计算机软件技术基础 复习题

第一章常用数据结构及算法

1.1 线性表逻辑结构及运算

例一.简单线性表举例：

La=（Sun，Mon，The，Wed，Thu，Fri，Sat），其中的元素是字符串，表的长度为7。

Lb=（84，79，95，72，90，74），其中的元素是整型，表的长度为6。

Lc=（stud1，stud2，……，stud30），其中的元素为下列结构体类型：

struct StudentInfo{

int No; //学号

char *name; //学生姓名

int age; //学生年龄

...;

}

例二.图书馆的书目检索系统，如下图所示。

由这三张表构成的文件便是自动检索系统的数学模型的主要部分，其中各个表之间存在着简单的线性关系，即数据结构。

1.2顺序表

例一.顺序存储结构线性表的典型操作算法。

类型定义如下：

数组形式类型定义指针形式类型定义

典型操作算法：

（1）初始化（2）销毁

例二.比较两个线性表的大小。

分析：

两个线性表的比较可以依据下列方法：设A、B是两个线性表，均用向量表示，表长分别为m和n。a和b分别为A 和B 中去除最大共同前缀后的子表。

如A=(x,y,z,y,z,x,z)，B=(x,y,z,z,y,x,x,z)，两表的最大共同前缀为(x,y,z) 。

则a=（y,z,x,z），b=（z,y,x,x,z），

若a=b= 空表，则A=B；

若a=空表且b≠空表，或两者均不空且a首元素小于b首元素，则A

否则，A>B。

算法思路：首先找出A、B的最大共同前缀；然后求出a和b，之后在按比较规则进行比较，

A>B 函数返回1；A=B返回0；A

算法如下：

int compare(int A[],int B[],int m,int n)

{

int i=0,j,a[],b[],ma=0,nb=0; /* ma,mb分别为a,b的长

度*/

while (A[i]==B[i]) i++; /*找最大共同前缀*/

for (j=i;j

{

a[j-i]=A[j];ms++; } /*求数组a*/

for (j=i;j

{

b[j-i]=B[j];ns++; } /*求数组b*/

if (ms==ns&&ms==0)

return 0;

else if (ms==0&&ns>0 || ms>0 && ns>0 &&

a[0]

return –1;

else

return 1;

}

例三.设数组R[0..n-1]的n个元素中（n>1）有多个零元素，试将R中所有非零元素依次移动到R 数组的前端R[0..i](0≤i≤n)中的算法。

参阅数组移动算法如下：

void move(int r[],int n)

{

int i=-1, j;

for(j=0;j<=n-1;j++)

{

if (r[j]!=0)

{

i++;r[i]=r[j];

if (i!=j)

r[j]=0;

}

}

1.3链表

例一.链式存储结构线性表的典型操作算法。

类型定义如下：

典型操作算法：

（1）初始化链表（2）销毁

int InitList(LINKLIST *L) {

L->head=(*LINKLIST)malloc(size

of(LINKLIST)); //为头结点分配存储单元

if (L->head)

{L->head->next=NULL; return 1;

else return 0 ;

}

（3）清空链表（4）求链表长度

void ClearList(LINKLIST *L) {

LINKLIST *p;

while (L->head->next) {

p=L->head->next; //p指向链表中头结点后面的第一个结点 L->head->next=p->next; //删除p结点

free(p); //释放p结点占据的存储空间

}

}

int ListLength(LINKLIST L) {

LINKLIST *p; int len;

for(p=L.head,

len=0;p->next==NULL;

p=p->next,len++);

return(len);

}

return 0;

s=(LINKLIST*)malloc(size of(LINKLIST));

if (s==NULL) return 0;

s->elem=e;

for

(p=L->head,j=0;p&&jne xt;j++); //寻找第i-1个结点

s->next=p->next;

p->next=s; //将s结点插入

return 1;

} return 0;

for(p=L->head,

j=0;jnext,j++);

s=p->next; //用s指向将要删除的结点

*e=s->elem;

p->next=s->next; //删除s 指向的结点

free(s);

return 1;

}

例二.假设单链表的表头指针用head表示，写出将其所有结点按相反次序链接的算法。

分析：

依次取原链表中的每个结点，将其作为第一个结点插入到新链表中去，指针p用来指向当前结点，p为空时结束。

参照算法如下：

void contrary(Linklist head)

{

LNode *p,*q,*s;

p=s=head; /*p指向第一个数据结点*/

head->next=NULL; /*将原链表置为空表*/

while (p)

{

q=p; p=p->next;

q->next=s; /*将当前结点插到头结点的后面*/

s->next=q;

}

head=s;

}

例三.已知单链表的表头指针用head表示，删除其重复结点。

分析：

用指针p指向第一个数据结点，从它的后继结点开始，查找与其值相同的结点并删除，直到表结束；p再指向下一个，依次类推，p指向最后结点时算法结束。

参照算法如下：

void DeleteList(LinkList head)

{

LNode *p,*q,*s;

p=head->next; /*p指向第一个结点*/

if(p==NULL) return;

while (p->next)

{

q=p;

while (q->next) /*从*p的后继开始找重复结点*/

{

if(q->next->data==p->data)

{ s=q->next; /* 找到重复结点，用s指向，删除*r

*/

q->next=s->next;

free(s);

}

else q=q->next;

}

p=p->next;/*p指向下一个，继续*/

}

}

1.4栈

例一.设计顺序栈的操作算法。 参阅程序代码如下：

（1）顺序栈的结构定义

（2）初始化栈

（3）入栈

（4）出栈

例二.将从键盘输入的字符序列逆置输出。 参照算法如下：

{

STACK s; /*定义一个栈结构S*/

char ch;

InitStack(&s); /*初始化栈*/

while ((ch=getchar())!='\n') /*从键盘输入字符，直到输入换行符为止*/ Push(&s ,ch); /*将输入的每个字符入栈*/

while (!StackIsEmpty(s)) /*依次退栈并输出退出的字符*/

{

Pop(&s,&ch);

putchar(ch);

}

putchar('\n');

}

1.5队列

例一.设计顺序队的操作算法。

参阅程序代码如下：

（1）循环队列的类型定义（2）初始化队

#define MAXSIZE 10 //队的大

小

typedef struct{

datatype data[MAXSIZE];

//存放队中数据元素的

存储单元

int front,rear; //队头队尾指

针

int num; //队中元素个数

} QUEUE;

（3）入队（4）出队

例二.构建杨辉三角。

分析：

第1 行 1 1

第2 行 1 2 1

第3 行 1 3 3 1

第4 行 1 4 6 4 1

可以看作求二项式系数：

设第i-1行的值为：(a[0]=0) a[1]..a[i] (a[i+1]=0)

则第i 行的值为： b[j] = a[j-1]+a[j], j=1,2,…,i+1

假设只计算三行，则队列的最大容量为5。如下图所示：

参照算法如下：

InSeq (&q,1); /* 第一行元素入队*/

/* 产生第n行元素并入队，同时打印第n-1行的元素*/

while(n<=N)

{

i=m; for(;i;i--) printf(" ");

m--;

InSeq (&q,1); /* 第n行的第一个元素入队*/

for(i=1;i<=n-2;i++)

/* 利用队中第n-1行元素产生第n行的中间n-2个元素并入队*/ {

OutSeq (&q,&temp);

printf("%d ",temp); /* 打印第n-1行的元素*/

GetHead(&q,&x);

temp=temp+x; /*利用队中第n-1行元素产生第n行元素*/ InSeq (&q,temp);

}

OutSeq (&q,&x);

printf("%d\n\n",x); /* 打印第n-1行的最后一个元素*/

InSeq (&q,1); /* 第n行的最后一个元素入队*/

n++;

}

}

1.6 二叉树

例一、将百分制转换为五级分制的程序。

分析：

该程序很容易实现，算法如下：

if (score<60) grade=”E”;

else if (score<70) grade=”D”

else if (score<80) grade=”C”

else if (score<90) grade=”B”

else grade=”A”;

该判定过程可以用下图所示的判定树来表示。

图（a）

如果上述程序需要反复使用，而且每次输入量很大，则应考虑效率问题，即其操作所需要的时间。因为在实际中，学生成绩在五个等级上的分布是不均匀的，假设其分布规律如下所示：

从表中可以看出80％以上的数据需进行三次或三次以上的比较才能得出结果。假定以5，15，40，30和10为权构造一棵有五个叶子结点的哈夫曼树，则可得到如图(b)所示的判定过程，它可使大部分的数据经过较少的比较次数得出结果。

图（b）

由于每个判定框都有两次比较，将这两次比较分开，得到如图(c)所示的判定树，按此判定树可写出相应的程序。假设有10000个输入数据，若按图(a)的判定过程进行操作，则总共需进行31500次比较；而若按图(c)的判定过程进行操作，则总共仅需进行22000次比较。

图（c）

例二.电文编码：

假定用于通信的电文为“ABACCDA”，其中由4个字母A，B，C，D组成，请设计编码方案。

分析：

编码方案1：电文中只有4个字母，可以使用2位二进制编码：

则上述电文编码为：00010010101100 共14位。译码时，只需每2位一译即可。特点：等长等频率编码，译码容易，但电文不一定最短。

编码方案2：采用不等长编码，让出现次数多的字符用短码：

则上述文字的电文为：000011010 共9位。但无法译码，它即可译为BBCCACA，也可译为AAAACCDA等。

编码方案3：采用不等长编码，让出现次数多的字符用短码，且任一编码不能是另一编码的前缀。

则上述文字的电文为：0110010101110 共13位。

对编码方案3有如下图所示赫夫曼树。

利用赫夫曼树可以构造一种不等长的二进制编码，并且构造所得的赫夫曼编码是一种最优前缀编码，即使所传电文的总长度最短。

例一.处理冲突的方法：

在长度为11的哈希表中已填有关键字分别为17,60,29的记录，现有第四个记录，其关键字为38，由哈希函数得到地址为5，若用线性探测再散列，如下：

例一.直接插入排序算法。

void INSERTSORT(rectype R[ ]) //对数组R按递增序进行插入排序, R[0]是监视哨{ int i, j;

for (i=2; i<=size; i++) //依次插入R[2], …, R[n]

{ R[0]=R[i];

j=i-1;

while (R[0].key

{ R[j+1]=R[j]; j--; } //将关键字大于R[i].key的记录后移

R[j+1]=R[0]; //插入R[i]

}

}

例二.快速排序算法。

int PARTITION(rectype R[ ], int l, int h) /* 返回划分后被定位的基准记录的位置*/ /* 对无序区R[l]～R[h]做划分*/

{ int i, j;

rectype temp;

i=l; j=h; temp=R[i]; /* 初始化，temp为基准*/

do

{ while ((R[j].key>=temp.key) && (i

j--; /* 从右向左扫描，查找第一个关键字小于temp.key的记录*/ if (i

while ((R[i].key<=temp.key) && (i

i++; /* 从左向右扫描，查找第一个关键字大于temp.key的记录*/ if (i

} while (i!=j);

R[i]=temp; /* 基准temp已被最后定位*/

return i;

}

void QUICKSORT(rectype R[ ], int s1, int t1) /* 对R[s1]～R[t1]做快速排序*/ { int i;

if (s1

{ i=PARTITION(R, s1, t1); /* 对R[s1]～R[t1]作划分*/

QUICKSORT(R, s1, i-1); /* 递归处理左区间*/

QUICKSORT(R, i+1, t1); /* 递归处理右区间*/

}

} /* QUICKSORT */

例三. 二路归并排序算法。

MERGEPASS(rectype R[ ], rectype R1[ ], int length)

/*对R做一趟归并，结果放在R1中；length是本趟归并的有序子件的长度 */ { int i, j;

i=0 ; /* I指向第一对子文件的起始点 */

while (i+2*length-1

{ MERGE(R, R1, i, i+length-1, i+2*length-1);

i=i+2*length; /* i指向下一对子文件的起始点 */

}

if (i+length-1)

else /* 子文件个数为奇数 */

for (j=i; j

MERGESORT(rectype R[ ]) /* 对R进行二路归并排序 */

{ int length;

length=1;

while (length

{ MERGEPASS(R, R1, length); /* 一趟归并，结果在R1中 */

length=2*length;

MERGEPASS(R1, R, length); /* 再次归并，结果在R中 */

length=2 *length; }

} /* MERGESORT */