实用数据结构基础(第三版)课后答案

单元练习1

四．分析下面各程序段的时间复杂度

1 O(n*m)（2） O(n2)（3） O(1)（4）O(n) （5） O(n2)

五．根据二元组关系，画出对应逻辑图形的草图，指出它们属于何种数据结构。

1

属于集合

（2）B=（D,R），其中：

属于线性结构

（3）属于树结

（4）

属于图结构

（5）属于树结

（6）单元练习2

四．分析下述算法的功能

（1）返回结点*p的直接前趋结点地址。

（2）交换结点*p和结点*q（p和q的值不变）。

五．程序填空

（1）已知线性表中的元素是无序的，并以带表头结点的单链表作存储。试写一算法，删除表中所有大于min，小于max的元素，试完成下列程序填空。

V oid delete (lklist head; datatype min, max)

{ q=head->next;

while (p!=NULL)

{ if ((p->data<=min ) | | (p->data>=max )

{q=p; p=p->next ; }

else

{ q->next=p->next ;

delete (p) ;

p=q->next ; }

}

}

（2）在带头结点head的单链表的结点a之后插入新元素x，试完成下列程序填空。

struct node

{ elemtype data;

node *next;

};

void lkinsert (node *head, elemtype x)

{ node *s, *p;

s=new node ;

s->data=x ;

p=head->next;

while (p!=NULL) && ( p->data!=a )

____p=p->next ;

if (p==NULL)

cout<< " 不存在结点a! ";

else {_____s->next=p->next______;

___ p->next=s __________;

}

}

六．算法设计题

（1）写一个对单循环链表进行遍历（打印每个结点的值）的算法，已知链表中任意结点的地址为P 。

解：

void Show(ListNode *P)

{ ListNode *t=P;

do

{ printf("%c",t->data);

t=t->rear;

}

while (t!=P);

}

（1）对给定的带头结点的单链表L，编写一个删除L中值为x的结点的直接前趋结点的算法。

解：

void delete(ListNode *L)

{ ListNode *p=L,*q;

if(L->next->data==X)

{

printf(“值为x的结点是第一个结点，没有直接前趋结点可以删除”);

return;

}

For(p->next->data!=X;q=p;p=p->next);// 删除指针p所指向的结点

q->next=p->next;

delete p;

}

（2）已知一个单向链表，编写一个函数从单链表中删除自第i个结点起的k个结点。解：

void Del(node *head,int i,int k)

{

node *p,*q;

int j;

if(i==1)

for(j=1;j<=k;j++) // 删除前k个元素

{

p=head; // p指向要删除的结点

head=head->next;

delete p;

}

else

{

p=head;

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

p=p->next; // p指向要删除的结点的前一个结点

for(j=1;j<=k;j++)

{

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

p->next=q->next;

delete q;

}

}

}

（3）有一个单向链表（不同结点的数据域值可能相同），其头指针为head，编写一个函数计算值域为x的结点个数。

解：//本题是遍历单链表的每个结点，每遇到一个结点，结点个数加1，结点个数存储在变量n中。实现本题功能的函数如下：

int counter(head)

node *head；

{ node *p;

int n=0;

p=head；

while(p!=NULL)

{ if(p->data==x)

n++；

p=p->next;

}

return(n);

}

（5）有两个循环单向链表，链头指针分别为head1和head2，编写一个函数将链表head1链接到链表head2，链接后的链表仍是循环链表。

解：//本题的算法思想是：先找到两链表的尾指针，将第一个链表的尾指针与第二个链表的头结点链接起来，使之成为循环的。函数如下：

node *link (node *head1, *head2)

{ node *p,*q;

p=head1;

while(p->next!=head1)

p=p->next;

q=head2;

while(q->next!=head2)

q=q->next;

p->next=head2;

q->next=head1;

return (head1);

}

单元练习3

四．应用题

（1）设有一个栈，元素进栈的次序为：A，B，C，D，E，用I表示进栈操作，O表示出栈操作，写出下列出栈的操作序列。

①C，B，A，D，E ②A，C，B，E，D

解：①IIIOOOIOIO

②IOIIOOIIOO

（2）求后缀表达式

①A^B^C/D

解：A B ^ C ^ D /

②-A+B*C+D/E

解：0 A – B C * + D E / +

③A*(B+C)*D-E

解：A B C + * D * E -

④(A+B)*C-E/(F+G/H)-D

解：A B + C * E F G H / + / - D -

⑤8/(5+2)-6

解：8 5 2 + / 6 -

六．算法设计题

（1）设用一维数组stack[n]表示一个堆栈，若堆栈中每个元素需占用M个数组单元（M>1）。

①试写出其入栈操作的算法。

②试写出其出栈操作的算法。

解：//用一整型变量top表示栈顶指针，top为0时表示栈为空。栈中元素从S [1]开始存放元素。

//①入栈算法：

void push (char x)

{

if ((top+M)>MAXLEN-1)

pr intf (“堆栈溢出！”);

else

{

if (top= =0)

{

top++;

S [top]=x;

}

else

{

top=top+M;

S [top]=x;

}

}

}

//②出栈算法：

void pop (char x)

{

if (top= =0)

printf (“堆栈为空栈！”);

else

{

if (top= =1)

{

x= S [top];

top––;

}

else

{

x= S [top];

top=top–M;

}

}

}

（2）设计一个算法，要求判别一个算术表达式中的圆括号配对是否正确。解：//设表达式在字符数组a[ ]中，使用一堆栈S来帮助判断。

int correct (char a[ ])

{

stack s ;

InitStack (s); //调用初始化栈函数

for (i=0; i

if (a[i]= =’(’)

Push (s,’(’);

else

if (a[i]= =’)’)

{

if StackEmpty (s) //调用判栈空函数

return 0; //若栈为空返回0；否则出栈

else

Pop(s);

}

if (StackEmpty (s) ) //调用判栈空函数

printf (“配对正确！”); //若栈空，说明配对正确，并返回1

else

printf (“配对错误！”); //配对错误返回0

}

（3）设计一个将十进正整数转换为十进制数的算法，并要求上机调试通过。

解：#include

#include

typedef struct stacknode //定义栈的存储结构

{

int data;

struct stacknode *next;

}stacknode;

typedef struct

{

stacknode *top; //定义栈顶的指针

}linkstack;

void Conversion(int n) //栈的应用：十——十六进制转换{ linkstack s;

int x;

s.top=NULL; //置栈空

do

{ x=n%16; //取余数

n= n/16 ; //取新的商

stacknode *p=new stacknode; //申请新结点

p->next=s.top ; //修改栈顶指针

s.top=p;

s.top->data=x; //余数入栈

}

while(n);

printf("\n\t\t转换后的十六进制数值为：";

while (s.top) //出栈处理

{ if(s.top->data<10);

printf("%d",s.top->data);

else

switch(s.top->data)

{

case 10: printf("%c",'A');break;

case 11: printf("%c",'B');break;

case 12: printf("%c",'C');break;

case 13: printf("%c",'D');break;

case 14: printf("%c",'E');break;

case 15: printf("%c",'F');break;

}

stacknode *p=s.top;

s.top=s.top->next;

free(p) ; //出栈一个余数，收回一个结}

printf("\n\n");

}

void main()

{

int n;

printf("\n\t\t请输入一个十进制正整数：");

scanf("%d",&n);

Conversion(n);

}

单元练习4

五．程序填空

假定用一个循环单链表表示一个循环队列，该队列只设一个队尾指针rear，试填空完成向循环队列中插入一个元素为x的结点的函数。

typedef struct queuenode // 定义队列的存储结构

{ int data;

struct queuenode *next;

}QueueNode;

InQueue(QueueNode *rear,int x) // 向队列插入元素为x的函数{ QueueNode *rear;

QueueNode *head,*s;

s= new QueueNode ;

s->data= x ;

if(rear==NULL) // 循环队列为空，则建立一个结点的循环队列

{ rear=s; rear->next;}

else

{ head= rear->next ; // 循环队列非空，则将s插到后面

rear->next= s ;

rear=s;

rear->next =head;

}

}

六. 算法设计题

（1）设一个循环队列Queue，只有头指针front，不设尾指针，另设一个含有元素个数的记数器cont，试写出相应的入队算法和出队算法。

解：

//入队算法：

void inqueqe(int x)

{ int temp;

if (count==n)

printf(" 队列上溢出\n");

else

{ count++

temp=(front+count)%n;

Queue[temp]=x

}

}

//出队算法：

int outqueue()

{ int temp;

if(count==0)

printf(" 队列下溢出\n");

else

{ temp=Queue[front];

front=(front+1)%n;

count--;

return temp;

}

}

（2）用一个循环数组Q[0..MAXLEN-1]表示队列时，该队列只有一个头指针front，不设尾指针，而改置一个记数器count用以记录队列中结点的个数。试编写一个能实现：初始化队列、判队空、读队头元素、入队操作和出队操作的算法。

解：//用一个循环数组Queue[0，n-1]表示该循环队列，头指针为front，计数器count 用来记录队列中结点的个数。

//队列为空：count==0

//队列为满：count=MAXLEN

//队尾第一个元素位置==(front+count)%MAXLEN

//队首第一个元素位置==(front+1)%MAXLEN

const MAXLEN=100;

int queue[MAXLEN];

int front,count; // 定义队头和计数器count

①初始化队列

void init()

{

front=1;

count=0;

}

②判定队空

int QEmpty()

{

if (count==0)

return(1);

else

return(0);}

③读队头元素

void ReadFront(int queue[],x)

{

if (count==0)

printf(" 下溢出\n");

else

{

front=(front+1)%MAXLEN;

x=queue[front];

}

}

④入队操作

void InQueue(int queue[],int x)

{

int place;

if (count==MAXLEN)

printf(" 上溢出\n");

else

{

count++;

place=(front+count)%MAXLEN;

queue[MAXLEN]=x;

}

}

⑤出队操作

void OutQueue(int queue[]) // 删除队列头元素

{

if (count==0)

printf(" 队列下溢出\n");

else

{

front=(front+1)%MAXLEN;

count--;

}

}

（3）一个用单链表组成的循环队列，只设一个尾指针rear，不设头指针，请编写他如下算法：

①向循环队列中插入一个元素为x的结点；

②从循环队列中删除一个结点。

①解：//定义本题队列的结点类型如下：

typedef struct linknode

{

int data;

struct linknode *next;

}QueueNode;

QueueNode *rear;

Inqueue(int x) // 向队列插入结点x

{

QueueNode *head, *s;

s=(qu *) new qu; // 创建一个新结点

s->data=x;

if(rear==NUlL) // 若队空,则建立一个循环队列

{

rear=s;

rear->next=s;

}

else // 若不为空，则将s插到后面

{

head=rear->next；

rear->next=s;

rear=s; // rear始终指向最后一个结点

rear->next=head;

}

}

②解：

void delqueue(rear)

{

if(rear==NULL)

printf(" 下溢出!\n");

else

{

head=rear->next; // head指向队首结点

if(head==rear)

rear=NULL // 只有—个结点则直接删除该结点else

rear->next=head->next // 否则删除第一个结点

delete head；// 释放队首结点

}

}

单元练习5

四．程序题填空

（1）下面程序是把两个串r1和r2首尾相连的程序，即：r1=r1+r2，试完成程序填空。

typedef Struct

{ char vec[MAXLEN]; // 定义合并后串的最大长度

int len; // len为串的长度

}St ;

void ConcatStr(Str *r1,Str *r2) // 字符串连接函数

{ int i;

cout<vec<vec;

if(r1->len+r2->len>MAXLEN )

cout<<"两个串太长，溢出！";

else

{ for(i=0;ilen ;i++) // 把r2连接到r1

r1->vec[r1->len+i ]=r2->vec[i];

r1->vec[r1->len+i]='\0' ; // 添上字符串结束标记

r1->len=r1->len+r2->len ; // 修改新串长度

}

}

（2）设x和y两个串均采用顺序存储方式，下面的程序是比较x 和y两个串是否相等的函数，试完成程序填空。

#define MAXLEN 100

typedef struct

{ char vec[MAXLEN]; len;

} str;

int same (x,y)

str *x,*y;

{ int i=0,tag=1;

if (x->len!= y->len) return (0); // (或<> )

else

{ while ( ilen&& tag )

{ if ( x->vec[i] != y->vec[i] ) tag=0 ;

i++ ; （或i=i+1 ）

}

return (tag);

}

}

（4）下面算法是判断字符串是否为回文（即正读和倒读相同），试完成程序填空。

#include "stdio.h"

typedef struct

{ char vec[MAXLEN];

int len;

}str;

void Palindrome (str s)

{ int i=0;

ing j= s.len-1 ;

while (j-i>=1 )

{ if ( s.vec[i]==s.vec[j] )

{i++;j-- ;continue} // (或j=j+1 )

else

break;

}

if (j-i>=1 )

cout<<"It is not a palindrome\n";

else

cout<<"It is a palindrome\n";

}

五．编程题

（1）设下面所用的串均采用顺序存储方式，其存储结构定义如下，请编写下列算法：#define MAXLEN 100

typedef struct

{ char vec[MAXLEN];

int len;

} str;

①将串中r中所有其值为ch1的字符换成ch2的字符。

②将串中r中所有字符按照相反的次序仍存放在r中。

③从串r中删除其值等于ch的所有字符。

④从串r1中第index个字符起求出首次与字符r2相同的子串的起始位置。

⑤从串r中删除所有与串r3相同的子串（允许调用第（4）小题的函数）。

⑥编写一个比较x 和y两个串是否相等的函数。

解：

①//算法思想：从头至尾扫描r串，对于值为ch1的元素直接替换成ch2即可。

str *trans(r,ch1,ch2)

str *r;

char ch1,ch2;

{ int i;

for(i=0;ilen;i++)

if(r->vec[i]==ch1)

r-vec[i]=ch2;

return(r);

}

②//算法思想是：将第一个元素与最后一个元素交换，第二个元素与倒数第二个元素交换，依次类推，便将该串的所有字符反序了。

str *invert (r)

str *r;

{ int i;

char x;

for(i=0;i<(r->len%2);i++)

{ x=r->vec[i];

r->vec[i]=r->[r->len-i+1];

r->vec[r->len-i+1]=x;

}

return (r );

}

③//算法思想：从头到尾扫描r串，对于值为ch的元素用移动的方式进行删除。

str *delall(r,ch)

str *r;

char ch;

{ int i,j;

for(i=0;ilen;i++)

if(r->vec[i]==ch)

{

for(j=i;jlen;j++)

r->vec[i]=r->vec[i+1];

r->len=r->len-1;

}

return (r );

}

④//算法思想：从第index个元素开始扫描r1，当其元素值与r2的第一个元素的值相同时，判定它们之后的元素值是否依次相同，直到r2结束为止，若都相同则返回，否则继续上述过程直到r1扫描完为止。

int partposition(r2,r1,index)

str *r2, *r1;

int index;

{ int i,j,k;

for(i=index;r1->vec[i];i++)

for(j=i,k=0;r1->vec[j]==r2->vec[k];j++,k++)

if(!r2->vec[k+1])

return(i);

return(-1);

}

⑤算法思想：从位置1开始调用第（4）小题的函数partposition（），若找到了一个相同子串，则调用delsubstring（），再相同的方法查找后面位置的相同子串。

str *delstringall(r,r3)

str *r, *r3;

{ int i=0;

while(ilen)

{ if(partposition(r,r3,i)!=-1)

delsubstring(r,i,r3->len)

i++;

}

}

⑥两个串相等的条件是两个串的长度相等，且两个串的对应的字符必须都相同。

int same(x,y)

str *x,*y;

{ int i=0,tag=1;

if(x->len!=y->len)

return(0);

else

{ while(ilen && tag)

{ if(x->vec[i]!=y->vec[i])

tag=0;

i++;

}

return(tag);

}

}

（2）设计一算法判断字符串是否为回文（即正读和倒读相同）

解：#include "stdio.h"

typedef struct

{ char *head;

int length;

}Hstring;

void isPalindrome(Hstring s)

{

int i=0;

int j=s.length-1;

while(j-i>=1)

{

if (s.head[i]==s.head[j])

{i++; j--; continue;}

else

break;

}

if(j-i>=1)

printf("Tt is not a palindrome\n ");

else

printf("it is a palindrome\n");

}

（3）设计一算法从字符串中删除所有与字串"del"相同的子串

解：#include "stdio.h"

#include "string.h"

typedef struct

{ char *head;

int length;

}Hstring;

char *DeleteSubString(Hstring S,Hstring T)

{

int i=0;

int j,k;

int Slength=S.length;

int Tlength=T.length;

char *tail;

while(i<=Slenght-Tlength)

{

j=0;k=i;

while (j

{j++; k++;}

if(j==Tlength) // 若匹配则执行下面的程序

{

if (i==0) // 若位于头位置则改变头指针

{

S.head=S.head+Tlength;

S.length-=Tlength;

Slength-=Tlength;

i=0;

}

else

if (i+Tlength

{

tail=S.head+i+Tlength;

strcpy(S.head+i,tail);

S.length-=Tlength;

Slength-=Tlength;

}

else // 若位于尾部则割去

strncpy(S.head+i,”\0”,1);

}

else // 若不匹配则i加1

i++;

}

return S.head;

}

（4）设计一算法统计字符串中否定词"not"的个数

解：#include "stdio.h"

#include "string.h"

int Find_word(char *text, const char *word)

{ int textlength=strlen(text);

int wordlength=strlen(word);

int i,j,k;

int count=0;

for(i=0;i

{ j=0;k=i;}

while(j

{ j++;k++;}

if(j==wordlength&&word[j]==’\0’) // 匹配成功计数器加1

count++;

}

return count;

单元练习6

四．算法阅读题

（1）已知A[]是一个下三角矩阵，下述算法的功能是什么？

int f1(int A[],int n)

{ int i,k,s=0; // 设B[0..(n+1)n/2-1]存放下三角元素

k=0;

s=A[0];

for(i=0;i

{ k=k+i+2;

s=s+A[k];

}

return s;

}

算法功能：求矩阵主对角线上元素之和。

分析：注意k的变化依次为：0，2，5，9，14，正好是a ii在A中的存储位置。在循环中k 每次增加i+2。

第i行主对角线上的元素a ii，其在A中的位置为:

i(i+1)/2+i；(1)

第i+1行主对角线上的元素a i+1 i+1，其在A中的位置为:

(i+1)(i+2)/2+(i+1), (2)

(2)-(1)得i-2。

（2）在按行优先顺序存储的三元组表中，求某列非零元素之和的算法如下，填空以完成算法。

#define SMAX 100 // 定义一个足够大的三元组表

typedef struct

{

int i,j,v; // 非零元素的行、列、值

}SPNode; // 三元组类型

typedef struct // 定义稀疏矩阵

{ int m,n,t; // 矩阵的行、列及非零元素的个数

SPNode data[SMAX]; // 三元组表

}SPMatrix; // 三元组表的存储类型

if f2(SPNode *a,col)

{ // 求第col列非零元素之和

int k,sum=0;

if( ①a->t<=0 )

printf(“a<=0”);

if( ②col<0 || col >=a->n )

printf(“列错！”);

for(③k=0 ; kt ; ④k++ )

if (a->tada[k].j==n)

sum= ⑤sum + a->data[k].v ;

return sum;

}

单元练习7

一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）

四. 简答题

（1）已知一棵树边的集合如下，请画出此树，并回答问题。

{(L,M),(L,N),(E,L),(B,E),(B,D),(A,B),(G,J),(G,K),(C,G),(C,F),(H,I),(C,H),(A,C)}

①哪个是根结点？②哪些是叶结点？③哪个是G的双亲？

④哪些是G的祖先？⑤哪些是G的孩子？⑥哪些是E的子孙？

⑦哪些是E的兄弟？哪些是F的兄弟？⑧结点B和N的层次各是多少？

⑨树的深度是多少？⑩以结点C为根的子树的深度是多少？

?树的度数是多少？

答：

①A是根结点。

②叶结点：M，N，D，J，K，F，I。

③G的双亲：C。

④G的祖先：A，C。

⑤G的孩子：J，K。

⑥E的子孙：L，M，N。

⑦E的兄弟：D；F的兄弟：G，H。

⑧结点B的层次为2；结点N的层次是5。

⑨树的深度是5。

⑩以结点C为根的子树的深度是3。

?树的度数是3。

（2）设下列二叉树是与某森林对应的二叉树，试回答下列问题。

①森林中有几棵树？

②每一棵树的根结点分别是什

么？

③第一棵树有几个结点？

④第二棵树有几个结点？

⑤森林中有几个叶结点？

解：①4

②A,C,G,K

③6

④2

⑤7

（3）二叉树按中序遍历的结果为：ABC，试问有几种不同形态的二叉树可以得到这一遍历结果？并画出这些二叉树。

答：有5种不同形态的二叉树可以得到这一遍历结果，如下图所示。

（4）分别画出具有3个结点的树和3个结点的二叉树的所有不同形态。 答：

3个结点的树：

3个结点的二叉树树：

五. 应用题

（1）已知一棵二叉树的后序遍历和中序遍历的序列分别为：ACDBGIHFE 和ABCDEFGHI 。

请画出该二叉树，并写出它的前序遍历的序列。 解：恢复的二叉树为：

其前序遍历的序列为：E B A D C F H G I

（2）已知一棵二叉树的前序遍历和中序遍历的序列分别为：ABDGHCEFI 和GDHBAECIF 。

请画出此二叉树，并写出它的后序遍历的序列。

其后序遍历的序列为：G H D B E I F C A

（3）已知一棵树的层次遍历的序列为：ABCDEFGHIJ ，中序遍历的序列为：DBGEHJACIF ，

请画出该二叉树，并写出它的后序遍历的序列。 解：

后序遍历的序列：D G J H E B I F C A （4） 把下列一般树转换为二叉树

①

（5）把下列森林转换为二叉树

②

解：

（6）把下列二叉树还原为森林

解：还原后的二叉树为：

②

（7）某二叉树的结点数据采用顺序存储，其结构如下：

① 画出该二叉树（3分）

② 写出按层次遍历的结点序列（2分） 解：