数据结构c语言描述第二版答案耿国华西安电子科技大学.docx

数据结构c语言描述第二版答案耿国华西安电子科技大学.docx

《数据结构c语言描述第二版答案耿国华西安电子科技大学.docx》由会员分享，可在线阅读，更多相关《数据结构c语言描述第二版答案耿国华西安电子科技大学.docx（22页珍藏版）》请在冰豆网上搜索。

数据结构c语言描述第二版答案耿国华西安电子科技大学

第1章绪论

2.

（1）×

（2）×（3）√

3.

（1）A

（2）C（3）C

5.计算下列程序中x=x+1的语句频度

for（i=1;i<=n;i++）

for（j=1;j<=i;j++）

for（k=1;k<=j;k++）

x=x+1;

【解答】x=x+1的语句频度为：

T（n）=1+（1+2）+（1+2+3）+……+（1+2+……+n）=n（n+1）（n+2）/6

6.编写算法，求一元多项式pn（x）=a0+a1x+a2x2+…….+anxn的值pn（x0）,并确定算法中每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能小，规定算法中不能使用求幂函数。

注意：

本题中的输入为ai（i=0,1,…n）、x和n,输出为Pn（x0）。

算法的输入和输出采用下列方法

（1）通过参数表中的参数显式传递

（2）通过全局变量隐式传递。

讨论两种方法的优缺点，并在算法中以你认为较好的一种实现输入输出。

【解答】

（1）通过参数表中的参数显式传递

优点：

当没有调用函数时，不占用内存，调用结束后形参被释放，实参维持，函数通用性强，移置性强。

缺点：

形参须与实参对应，且返回值数量有限。

（2）通过全局变量隐式传递

优点：

减少实参与形参的个数，从而减少内存空间以及传递数据时的时间消耗

缺点：

函数通用性降低，移植性差

算法如下：

通过全局变量隐式传递参数

PolyValue（）

{inti,n;

floatx,a[],p;

printf（“\nn=”）;

scanf（“%f”,&n）;

printf（“\nx=”）;

scanf（“%f”,&x）;

for（i=0;i

scanf（“%f”,&a[i]）;/*执行次数：

n次*/

p=a[0];

for（i=1;i<=n;i++）

{p=p+a[i]*x;/*执行次数：

n次*/

x=x*x;}

printf（“%f”,p）;

}

算法的时间复杂度：

T（n）=O（n）

通过参数表中的参数显式传递

floatPolyValue（floata[],floatx,intn）

{

floatp,s;

inti;

p=x;

s=a[0];

for（i=1;i<=n;i++）

{s=s+a[i]*p;/*执行次数:

n次*/

p=p*x;}

return（p）;

}

算法的时间复杂度：

T（n）=O（n）

第2章线性表

习题

1.填空：

（1）在顺序表中插入或删除一个元素，需要平均移动一半元素，具体移动的元素个数与插入或删除的位置有关。

（2）线性表有顺序和链式两种存储结构。

在顺序表中，线性表的长度在数组定义时就已经确定，是静态保存，在链式表中，整个链表由“头指针”来表示，单链表的长度是动态保存。

（3）在顺序表中，逻辑上相邻的元素，其物理位置＿一定＿＿＿＿＿相邻。

在单链表中，逻辑上相邻的元素，其物理位置不一定相邻。

（4）在带头结点的非空单链表中，头结点的存储位置由头指针指示，首元素结点的存储位置由头结点指示，除首元素结点外，其它任一元素结点的存储位置由其直接前趋的next域指示。

2.选择题

（1）A

（2）已知L是无表头结点的单链表，且P结点既不是首元素结点，也不是尾元素结点。

按要求从下列语句中选择合适的语句序列。

a.在P结点后插入S结点的语句序列是：

E、A。

b.在P结点前插入S结点的语句序列是：

H、L、I、E、A。

c.在表首插入S结点的语句序列是：

F、M。

d.在表尾插入S结点的语句序列是：

L、J、A、G。

供选择的语句有：

AP->next=S;

BP->next=P->next->next;

CP->next=S->next;

DS->next=P->next;

ES->next=L;

FS->next=NULL;

GQ=P;

Hwhile（P->next!

=Q）P=P->next;

Iwhile（P->next!

=NULL）P=P->next;

JP=Q;

KP=L;

LL=S;

ML=P;

（3）D

（4）D

（5）D

（6）A

7试分别以不同的存储结构实现单线表的就地逆置算法，即在原表的存储空间将线性表（a1,a2,…,an）逆置为（an,an-1,…,a1）。

【解答】

（1）用一维数组作为存储结构

    void invert（SeqList *L, int *num）

{ 

 int j;

 ElemType tmp;

for（j=0;j<=（*num-1）/2;j++）

{tmp=L[j];

L[j]=L[*num-j-1];

L[*num-j-1]=tmp;}

}

（2）用单链表作为存储结构

  void invert（LinkList L）

 {

Node *p,*q,*r;

   if（L->next==NULL） return;         /*链表为空*/

   p=L->next;   

   q=p->next;              

p->next=NULL;             /*摘下第一个结点，生成初始逆置表*/

while（q!

=NULL）            /*从第二个结点起依次头插入当前逆置表*/

  {

r=q->next;

q->next=L->next;

L->next=q;

q=r;

 }

}

11将线性表A=（a1,a2,……am）,B=（b1,b2,……bn）合并成线性表C,C=（a1,b1,……am,bm,bm+1,…….bn） 当m<=n时，或C=（a1,b1,……an,bn,an+1,……am）当m>n时,线性表A、B、C以单链表作为存储结构，且C表利用A表和B表中的结点空间构成。

注意：

单链表的长度值m和n均未显式存储。

【解答】算法如下：

LinkList merge（LinkList A, LinkListB, LinkList C）

{Node *pa,*qa,*pb,*qb,*p;

 pa=A->next;                   /*pa表示A的当前结点*/

 pb=B->next; 

p=A; /*利用p来指向新连接的表的表尾，初始值指向表A的头结点*/

 while（pa!

=NULL && pb!

=NULL）  /*利用尾插法建立连接之后的链表*/

{  qa=pa->next;

qb=qb->next;

 p->next=pa;  /*交替选择表A和表B中的结点连接到新链表中；*/

p=pa;

p->next=pb;

p=pb;                      

printf（"请输入第一个报数上限值m（m>0）:

"）;

 scanf（"%d",&m）;

 printf（"*****************************************\n"）;

 printf（"出列的顺序为:

\n"）;

 q=L;

 p=L->next;

 while（n!

=1）                       /*计算出列的顺序*/

 {

        j=1;

      while（j

      {

               q=p;              /*q为当前结点p的前驱结点*/

            p=p->next;

            j++;

      }

      printf（"%d->",p->num）;

      m=p->password;                /*获得新密码*/

      n--;                

      q->next=p->next;   /*p出列*/

      r=p;

      p=p->next;

      free（r）;

   }

  printf（"%d\n",p->num）;

}

第3章限定性线性表—栈和队列

第三章答案

1按3.1（b）所示铁道（两侧铁道均为单向行驶道）进行车厢调度，回答：

（1）如进站的车厢序列为123，则可能得到的出站车厢序列是什么？

（2）如进站的车厢序列为123456，能否得到435612和135426的出站序列，并说明原因（即写出以“S”表示进栈、“X”表示出栈的栈序列操作）。

【解答】

（1）可能得到的出站车厢序列是：

123、132、213、231、321。

（2）不能得到435612的出站序列。

因为有S

（1）S

（2）S（3）S（4）X（4）X（3）S（5）X（5）S（6）S（6），此时按照“后进先出”的原则，出栈的顺序必须为X

（2）X

（1）。

能得到135426的出站序列。

因为有S

（1）X

（1）S

（2）S（3）X（3）S（4）S（5）X（5）X（4）X

（2）X

（1）。

3给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？

【解答】

（1）顺序栈（top用来存放栈顶元素的下标）

判断栈S空：

如果S->top==-1表示栈空。

判断栈S满：

如果S->top==Stack_Size-1表示栈满。

（2）链栈（top为栈顶指针，指向当前栈顶元素前面的头结点）

判断栈空：

如果top->next==NULL表示栈空。

判断栈满：

当系统没有可用空间时，申请不到空间存放要进栈的元素，此时栈满。

4照四则运算加、减、乘、除和幂运算的优先惯例，画出对下列表达式求值时操作数栈和运算符栈的变化过程：

A-B*C/D+E↑F

【解答】

5写一个算法，判断依次读入的一个以@为结束符的字母序列，是否形如‘序列1&序列2’的字符序列。

序列1和序列2中都不含‘&’，且序列2是序列1的逆序列。

例如，’a+b&b+a’是属于该模式的字符序列，而’1+3&3-1’则不是。

【解答】算法如下：

intIsHuiWen（）

{

Stack*S;

Charch,temp;

InitStack（&S）;

Printf（“\n请输入字符序列：

”）;

Ch=getchar（）;

While（ch!

=&）/*序列1入栈*/

{Push（&S,ch）;

ch=getchar（）;

}

do/*判断序列2是否是序列1的逆序列*/

{ch=getchar（）;

Pop（&S,&temp）;

if（ch!

=temp）/*序列2不是序列1的逆序列*/

{return（FALSE）;printf（“\nNO”）;}

}while（ch!

=@&&!

IsEmpty（&S））

if（ch==@&&IsEmpty（&S））

{return（TRUE）;printf（“\nYES”）;}/*序列2是序列1的逆序列*/

else

{return（FALSE）;printf（“\nNO”）;}

}/*IsHuiWen（）*/

8要求循环队列不损失一个空间全部都能得到利用，设置一个标志tag,以tag为0或1来区分头尾指针相同时的队列状态的空与满，请编写与此相应的入队与出队算法。

【解答】入队算法：

intEnterQueue（SeqQueue*Q,QueueElementTypex）

{/*将元素x入队*/

if（Q->front==Q->front&&tag==1）/*队满*/

return（FALSE）;

if（Q->front==Q->front&&tag==0）/*x入队前队空，x入队后重新设置标志*/

tag=1;

Q->elememt[Q->rear]=x;

Q->rear=（Q->rear+1）%MAXSIZE;/*设置队尾指针*/

Return（TRUE）;

}

出队算法：

intDeleteQueue（SeqQueue*Q,QueueElementType*x）

{/*删除队头元素，用x返回其值*/

if（Q->front==Q->rear&&tag==0）/*队空*/

return（FALSE）;

*x=Q->element[Q->front];

Q->front=（Q->front+1）%MAXSIZE;/*重新设置队头指针*/

if（Q->front==Q->rear）tag=0;/*队头元素出队后队列为空，重新设置标志域*/

Return（TUUE）;

}

第4章串

第四章答案

1设s=’IAMASTUDENT’，t=’GOOD’，q=’WORKER’。

给出下列操作的结果：

【解答】StrLength（s）=14;

SubString（sub1,s,1,7）sub1=’IAMA’;

SubString（sub2,s,7,1）sub2=’’;

StrIndex（s,4,’A’）=6;

StrReplace（s,’STUDENT’,q）;s=’IAMAWORKER’;

StrCat（StrCat（sub1,t）,StrCat（sub2,q））sub1=’IAMAGOODWORKER’。

2编写算法，实现串的基本操作StrReplace（S,T,V）。

【解答】算法如下：

intstrReplace（SStringS,SStringT,SStringV）

{/*用串V替换S中的所有子串T*/

intpos,i;

pos=strIndex（S,1,T）;/*求S中子串T第一次出现的位置*/

if（pos==0）return（0）;

while（pos!

=0）/*用串V替换S中的所有子串T*/

{

switch（T.len-V.len）

{

case0:

/*串T的长度等于串V的长度*/

for（i=0;i<=V.len;i++）/*用V替换T*/

S->ch[pos+i]=V.ch[i];

case>0:

/*串T的长度大于串V的长度*/

for（i=pos+t.ien;ilen;i--）/*将S中子串T后的所有字符

S->ch[i-t.len+v.len]=S->ch[i];前移T.len-V.len个位置*/

for（i=0;i<=V.len;i++）/*用V替换T*/

S->ch[pos+i]=V.ch[i];

S->len=S->len-T.len+V.len;

case<0:

/*串T的长度小于串V的长度*/

if（S->len-T.len+V.len）<=MAXLEN/*插入后串长小于MAXLEN*/

{/*将S中子串T后的所有字符后移V.len-T.len个位置*/

for（i=S->len-T.len+V.len;i>=pos+T.len;i--）

S->ch[i]=S->ch[i-T.len+V.len];

for（i=0;i<=V.len;i++）/*用V替换T*/

S->ch[pos+i]=V.ch[i];

S->len=S->len-T.len+V.len;}

else

{/*替换后串长>MAXLEN,但串V可以全部替换*/

if（pos+V.len<=MAXLEN）

{for（i=MAXLEN-1;i>=pos+T.len;i--）

S->ch[i]=s->ch[i-T.len+V.len]

for（i=0;i<=V.len;i++）/*用V替换T*/

S->ch[pos+i]=V.ch[i];

S->len=MAXLEN;}

else/*串V的部分字符要舍弃*/

{for（i=0;i

S->ch[i+pos]=V.ch[i];

S->len=MAXLEN;}

}/*switch（）*/

pos=StrIndex（S,pos+V.len,T）;/*求S中下一个子串T的位置*/

}/*while（）*/

return

（1）;

}/*StrReplace（）*/

第五章数组和广义表

第五章答案

1.假设有6行8列的二维数组A，每个元素占用6个字节，存储器按字节编址。

已知A的基地址为1000，计算：

（1）数组A共占用多少字节；（288）

（2）数组A的最后一个元素的地址；（1282）

（3）按行存储时，元素A36的地址；（1126）

（4）按列存储时，元素A36的地址；（1192）

4.设有三对角矩阵An×n,将其三条对角线上的元素逐行的存于数组B[1..3n-2]中，使得B[k]=aij，求：

（1）用i,j表示k的下标变换公式；

（2）用k表示i、j的下标变换公式。

【解答】

（1）k=2（i-1）+j

（2）i=[k/3]+1,j=[k/3]+k%3（[]取整，%取余）

5.在稀疏矩阵的快速转置算法5.2中，将计算position[col]的方法稍加改动，使算法只占用一个辅助向量空间。

【解答】算法

（一）

FastTransposeTSMatrix（TSMartrixA,TSMatrix*B）

{/*把矩阵A转置到B所指向的矩阵中去，矩阵用三元组表表示*/

intcol,t,p,q;

intposition[MAXSIZE];

B->len=A.len;B->n=A.m;B->m=A.n;

if（B->len>0）

{

position[1]=1;

for（t=1;t<=A.len;t++）

position[A.data[t].col+1]++;/*position[col]存放第col-1列非零元素的个数,即利用pos[col]来记录第col-1列中非零元素的个数*/

/*求col列中第一个非零元素在B.data[]的位置，存放在position[col]中*/

for（col=2;col<=A.n;col++）

position[col]=position[col]+position[col-1];

for（p=1;p

{

col=A.data[p].col;

q=position[col];

B->data[q].row=A.data[p].col;

B->data[q].col=A.data[p].row;

B->data[q].e=A.data[p].e;

Position[col]++;

}

}

}

算法

（二）

FastTransposeTSMatrix（TSMartrixA,TSMatrix*B）

{

intcol,t,p,q;

intposition[MAXSIZE];

B->len=A.len;B->n=A.m;B->m=A.n;

if（B->len>0）

{

for（col=1;col<=A.n;col++）

position[col]=0;

for（t=1;t<=A.len;t++）

position[A.data[t].col]++;/*计算每一列的非零元素的个数*/

/*从最后一列起求每一列中第一个非零元素在B.data[]中的位置，存放在position[col]中*/

for（col=A.n,t=A.len;col>0;col--）

{t=t-position[col];

position[col]=t+1;

}

for（p=1;p

{

col=A.data[p].col;

q=position[col];

B->data[q].row=A.data[p].col;

B->data[q].col=A.data[p].row;

B->data[q].e=A.data[p].e;

Position[col]++;

}

}

}

8.画出下面广义表的两种存储结构图示：

（（（（a）,b））,（（（）,d）,（e,f）））

【解答】

第一种存储结构

第二种存储结构

9.求下列广义表运算的结果：

（1）HEAD[（（a,b）,（c,d））];（a,b）

（2）TAIL[（（a,b）,（c,d））];（（c,d））

（3）TAIL[HEAD[（（a,b）,（c,d））]];（b）

（4）HEAD[TAIL[HEAD[（（a,b）,（c,d））]]];b

（5）TAIL[HEAD[TAIL[（（a,b）,（c,d））]]];（d）

第六章

第六章答案

6．1分别画出具有3个结点的树和3个结点的二叉树的所有不同形态。

【解答】

具有3个结点的树具有3个结点的二叉树

6.3已知一棵度为k的树中有n1个度为1的结点，n2个度为2的结点，……，nk个度为k的结点，则该树中有多少个叶子结点？

【解答】设树中结点总数为n,则n=n0+n1+……+nk

树中分支数目为B,则B=n1+2n2+3n3+……+knk

因为除根结点外，每个结点均对应一个进入它的分支，所以有n=B+1

即n0+n1+……+nk=n1+2n2+3n3+……+knk+1

由上式可得叶子结点数为：

n0=n2+2n3+……+（k-1）nk+1

6.5已知二叉树有50个叶子结点，则该二叉树的总结点数至少应有多少个？

【解答】n0表示叶子结点数，n2表示度为2的结点数，则n0=n2+1

所以n2=n0–1=49，当二叉树中没有度为1的结点时，总结点数n=n0+n2=99

6.6试分别找出满足以下条件的所有二叉树:

（1）前序序列与中序序列相同;

（2）中序序列与后序序列相同;

（3）前序序列与后序序列相同。

【解答】

（1）前序与中序相同：

空树或缺左子树的单支树；

（2）中序与后序相同：

空树或缺右子树的单支树；

（3）前序与后序相同：

空树或只有根结点的二叉树。

6.9假设通讯的电文仅由8个字母组成，字母在电文中出现的频率分别为：

0.07，0.19，0.02，0.06，0.32，0.03，0.21，0.10

请为这8个字母设计哈夫曼编码。

【解答】

构造哈夫曼树如下：

哈夫曼编码为：

I1：

11111I5：

1100

I2：

11110I6：

10

I3：

1110I7：

01

I4：

1101I8：

00

6.11画出如下图所示树对应的二叉树。

【解答】

6.16分别写出算法，实现在中序线索二叉树T中查找给定结点*p在中序序列中的前驱与后继。

在先序线索二叉树T中，查找给定结点*p在先序序列中的后继。

在后序线