严蔚敏数据结构题集(C语言版)完整答案

第1章绪论1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

1.3 设有数据结构(D,R)，其中{}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。

解：1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADT Complex{数据对象：D={r,i|r,i 为实数}数据关系：R={<r,i>}基本操作：InitComplex(&C,re,im)操作结果：构造一个复数C，其实部和虚部分别为re和im DestroyCmoplex(&C)操作结果：销毁复数CGet(C,k,&e)操作结果：用e返回复数C的第k元的值Put(&C,k,e)操作结果：改变复数C的第k元的值为eIsAscending(C)操作结果：如果复数C的两个元素按升序排列，则返回1，否则返回0IsDescending(C)操作结果：如果复数C的两个元素按降序排列，则返回1，否则返回0 Max(C,&e)操作结果：用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果：用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={s,m|s,m为自然数，且m不为0}数据关系：R={<s,m>}基本操作：InitRationalNumber(&R,s,m)操作结果：构造一个有理数R，其分子和分母分别为s和m DestroyRationalNumber(&R)操作结果：销毁有理数RGet(R,k,&e)操作结果：用e返回有理数R的第k元的值Put(&R,k,e)操作结果：改变有理数R的第k元的值为eIsAscending(R)操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0 IsDescending(R)操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0 Max(R,&e)操作结果：用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。

严蔚敏 数据结构C 语言版答案详解第1章 绪论简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

,数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

}试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

设有数据结构(D,R)，其中{}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。

)解：试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADT Complex{-数据对象：D={r,i|r,i 为实数} 数据关系：R={<r,i>} 基本操作：InitComplex(&C,re,im)操作结果：构造一个复数C ，其实部和虚部分别为re 和im—DestroyCmoplex(&C)操作结果：销毁复数CGet(C,k,&e)操作结果：用e返回复数C的第k元的值Put(&C,k,e)^操作结果：改变复数C的第k元的值为eIsAscending(C)操作结果：如果复数C的两个元素按升序排列，则返回1，否则返回0 IsDescending(C)操作结果：如果复数C的两个元素按降序排列，则返回1，否则返回0）Max(C,&e)操作结果：用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果：用e返回复数C的两个元素中值较小的一个}ADT Complex^ADT RationalNumber{数据对象：D={s,m|s,m为自然数，且m不为0}数据关系：R={<s,m>}基本操作：}InitRationalNumber(&R,s,m)操作结果：构造一个有理数R，其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果：销毁有理数RGet(R,k,&e)>操作结果：用e返回有理数R的第k元的值Put(&R,k,e)操作结果：改变有理数R的第k元的值为eIsAscending(R)操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0 \IsDescending(R)操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0 Max(R,&e)操作结果：用e返回有理数R的两个元素中值较大的一个Min(R,&e)：操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber试画出与下列程序段等价的框图。

严蔚敏 数据结构C 语言版答案详解第1章 绪论1.1简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

b5E2RGbCAP 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

p1EanqFDPw 1.3 设有数据结构(D,R>，其中{}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。

解：1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义<有理数是其分子、分母均为自然数且分母不为零的分数）。

DXDiTa9E3d 解：ADT Complex{数据对象：D={r,i|r,i 为实数} 数据关系：R={<r,i>} 基本操作： InitComplex(&C,re,im>操作结果：构造一个复数C ，其实部和虚部分别为re 和imDestroyCmoplex(&C>操作结果：销毁复数CGet(C,k,&e>操作结果：用e 返回复数C 的第k 元的值Put(&C,k,e>操作结果：改变复数C的第k元的值为eIsAscending(C>操作结果：如果复数C的两个元素按升序排列，则返回1，否则返回0IsDescending(C>操作结果：如果复数C的两个元素按降序排列，则返回1，否则返回0Max(C,&e>操作结果：用e返回复数C的两个元素中值较大的一个Min(C,&e>操作结果：用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={s,m|s,m为自然数，且m不为0}数据关系：R={<s,m>}基本操作：InitRationalNumber(&R,s,m>操作结果：构造一个有理数R，其分子和分母分别为s和m DestroyRationalNumber(&R>操作结果：销毁有理数RGet(R,k,&e>操作结果：用e返回有理数R的第k元的值Put(&R,k,e>操作结果：改变有理数R的第k元的值为eIsAscending(R>操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0IsDescending(R>操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0Max(R,&e>操作结果：用e返回有理数R的两个元素中值较大的一个Min(R,&e>操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。

1.16void print_descending(int x,int y,int z)//按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<->为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; //冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f{int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp=0;temp[k-1]=1; //初始化for(i=k;i<=m;i++) //求出序列第k至第m个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果,此方法的时间复杂度仅为O(m^2).如果采用递归编程(大多数人都会首先想到递归方法),则时间复杂度将高达O(k^m).1.18typedef struct{char *sport;enum{male,female} gender;char schoolname; //校名为'A','B','C','D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中{scoretype score;i=0;while(result.sport!=NULL){switch(result.schoolname){case 'A':score[ 0 ].totalscore+=result.score;if(result.gender==0) score[ 0 ].malescore+=result.score;else score[ 0 ].femalescore+=result.score;break;case 'B':score.totalscore+=result.score;if(result.gender==0) score.malescore+=result.score;else score.femalescore+=result.score;break;……?……?……}i++；}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score of male:%d\n",score.malescore);printf("Total score of female:%d\n",score.femalescore);printf("Total score of all:%d\n\n",score.totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint{last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 to a%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue2.10Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;for(count=1;i+count-1<=a.length-k;count++) //注意循环结束的条件a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) return ERROR;va.length++;for(i=va.length-1;va.elem>x&&i>=0;i--)va.elem[i+1]=va.elem;va.elem[i+1]=x;return OK;}//Insert_SqList2.12int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B{for(i=1;A.elem||B.elem;i++)if(A.elem!=B.elem) return A.elem-B.elem;return 0;}//ListComp2.13LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)//求链表的长度{for(k=0,p=L;p->next;p=p->next,k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb接在ha后面形成链表hc{hc=ha;p=ha;while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; //插入在链表头部}else{while(--i>1) p=p->next;q->next=p->next;p->next=q; //插入在第i个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素{if(i==1) L=L->next; //删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; //删除第i个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L 中值大于mink且小于maxk的所有元素{p=L;while(p->next->data<=mink) p=p->next; //p是最后一个不大于mink的元素if(p->next) //如果还有比mink更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q是第一个不小于maxk的元素p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素{p=L->next;q=p->next; //p,q指向相邻两元素while(p->next){if(p->data!=q->data){p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步}else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)//顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2 {p=L->next;q=p->next;s=q->next;p->next=NULL;while(s->next){q->next=p;p=q;q=s;s=s->next; //把L的元素逐个插入新表表头}q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.2.23void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; //将B的元素插入if(s){t=q->next;q->next=s; //如A非空,将A的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList &A,LinkList &B,LinkList &C)//把元素递增排列的链表A 和B合并为C,且C中元素递减排列,使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa和pb分别指向A,B的当前元素while(pa||pb){if(pa->data<pb->data||!pb){pc=pa;q=pa->next;pa->next=pre;pa=q; //将A的元素插入新表}else{pc=pb;q=pb->next;pb->next=pre;pb=q; //将B的元素插入新表}pre=pc;}C=A;A->next=pc; //构造新表头}//reverse_merge分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A和B 的元素的交集并存入C中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;if(A.elem>B.elem[j]) j++;if(A.elem==B.elem[j]){C.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素,i++;j++; //就添加到C中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题{p=A->next;q=B->next;pc=(LNode*)malloc(sizeof(LNode));while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else{s=(LNode*)malloc(sizeof(LNode));s->data=p->data;pc->next=s;pc=s;p=p->next;q=q->next;}}//whileC=pc;}//LinkList_Intersect2.27void SqList_Intersect_True(SqList &A,SqList B)//求元素递增排列的线性表A和B的元素的交集并存回A中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;else if(A.elem>B.elem[j]) j++;else if(A.elem!=A.elem[k]){A.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素i++;j++; //且C中没有,就添加到C中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题{p=A->next;q=B->next;pc=A;while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){pc=pc->next;pc->data=p->data;p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList &A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置while(i<A.length&&j<B.length&& k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;elsesame=B.elem[j]; //找到了相同元素samewhile(B.elem[j]==same) j++;while(C.elem[k]==same) k++; //j,k后移到新的元素while(i<A.length&&A.elem<same)A.elem[m++]=A.elem[i++]; //需保留的元素移动到新位置while(i<A.length&&A.elem==same) i++; //跳过相同的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。

第1章绪论1.1简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

d r , , 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的 区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数 据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义 它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部 分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储 结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接 口。

1.3 设有数据结构(D,R)，其中D = { 1, d 2, d 3, d 4}， R = { }， r = {(d 1, d 2) (d 2, d 3) (d 3, d 4)}试按图论中图的画法惯例画出其逻辑结构图。

解：1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义 （有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADT Complex{数据对象：D={r,i|r,i 为实数} 数据关系：R={<r,i>} 基本操作：InitComplex(&C,re,im)操作结果：构造一个复数 C ，其实部和虚部分别为 re 和 imDestroyCmoplex(&C)操作结果：销毁复数 CGet(C,k,&e)操作结果：用 e 返回复数 C 的第 k 元的值Put(&C,k,e)操作结果：改变复数 C 的第 k 元的值为 eIsAscending(C)操作结果：如果复数 C 的两个元素按升序排列，则返回 1，否则返回 0IsDescending(C)操作结果：如果复数 C 的两个元素按降序排列，则返回 1，否则返回 0Max(C,&e)操作结果：用 e 返回复数 C 的两个元素中值较大的一个Min(C,&e)操作结果：用 e 返回复数 C 的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={s,m|s,m为自然数，且m不为0}数据关系：R={<s,m>}基本操作：InitRationalNumber(&R,s,m)操作结果：构造一个有理数R，其分子和分母分别为s和m DestroyRationalNumber(&R)操作结果：销毁有理数RGet(R,k,&e)操作结果：用e返回有理数R的第k元的值Put(&R,k,e)操作结果：改变有理数R的第k元的值为eIsAscending(R)操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0IsDescending(R)操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0Max(R,&e)操作结果：用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5试画出与下列程序段等价的框图。

严蔚敏 数据结构C 语言版答案详解第1章 绪论1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

1.3 设有数据结构(D,R)，其中{}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r =试按图论中图的画法惯例画出其逻辑结构图。

解：1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADT Complex{ 数据对象：D={r,i|r,i 为实数} 数据关系：R={<r,i>} 基本操作： InitComplex(&C,re,im)操作结果：构造一个复数C ，其实部和虚部分别为re 和im DestroyCmoplex(&C)操作结果：销毁复数C Get(C,k,&e) 操作结果：用e 返回复数C 的第k 元的值 Put(&C,k,e)操作结果：改变复数C 的第k 元的值为eIsAscending(C)操作结果：如果复数C的两个元素按升序排列，则返回1，否则返回0 IsDescending(C)操作结果：如果复数C的两个元素按降序排列，则返回1，否则返回0 Max(C,&e)操作结果：用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果：用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={s,m|s,m为自然数，且m不为0}数据关系：R={<s,m>}基本操作：InitRationalNumber(&R,s,m)操作结果：构造一个有理数R，其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果：销毁有理数RGet(R,k,&e)操作结果：用e返回有理数R的第k元的值Put(&R,k,e)操作结果：改变有理数R的第k元的值为eIsAscending(R)操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0 IsDescending(R)操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0 Max(R,&e)操作结果：用e返回有理数R的两个元素中值较大的一个Min(R,&e)操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图。

数据结构c语言版严蔚敏课后习题答案数据结构是计算机科学中的一个重要领域，它涉及到数据的组织、管理和存储方式，以便可以高效地访问和修改数据。

C语言作为一种广泛使用的编程语言，提供了丰富的数据结构实现方法。

严蔚敏教授编写的《数据结构（C语言版）》是许多计算机专业学生的必读教材。

以下是对该书课后习题的一些参考答案，供学习者参考。

第一章：绪论1. 数据结构的定义：数据结构是计算机中存储、组织数据的方式，它不仅包括数据元素的类型和关系，还包括数据操作的函数。

2. 数据结构的重要性：数据结构对于提高程序的效率至关重要。

合理的数据结构可以减少算法的时间复杂度和空间复杂度。

第二章：线性表1. 线性表的定义：线性表是由n个元素组成的有限序列，其中n称为线性表的长度。

2. 线性表的顺序存储结构：使用数组来存储线性表的元素，元素的存储关系是连续的。

3. 线性表的链式存储结构：使用链表来存储线性表的元素，每个元素包含数据部分和指向下一个元素的指针。

第三章：栈和队列1. 栈的定义：栈是一种特殊的线性表，只能在一端（栈顶）进行插入和删除操作。

2. 队列的定义：队列是一种特殊的线性表，允许在一端（队尾）进行插入操作，在另一端（队首）进行删除操作。

第四章：串1. 串的定义：串是由零个或多个字符组成的有限序列。

2. 串的存储结构：串可以采用顺序存储结构或链式存储结构。

第五章：数组和广义表1. 数组的定义：数组是由具有相同类型的多个元素组成的集合，这些元素按照索引顺序排列。

2. 广义表的定义：广义表是线性表的推广，其中的元素可以是数据也可以是子表。

第六章：树和二叉树1. 树的定义：树是由节点组成的，其中有一个特定的节点称为根，其余每个节点有且仅有一个父节点。

2. 二叉树的定义：二叉树是每个节点最多有两个子节点的树。

第七章：图1. 图的定义：图是由顶点和边组成的数据结构，可以表示复杂的关系。

2. 图的存储结构：图可以用邻接矩阵或邻接表来存储。

数据结构(C语言版)严蔚敏课后习题答案数据结构（C语言版）严蔚敏课后习题答案一、线性表1. 顺序表顺序表是一种存储结构，它将元素顺序存放在一块连续的存储区域中。

C语言中常用数组来实现顺序表。

以下是一些常见题目的解答：题目1：已知顺序表中存储了n个整数，请编写一个算法，将这个顺序表中的所有负数挑选出来，并将它们按照原有顺序存放在新的顺序表中。

解答：```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], neg[MAX_SIZE];int n, i, j = 0;printf("Enter the number of elements: ");scanf("%d", &n);printf("Enter the elements: ");for (i = 0; i < n; i++) {scanf("%d", &A[i]);if (A[i] < 0) {neg[j] = A[i];j++;}}printf("Negative numbers: ");for (i = 0; i < j; i++) {printf("%d ", neg[i]);}return 0;}```题目2：假设顺序表A和B中的元素递增有序排列，编写一个算法合并这两个顺序表，并使合并后的顺序表仍然递增有序。

解答：```#include <stdio.h>#define MAX_SIZE 100int main() {int A[MAX_SIZE], B[MAX_SIZE], C[MAX_SIZE * 2]; int m, n, i, j, k;printf("Enter the number of elements in the first list: "); scanf("%d", &m);printf("Enter the elements in increasing order: ");for (i = 0; i < m; i++) {scanf("%d", &A[i]);C[i] = A[i];}printf("Enter the number of elements in the second list: "); scanf("%d", &n);printf("Enter the elements in increasing order: ");for (i = 0; i < n; i++) {scanf("%d", &B[i]);C[m + i] = B[i];}// Merge A and B into Ci = j = k = 0;while (i < m && j < n) { if (A[i] < B[j]) {C[k] = A[i];i++;} else {C[k] = B[j];j++;}k++;}while (i < m) {C[k] = A[i];i++;k++;}while (j < n) {C[k] = B[j];j++;k++;}printf("Merged list in increasing order: ");for (i = 0; i < m + n; i++) {printf("%d ", C[i]);}return 0;}```2. 链表链表是一种动态的数据结构，它通过结点之间的指针联系起来。

1.16void print_descending(int x,int y,int z)// 按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<-> 为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; // 冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)// 求k 阶斐波那契序列的第m 项的值f{int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp=0;temp[k-1]=1; // 初始化for(i=k;i<=m;i++) // 求出序列第k 至第m 个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果，此方法的时间复杂度仅为0(m^2).如果采用递归编程(大多数人都会首先想到递归方法),则时间复杂度将高达0(3m).1.18typedef struct{char *sport;enum{male,female} gender;char school name; // 校名为'A','B',C,'D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])// 求各校的男女总分和团体总分,假设结果已经储存在数result[ ] 组中{scoretype score;i=0;while(result.sport!=NULL){switch(result.schoolname){case 'A':score[ 0 ].totalscore+=result.score;if(result.gender==0) score[ 0 ].malescore+=result.score;else score[ 0 ].femalescore+=result.score;break;case 'B':score.totalscore+=result.score;if(result.gender==0) score.malescore+=result.score;else score.femalescore+=result.score;break;}i++；}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score of male:%d\n",score.malescore);printf("Total score of female:%d\n",score.femalescore);printf("Total score of all:%d\n\n",score.totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])〃求i!*2A i 序列的值且不超过maxint{last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint 时,它除以前面一项的商会发生异常 1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 to a%d:\n",n,n); for(i=0;i<=n;i++) scanf("%f",p++); printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp 用于存放x 的i 次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue2.10Status DeleteK(SqList &a,int i,int k)// 删除线性表a 中第i 个元素起的k 个元素{if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;for(count=1;i+count-1<=a.length-k;count++) // 注意循环结束的条件a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)// 把x 插入递增有序表va 中{if(va.length+1>va.listsize) return ERROR;va.length++; for(i=va.length-1;va.elem>x&&i>=0;i--)va.elem[i+1]=va.elem;va.elem[i+1]=x;return OK; }//Insert_SqList2.12int ListComp(SqList A,SqList B)〃比较字符表A和B,并用返回值表示结果，值为正，表示A>B; 值为负，表示A<B;值为零，表示A=B{for(i=1;A.elem||B.elem;i++)if(A.elem!=B.elem) return A.elem-B.elem;return 0;}//ListComp2.13LNode* Locate(LinkList L，int x)// 链表上的元素查找，返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)// 求链表的长度{for(k=0，p=L;p->next;p=p->next，k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)〃把链表hb 接在ha 后面形成链表hc {hc=ha;p=ha;while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)// 在无头结点链表L 的第i 个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; // 插入在链表头部}else{while(--i>1) p=p->next;q->next=p->next;p->next=q; // 插入在第i 个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)// 在无头结点链表L 中删除第i 个元素{if(i==1) L=L->next; // 删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; // 删除第i 个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)// 删除元素递增排列的链表L 中值大于mink 且小于maxk 的所有元素{p=L;while(p->next->data<=mink) p=p->next; //p 是最后一个不大于mink 的元素if(p->next) // 如果还有比mink 更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q 是第一个不小于maxk 的元素p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)// 删除元素递增排列的链表L 中所有值相同的元素{p=L->next;q=p->next; //p,q 指向相邻两元素while(p->next){if(p->data!=q->data)p=p->next;q=p->next; // 当相邻两元素不相等时,p,q 都向后推一步}else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; // 当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)// 顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)// 链表的就地逆置;为简化算法,假设表长大于2{ p=L->next;q=p->next;s=q->next;p->next=NULL; while(s->next){q->next=p;p=q; q=s;s=s->next; // 把L 的元素逐个插入新表表头} q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是，逐个地把L的当前元素q插入新的链表头部,p为新表表头•2.23void merge1(LinkList &A,LinkList &B,LinkList &C)〃把链表A 和B 合并为C,A 和B 的元素间隔排列，且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; // 将B 的元素插入if(s){t=q->next;q->next=s; // 如A 非空,将A 的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList &A,LinkList &B,LinkList &C)// 把元素递增排列的链表A 和B 合并为C,且C中元素递减排列，使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa 和pb 分别指向A,B 的当前元素while(pa||pb)if(pa->data<pb->data||!pb){pc=pa;q=pa->next;pa->next=pre;pa=q; // 将A 的元素插入新表}else{ pc=pb;q=pb->next;pb->next=pre;pb=q; // 将B 的元素插入新表} pre=pc;}C=A;A->next=pc; // 构造新表头}//reverse_merge分析:本算法的思想是，按从小到大的顺序依次把A和B的元素插入新表的头部pc处最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)// 求元素递增排列的线性表 A 和 B 的元素的交集并存入 C 中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++; if(A.elem>B.elem[j]) j++;if(A.elem==B.elem[j]){ C.elem[++k]=A.elem; // 当发现了一个在A,B 中都存在的元素, i++;j++; // 就添加到C 中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)// 在链表结构上重做上题{p=A->next;q=B->next; pc=(LNode*)malloc(sizeof(LNode));while(p&&q){ if(p->data<q->data) p=p->next; else if(p->data>q->data) q=q->next;else{ s=(LNode*)malloc(sizeof(LNode)); s->data=p->data; pc->next=s;pc=s; p=p->next;q=q->next;}}//whileC=pc; }//LinkList_Intersect2.27void SqList_Intersect_True(SqList &A,SqList B)// 求元素递增排列的线性表A 和B 的元素的交集并存回 A 中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;else if(A.elem>B.elem[j]) j++;else if(A.elem!=A.elem[k]){A.elem[++k]=A.elem; // 当发现了一个在A,B 中都存在的元素i++;j++; // 且C 中没有,就添加到C 中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)// 在链表结构上重做上题{ p=A->next;q=B->next;pc=A; while(p&&q){ if(p->data<q->data) p=p->next; else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){ pc=pc->next; pc->data=p->data; p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList &A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i 指示A 中元素原来的位置,m 为移动后的位置while(i<A.length&&j<B.length&& k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;else{ same=B.elem[j]; // 找到了相同元素samewhile(B.elem[j]==same) j++; while(C.elem[k]==same) k++; //j,k 后移到新的元素while(i<A.length&&A.elem<same)A.elem[m++]=A.elem[i++]; // 需保留的元素移动到新位置while(i<A.length&&A.elem==same) i++; // 跳过相同的元素}}//whilewhile(i<A.length) A.elem[m++]=A.elem[i++]; //A 的剩余元素重新存储。

任何的限度，都是从自己的心坎开端的。

每一奋发尽力的背地，必有加倍的弥补。

严蔚敏数据结构C语言版答案详解第1章绪论1.1 简述下列术语：数据数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型解：数据是对客观事物的符号表示在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理数据对象是性质相同的数据元素的集合是数据的一个子集数据结构是相互之间存在一种或多种特定关系的数据元素的集合存储结构是数据结构在计算机中的表示数据类型是一个值的集合和定义在这个值集上的一组操作的总称抽象数据类型是指一个数学模型以及定义在该模型上的一组操作是对一般数据类型的扩展1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别解：抽象数据类型包含一般数据类型的概念但含义比一般数据类型更广、更抽象一般数据类型由具体语言系统内部定义直接提供给编程者定义用户数据因此称它们为预定义数据类型抽象数据类型通常由编程者定义包括定义它所使用的数据和在这些数据上所进行的操作在定义抽象数据类型中的数据部分和操作部分时要求只定义到数据的逻辑结构和操作说明不考虑数据的存储结构和操作的具体实现这样抽象层次更高更能为其他用户提供良好的使用接口1.3 设有数据结构(DR)其中试按图论中图的画法惯例画出其逻辑结构图解：1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）解：ADT Complex{数据对象：D={ri|ri为实数}数据关系：R={<ri>}基本操作：InitComplex(&Creim)操作结果：构造一个复数C其实部和虚部分别为re和imDestroyCmoplex(&C)操作结果：销毁复数CGet(Ck&e)操作结果：用e返回复数C的第k元的值Put(&Cke)操作结果：改变复数C的第k元的值为eIsAscending(C)操作结果：如果复数C的两个元素按升序排列则返回1否则返回0IsDescending(C)操作结果：如果复数C的两个元素按降序排列则返回1否则返回0Max(C&e)操作结果：用e返回复数C的两个元素中值较大的一个Min(C&e)操作结果：用e返回复数C的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={sm|sm为自然数且m不为0}数据关系：R={<sm>}基本操作：InitRationalNumber(&Rsm)操作结果：构造一个有理数R其分子和分母分别为s和mDestroyRationalNumber(&R)操作结果：销毁有理数RGet(Rk&e)操作结果：用e返回有理数R的第k元的值Put(&Rke)操作结果：改变有理数R的第k元的值为eIsAscending(R)操作结果：若有理数R的两个元素按升序排列则返回1否则返回0IsDescending(R)操作结果：若有理数R的两个元素按降序排列则返回1否则返回0Max(R&e)操作结果：用e返回有理数R的两个元素中值较大的一个Min(R&e)操作结果：用e返回有理数R的两个元素中值较小的一个}ADT RationalNumber1.5 试画出与下列程序段等价的框图(1) product=1; i=1;while(i<=n){product *= i;i++;}(2) i=0;do {i++;} while((i!=n) && (a[i]!=x));(3) switch {case x<y: z=y-x; break;case x=y: z=abs(x*y); break;default: z=(x-y)/abs(x)*abs(y);}1.6 在程序设计中常用下列三种不同的出错处理方式：(1) 用exit语句终止执行并报告错误；(2) 以函数的返回值区别正确返回或错误返回；(3) 设置一个整型变量的函数参数以区别正确返回或某种错误返回试讨论这三种方法各自的优缺点解：(1)exit常用于异常错误处理它可以强行中断程序的执行返回操作系统(2)以函数的返回值判断正确与否常用于子程序的测试便于实现程序的局部控制(3)用整型函数进行错误处理的优点是可以给出错误类型便于迅速确定错误1.7 在程序设计中可采用下列三种方法实现输出和输入：(1) 通过scanf和printf语句；(2) 通过函数的参数显式传递；(3) 通过全局变量隐式传递试讨论这三种方法的优缺点解：(1)用scanf和printf直接进行输入输出的好处是形象、直观但缺点是需要对其进行格式控制较为烦琐如果出现错误则会引起整个系统的崩溃(2)通过函数的参数传递进行输入输出便于实现信息的隐蔽减少出错的可能(3)通过全局变量的隐式传递进行输入输出最为方便只需修改变量的值即可但过多的全局变量使程序的维护较为困难1.8 设n为正整数试确定下列各程序段中前置以记号@的语句的频度：(1) i=1; k=0;while(i<=n-1){@ k += 10*i;i++;}(2) i=1; k=0;do {@ k += 10*i;i++;} while(i<=n-1);(3) i=1; k=0;while (i<=n-1) {i++;@ k += 10*i;}(4) k=0;for(i=1; i<=n; i++) {for(j=i; j<=n; j++)@ k++;}(5) for(i=1; i<=n; i++) {for(j=1; j<=i; j++) {for(k=1; k<=j; k++)@ x += delta;}(6) i=1; j=0;while(i+j<=n) {@ if(i>j) j++;else i++;}(7) x=n; y=0; // n是不小于1的常数while(x>=(y+1)*(y+1)) {@ y++;}(8) x=91; y=100;while(y>0) {@ if(x>100) { x -= 10; y--; }else x++;}解：(1) n-1(2) n-1(3) n-1(4) n+(n-1)+(n-2)+ (1)(5) 1+(1+2)+(1+2+3)+...+(1+2+3+...+n)===(6) n(7) 向下取整(8) 11001.9 假设n为2的乘幂并且n>2试求下列算法的时间复杂度及变量count的值（以n的函数形式表示）int Time(int n) {count = 0; x=2;while(x<n/2) {x *= 2; count++;}return count;}解：count=1.11 已知有实现同一功能的两个算法其时间复杂度分别为和假设现实计算机可连续运算的时间为秒（100多天）又每秒可执行基本操作（根据这些操作来估算算法时间复杂度）次试问在此条件下这两个算法可解问题的规模（即n值的范围）各为多少？哪个算法更适宜？请说明理由解：n=40n=16则对于同样的循环次数n在这个规模下第二种算法所花费的代价要大得多故在这个规模下第一种算法更适宜1.12 设有以下三个函数：请判断以下断言正确与否：(1) f(n)是O(g(n))(2) h(n)是O(f(n))(3) g(n)是O(h(n))(4) h(n)是O(n3.5)(5) h(n)是O(nlogn)解：(1)对 (2)错 (3)错 (4)对 (5)错1.13 试设定若干n值比较两函数和的增长趋势并确定n在什么范围内函数的值大于的值解：的增长趋势快但在n较小的时候的值较大当n>438时1.14 判断下列各对函数和当时哪个函数增长更快？(1)(2)(3)(4)解：(1)g(n)快 (2)g(n)快 (3)f(n)快 (4) f(n)快1.15 试用数学归纳法证明：(1)(2)(3)(4)1.16 试写一算法自大至小依次输出顺序读入的三个整数XY和Z的值解：int max3(int xint yint z){if(x>y)if(x>z) return x;else return z;elseif(y>z) return y;else return z;}1.17 已知k阶斐波那契序列的定义为...；试编写求k阶斐波那契序列的第m项值的函数算法k和m均以值调用的形式在函数参数表中出现解：k>0为阶数n为数列的第n项int Fibonacci(int kint n){if(k<1) exit(OVERFLOW);int *px;p=new int[k+1];if(!p) exit(OVERFLOW);int ij;for(i=0;i<k+1;i++){if(i<k-1) p[i]=0;else p[i]=1;}for(i=k+1;i<n+1;i++){x=p[0];for(j=0;j<k;j++) p[j]=p[j+1];p[k]=2*p[k-1]-x;}return p[k];}1.18 假设有ABCDE五个高等院校进行田径对抗赛各院校的单项成绩均已存入计算机并构成一张表表中每一行的形式为项目名称性别校名成绩得分编写算法处理上述表格以统计各院校的男、女总分和团体总分并输出解：typedef enum{ABCDE} SchoolName;typedef enum{FemaleMale} SexType;typedef struct{char event[3]; //项目SexType sex;SchoolName school;int score;} Component;typedef struct{int MaleSum; //男团总分int FemaleSum; //女团总分int TotalSum; //团体总分} Sum;Sum SumScore(SchoolName sn Component a[]int n){Sum temp;temp.MaleSum=0;temp.FemaleSum=0;temp.TotalSum=0;int i;for(i=0;i<n;i++){if(a[i].school==sn){if(a[i].sex==Male) temp.MaleSum+=a[i].score;if(a[i].sex==Female) temp.FemaleSum+=a[i].score;}}temp.TotalSum=temp.MaleSum+temp.FemaleSum;return temp;}1.19 试编写算法计算的值并存入数组a[0..arrsize-1]的第i-1个分量中(i=12...n)假设计算机中允许的整数最大值为maxint则当n>arrsize或对某个使时应按出错处理注意选择你认为较好的出错处理方法解：#include<iostream.h>#include<stdlib.h>#define MAXINT 65535#define ArrSize 100int fun(int i);int main(){int ik;int a[ArrSize];cout<<"Enter k:";cin>>k;if(k>ArrSize-1) exit(0);for(i=0;i<=k;i++){if(i==0) a[i]=1;else{if(2*i*a[i-1]>MAXINT) exit(0);else a[i]=2*i*a[i-1];}}for(i=0;i<=k;i++){if(a[i]>MAXINT) exit(0);else cout<<a[i]<<" ";}return 0;}1.20 试编写算法求一元多项式的值的值并确定算法中每一语句的执行次数和整个算法的时间复杂度注意选择你认为较好的输入和输出方法本题的输入为和输出为解：#include<iostream.h>#include<stdlib.h>#define N 10double polynomail(int a[]int idouble xint n);int main(){double x;int ni;int a[N];cout<<"输入变量的值x:";cin>>x;cout<<"输入多项式的阶次n:";cin>>n;if(n>N-1) exit(0);cout<<"输入多项式的系数a[0]--a[n]:";for(i=0;i<=n;i++) cin>>a[i];cout<<"The polynomail value is "<<polynomail(a nxn)<<endl;return 0;}double polynomail(int a[]int idouble xint n)if(i>0) return a[n-i]+polynomail(ai-1xn)*x;else return a[n];}本算法的时间复杂度为o(n)第2章线性表2.1 描述以下三个概念的区别：头指针头结点首元结点（第一个元素结点）解：头指针是指向链表中第一个结点的指针首元结点是指链表中存储第一个数据元素的结点头结点是在首元结点之前附设的一个结点该结点不存储数据元素其指针域指向首元结点其作用主要是为了方便对链表的操作它可以对空表、非空表以及首元结点的操作进行统一处理2.2 填空题解：(1) 在顺序表中插入或删除一个元素需要平均移动表中一半元素具体移动的元素个数与元素在表中的位置有关(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻单链表中逻辑上相邻的元素的物理位置不一定紧邻(3) 在单链表中除了首元结点外任一结点的存储位置由其前驱结点的链域的值指示(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理2.3 在什么情况下用顺序表比链表好？解：当线性表的数据元素在物理位置上是连续存储的时候用顺序表比用链表好其特点是可以进行随机存取2.4 对以下单链表分别执行下列各程序段并画出结果示意图解：2.5 画出执行下列各行语句后各指针及链表的示意图L=(LinkList)malloc(sizeof(LNode)); P=L;for(i=1;i<=4;i++){P->next=(LinkList)malloc(sizeof(LNode));P=P->next; P->data=i*2-1;}P->next=NULL;for(i=4;i>=1;i--) Ins_LinkList(Li+1i*2);for(i=1;i<=3;i++) Del_LinkList(Li);解：2.6 已知L是无表头结点的单链表且P结点既不是首元结点也不是尾元结点试从下列提供的答案中选择合适的语句序列a. 在P结点后插入S结点的语句序列是__________________b. 在P结点前插入S结点的语句序列是__________________c. 在表首插入S结点的语句序列是__________________d. 在表尾插入S结点的语句序列是__________________(1) P->next=S;(2) P->next=P->next->next;(3) P->next=S->next;(4) S->next=P->next;(5) S->next=L;(6) S->next=NULL;(7) Q=P;(8) while(P->next!=Q) P=P->next;(9) while(P->next!=NULL) P=P->next;(10) P=Q;(11) P=L;(12) L=S;(13) L=P;解：a. (4) (1)b. (7) (11) (8) (4) (1)c. (5) (12)d. (9) (1) (6)2.7 已知L是带表头结点的非空单链表且P结点既不是首元结点也不是尾元结点试从下列提供的答案中选择合适的语句序列a. 删除P结点的直接后继结点的语句序列是____________________b. 删除P结点的直接前驱结点的语句序列是____________________c. 删除P结点的语句序列是____________________d. 删除首元结点的语句序列是____________________e. 删除尾元结点的语句序列是____________________(1) P=P->next;(2) P->next=P;(3) P->next=P->next->next;(4) P=P->next->next;(5) while(P!=NULL) P=P->next;(6) while(Q->next!=NULL) { P=Q; Q=Q->next; }(7) while(P->next!=Q) P=P->next;(8) while(P->next->next!=Q) P=P->next;(9) while(P->next->next!=NULL) P=P->next;(10) Q=P;(11) Q=P->next;(12) P=L;(13) L=L->next;(14) free(Q);解：a. (11) (3) (14)b. (10) (12) (8) (3) (14)c. (10) (12) (7) (3) (14)d. (12) (11) (3) (14)e. (9) (11) (3) (14)2.8 已知P结点是某双向链表的中间结点试从下列提供的答案中选择合适的语句序列a. 在P结点后插入S结点的语句序列是_______________________b. 在P结点前插入S结点的语句序列是_______________________c. 删除P结点的直接后继结点的语句序列是_______________________d. 删除P结点的直接前驱结点的语句序列是_______________________e. 删除P结点的语句序列是_______________________(1) P->next=P->next->next;(2) P->priou=P->priou->priou;(3) P->next=S;(4) P->priou=S;(5) S->next=P;(6) S->priou=P;(7) S->next=P->next;(8) S->priou=P->priou;(9) P->priou->next=P->next;(10) P->priou->next=P;(11) P->next->priou=P;(12) P->next->priou=S;(13) P->priou->next=S;(14) P->next->priou=P->priou;(15) Q=P->next;(16) Q=P->priou;(17) free(P);(18) free(Q);解：a. (7) (3) (6) (12)b. (8) (4) (5) (13)c. (15) (1) (11) (18)d. (16) (2) (10) (18)e. (14) (9) (17)2.9 简述以下算法的功能(1) Status A(LinkedList L) { //L是无表头结点的单链表if(L && L->next) {Q=L; L=L->next; P=L;while(P->next) P=P->next;P->next=Q; Q->next=NULL;}return OK;}(2) void BB(LNode *sLNode *q) {p=s;while(p->next!=q) p=p->next;p->next =s;}void AA(LNode *paLNode *pb) {//pa和pb分别指向单循环链表中的两个结点BB(papb);BB(pbpa);}解：(1) 如果L的长度不小于2将L的首元结点变成尾元结点(2) 将单循环链表拆成两个单循环链表2.10 指出以下算法中的错误和低效之处并将它改写为一个既正确又高效的算法Status DeleteK(SqList &aint iint k){//本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素if(i<1||k<0||i+k>a.length) return INFEASIBLE;//参数不合法else {for(count=1;count<k;count++){//删除第一个元素for(j=a.length;j>=i+1;j--) a.elem[j-i]=a.elem[j];a.length--;}return OK;}解：Status DeleteK(SqList &aint iint k){//从顺序存储结构的线性表a中删除第i个元素起的k个元素//注意i的编号从0开始int j;if(i<0||i>a.length-1||k<0||k>a.length-i) return INFEASIBLE;for(j=0;j<=k;j++)a.elem[j+i]=a.elem[j+i+k];a.length=a.length-k;return OK;}2.11 设顺序表va中的数据元素递增有序试写一算法将x插入到顺序表的适当位置上以保持该表的有序性解：Status InsertOrderList(SqList &vaElemType x){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法int i;if(va.length==va.listsize)return(OVERFLOW);for(i=va.length;i>0x<va.elem[i-1];i--)va.elem[i]=va.elem[i-1];va.elem[i]=x;va.length++;return OK;}2.12 设和均为顺序表和分别为和中除去最大共同前缀后的子表若空表则；若=空表而空表或者两者均不为空表且的首元小于的首元则；否则试写一个比较大小的算法解：Status CompareOrderList(SqList &ASqList &B){int ikj;k=A.length>B.length?A.length:B.length;for(i=0;i<k;i++){if(A.elem[i]>B.elem[i]) j=1;if(A.elem[i]<B.elem[i]) j=-1;}if(A.length>k) j=1;if(B.length>k) j=-1;if(A.length==B.length) j=0;return j;}2.13 试写一算法在带头结点的单链表结构上实现线性表操作Locate(L x);解：int LocateElem_L(LinkList &LElemType x){int i=0;LinkList p=L;while(p&&p->data!=x){p=p->next;i++;}if(!p) return 0;else return i;}2.14 试写一算法在带头结点的单链表结构上实现线性表操作Length(L)解：//返回单链表的长度int ListLength_L(LinkList &L){int i=0;LinkList p=L;if(p) p=p-next;while(p){p=p->next;i++;}return i;}2.15 已知指针ha和hb分别指向两个单链表的头结点并且已知两个链表的长度分别为m和n试写一算法将这两个链表连接在一起假设指针hc指向连接后的链表的头结点并要求算法以尽可能短的时间完成连接运算请分析你的算法的时间复杂度解：void MergeList_L(LinkList &haLinkList &hbLinkList &hc){LinkList papb;pa=ha;pb=hb;while(pa->next&&pb->next){pa=pa->next;pb=pb->next;}if(!pa->next){hc=hb;while(pb->next) pb=pb->next;pb->next=ha->next;}else{hc=ha;while(pa->next) pa=pa->next;pa->next=hb->next;}}2.16 已知指针la和lb分别指向两个无头结点单链表中的首元结点下列算法是从表la中删除自第i个元素起共len个元素后将它们插入到表lb中第i个元素之前试问此算法是否正确？若有错请改正之Status DeleteAndInsertSub(LinkedList laLinkedList lbint iint jint len){if(i<0||j<0||len<0) return INFEASIBLE;p=la; k=1;while(k<i){ p=p->next; k++; }q=p;while(k<=len){ q=q->next; k++; }s=lb; k=1;while(k<j){ s=s->next; k++; }s->next=p; q->next=s->next;return OK;}解：Status DeleteAndInsertSub(LinkList &la LinkList &lbint iint jint len){LinkList pqsprev=NULL;int k=1;if(i<0||j<0||len<0) return INFEASIBLE;// 在la表中查找第i个结点p=la;while(p&&k<i){prev=p;p=p->next;k++;}if(!p)return INFEASIBLE;// 在la表中查找第i+len-1个结点q=p; k=1;while(q&&k<len){q=p->next;k++;}if(!q)return INFEASIBLE;// 完成删除注意i=1的情况需要特殊处理if(!prev) la=q->next;else prev->next=q->next;// 将从la中删除的结点插入到lb中if(j=1){q->next=lb;lb=p;}else{s=lb; k=1;while(s&&k<j-1){s=s->next;k++;}if(!s)return INFEASIBLE;q->next=s->next;s->next=p; //完成插入}return OK;}2.17 试写一算法在无头结点的动态单链表上实现线性表操作Insert(Lib)并和在带头结点的动态单链表上实现相同操作的算法进行比较2.18试写一算法实现线性表操作Delete(Li)并和在带头结点的动态单链表上实现相同操作的算法进行比较2.19 已知线性表中的元素以值递增有序排列并以单链表作存储结构试写一高效的算法删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）同时释放被删结点空间并分析你的算法的时间复杂度（注意mink和maxk是给定的两个参变量它们的值可以和表中的元素相同也可以不同）解：Status ListDelete_L(LinkList &LElemType minkElemType maxk){LinkList pqprev=NULL;if(mink>maxk)return ERROR;p=L;prev=p;p=p->next;while(p&&p->data<maxk){if(p->data<=mink){prev=p;p=p->next;}else{prev->next=p->next;q=p;p=p->next;free(q);}}return OK;}2.20 同2.19题条件试写一高效的算法删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）同时释放被删结点空间并分析你的算法的时间复杂度解：void ListDelete_LSameNode(LinkList &L){LinkList pqprev;p=L;prev=p;p=p->next;while(p){prev=p;p=p->next;if(p&&p->data==prev->data){prev->next=p->next;q=p;p=p->next;free(q);}}}2.21 试写一算法实现顺序表的就地逆置即利用原表的存储空间将线性表逆置为解：// 顺序表的逆置Status ListOppose_Sq(SqList &L){int i;ElemType x;for(i=0;i<L.length/2;i++){x=L.elem[i];L.elem[i]=L.elem[L.length-1-i];L.elem[L.length-1-i]=x;}return OK;}2.22 试写一算法对单链表实现就地逆置解：// 带头结点的单链表的逆置Status ListOppose_L(LinkList &L){LinkList pq;p=L;p=p->next;L->next=NULL;while(p){q=p;p=p->next;q->next=L->next;L->next=q;}return OK;}2.23 设线性表试写一个按下列规则合并AB为线性表C的算法即使得当时；当时线性表AB和C均以单链表作存储结构且C表利用A表和B表中的结点空间构成注意：单链表的长度值m和n均未显式存储解：// 将合并后的结果放在C表中并删除B表Status ListMerge_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqb;pa=A->next;pb=B->next;C=A;while(pa&&pb){qa=pa; qb=pb;pa=pa->next; pb=pb->next;qb->next=qa->next;qa->next=qb;}if(!pa)qb->next=pb;pb=B;free(pb);return OK;}2.24 假设有两个按元素值递增有序排列的线性表A和B均以单链表作存储结构请编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序允许表中含有值相同的元素）排列的线性表C并要求利用原表（即A表和B表）的结点空间构造C表解：// 将合并逆置后的结果放在C表中并删除B表Status ListMergeOppose_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqb;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;A->next=NULL;C=A;while(pa&&pb){if(pa->data<pb->data){qa=pa;pa=pa->next;qa->next=A->next; //将当前最小结点插入A表表头A->next=qa;}else{qb=pb;pb=pb->next;qb->next=A->next; //将当前最小结点插入A表表头A->next=qb;}}while(pa){qa=pa;pa=pa->next;qa->next=A->next;A->next=qa;}while(pb){qb=pb;pb=pb->next;qb->next=A->next;A->next=qb;}pb=B;free(pb);return OK;}2.25 假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合（即同一表中的元素值各不相同）现要求另辟空间构成一个线性表C其元素为A和B中元素的交集且表C中的元素有依值递增有序排列试对顺序表编写求C的算法解：// 将A、B求交后的结果放在C表中Status ListCross_Sq(SqList &ASqList &BSqList &C){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{ListInsert_Sq(CkA.elem[i]);i++;k++;}}return OK;}2.26 要求同2.25题试对单链表编写求C的算法解：// 将A、B求交后的结果放在C表中并删除B表Status ListCross_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;C=A;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{qa=pa;pa=pa->next;}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.27 对2.25题的条件作以下两点修改对顺序表重新编写求得表C的算法(1) 假设在同一表（A或B）中可能存在值相同的元素但要求新生成的表C中的元素值各不相同；(2) 利用A表空间存放表C解：(1)// A、B求交然后删除相同元素将结果放在C表中Status ListCrossDelSame_Sq(SqList &ASqList &BSqList &C){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{if(C.length==0){ListInsert_Sq(CkA.elem[i]);k++;}elseif(C.elem[C.length-1]!=A.elem[i]){ListInsert_Sq(CkA.elem[i]);k++;}i++;}}return OK;}(2)// A、B求交然后删除相同元素将结果放在A表中Status ListCrossDelSame_Sq(SqList &ASqList &B){int i=0j=0k=0;while(i<A.length && j<B.length){if(A.elem[i]<B.elem[j]) i++;elseif(A.elem[i]>B.elem[j]) j++;else{if(k==0){A.elem[k]=A.elem[i];k++;}elseif(A.elem[k]!=A.elem[i]){A.elem[k]=A.elem[i];k++;}i++;}}A.length=k;return OK;}2.28 对2.25题的条件作以下两点修改对单链表重新编写求得表C的算法(1) 假设在同一表（A或B）中可能存在值相同的元素但要求新生成的表C中的元素值各不相同；(2) 利用原表（A表或B表）中的结点构成表C并释放A表中的无用结点空间解：(1)// A、B求交结果放在C表中并删除相同元素Status ListCrossDelSame_L(LinkList &ALinkList &BLinkList &C){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;C=A;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{if(pa->data==qa->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}else{qa=pa;pa=pa->next;}}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}(2)// A、B求交结果放在A表中并删除相同元素Status ListCrossDelSame_L(LinkList &A LinkList &B){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;while(pa&&pb){if(pa->data<pb->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}elseif(pa->data>pb->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}else{if(pa->data==qa->data){pt=pa;pa=pa->next;qa->next=pa;free(pt);}else{qa=pa;pa=pa->next;}}}while(pa){pt=pa;pa=pa->next;qa->next=pa;free(pt);}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.29 已知AB和C为三个递增有序的线性表现要求对A表作如下操作：删去那些既在B表中出现又在C表中出现的元素试对顺序表编写实现上述操作的算法并分析你的算法的时间复杂度（注意：题中没有特别指明同一表中的元素值各不相同）解：// 在A中删除既在B中出现又在C中出现的元素结果放在D中Status ListUnion_Sq(SqList &DSqList &ASqList &BSqList &C){SqList Temp;InitList_Sq(Temp);ListCross_L(BCTemp);ListMinus_L(ATempD);}2.30 要求同2.29题试对单链表编写算法请释放A表中的无用结点空间解：// 在A中删除既在B中出现又在C中出现的元素并释放B、CStatus ListUnion_L(LinkList &ALinkList &BLinkList &C){ListCross_L(BC);ListMinus_L(AB);}// 求集合A-B结果放在A表中并删除B表Status ListMinus_L(LinkList &ALinkList &B){LinkList papbqaqbpt;pa=A;pb=B;qa=pa; // 保存pa的前驱指针qb=pb; // 保存pb的前驱指针pa=pa->next;pb=pb->next;while(pa&&pb){if(pb->data<pa->data){pt=pb;pb=pb->next;qb->next=pb;free(pt);}elseif(pb->data>pa->data){qa=pa;pa=pa->next;}else{pt=pa;pa=pa->next;qa->next=pa;free(pt);}}while(pb){pt=pb;pb=pb->next;qb->next=pb;free(pt);}pb=B;free(pb);return OK;}2.31 假设某个单向循环链表的长度大于1且表中既无头结点也无头指针已知s为指向链表中某个结点的指针试编写算法在链表中删除指针s所指结点的前驱结点解：// 在单循环链表S中删除S的前驱结点Status ListDelete_CL(LinkList &S){LinkList pq;if(S==S->next)return ERROR;q=S;p=S->next;while(p->next!=S){q=p;p=p->next;}q->next=p->next;free(p);return OK;}2.32 已知有一个单向循环链表其每个结点中含三个域：predata和next其中data为数据域next为指向后继结点的指针域pre也为指针域但它的值为空试编写算法将此单向循环链表改为双向循环链表即使pre成为指向前驱结点的指针域解：// 建立一个空的循环链表Status InitList_DL(DuLinkList &L){L=(DuLinkList)malloc(sizeof(DuLNode));if(!L) exit(OVERFLOW);L->pre=NULL;L->next=L;return OK;}// 向循环链表中插入一个结点Status ListInsert_DL(DuLinkList &L ElemType e){DuLinkList p;p=(DuLinkList)malloc(sizeof(DuLNode));if(!p) return ERROR;p->data=e;p->next=L->next;L->next=p;return OK;}// 将单循环链表改成双向链表Status ListCirToDu(DuLinkList &L){DuLinkList pq;q=L;p=L->next;while(p!=L){p->pre=q;q=p;}if(p==L) p->pre=q;return OK;}2.33 已知由一个线性链表表示的线性表中含有三类字符的数据元素（如：字母字符、数字字符和其他字符）试编写算法将该线性表分割为三个循环链表其中每个循环链表表示的线性表中均只含一类字符解：// 将单链表L划分成3个单循环链表Status ListDivideInto3CL(LinkList &LLinkList &s1LinkList &s2LinkList &s3){LinkList pqpt1pt2pt3;p=L->next;pt1=s1;pt2=s2;pt3=s3;while(p){if(p->data>='0' && p->data<='9'){q=p;p=p->next;q->next=pt1->next;pt1->next=q;pt1=pt1->next;}elseif((p->data>='A' && p->data<='Z') ||(p->data>='a' && p->data<='z')){q=p;p=p->next;q->next=pt2->next;pt2->next=q;pt2=pt2->next;}else{p=p->next;q->next=pt3->next;pt3->next=q;pt3=pt3->next;}}q=L;free(q);return OK;}在2.34至2.36题中"异或指针双向链表"类型XorLinkedList和指针异或函数XorP定义为：typedef struct XorNode {char data;struct XorNode *LRPtr;} XorNode*XorPointer;typede struct { //无头结点的异或指针双向链表XorPointer LeftRight; //分别指向链表的左侧和右端} XorLinkedList;XorPointer XorP(XorPointer pXorPointer q);// 指针异或函数XorP返回指针p和q的异或值2.34 假设在算法描述语言中引入指针的二元运算"异或"若a和b为指针则a⊕b的运算结果仍为原指针类型且a⊕(a⊕b)=(a⊕a)⊕b=b(a⊕b)⊕b=a⊕(b⊕b)=a则可利用一个指针域来实现双向链表L链表L中的每个结点只含两个域：data域和LRPtr域其中LRPtr域存放该结点的左邻与右邻结点指针（不存在时为NULL）的异或若设指针L.Left指向链表中的最左结点L.Right指向链表中的最右结点则可实现从左向右或从右向左遍历此双向链表的操作试写一算法按任一方向依次输出链表中各元素的值解：Status TraversingLinkList(XorLinkedList &Lchar d){XorPointer pright;if(d=='l'||d=='L'){p=L.Left;left=NULL;while(p!=NULL){VisitingData(p->data);left=p;p=XorP(leftp->LRPtr);}}elseif(d=='r'||d=='R'){p=L.Right;right=NULL;while(p!=NULL){VisitingData(p->data);right=p;p=XorP(p->LRPtrright);}}else return ERROR;return OK;}2.35 采用2.34题所述的存储结构写出在第i个结点之前插入一个结点的算法2.36 采用2.34题所述的存储结构写出删除第i个结点的算法2.37 设以带头结点的双向循环链表表示的线性表试写一时间复杂度O(n)的算法将L改造为解：// 将双向链表L=(a1a2...an)改造为(a1a3...an。

第 1 章绪论1.1简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。

解：数据是对客观事物的符号表示。

在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。

数据对象是性质相同的数据元素的集合，是数据的一个子集。

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

存储结构是数据结构在计算机中的表示。

数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。

是对一般数据类型的扩展。

1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。

解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。

一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。

抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。

在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。

1.3设有数据结构(D,R)，其中D = {d1, d 2, d 3, d 4}，R = {r}，r = {(d1, d 2), (d 2, d3),(d 3, d 4)}试按图论中图的画法惯例画出其逻辑结构图。

解：1.4试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADT Complex{数据对象：D={r,i|r,i 为实数}数据关系：R={<r,i>}基本操作：InitComplex(&C,re,im)操作结果：构造一个复数 C，其实部和虚部分别为re 和 imDestroyCmoplex(&C)操作结果：销毁复数 CGet(C,k,&e)操作结果：用 e 返回复数C 的第k 元的值Put(&C,k,e)操作结果：改变复数 C 的第k 元的值为eIsAscending(C)操作结果：如果复数 C 的两个元素按升序排列，则返回 1，否则返回 0IsDescending(C)操作结果：如果复数 C 的两个元素按降序排列，则返回 1，否则返回 0 Max(C,&e)操作结果：用 e 返回复数C 的两个元素中值较大的一个Min(C,&e)操作结果：用 e 返回复数C 的两个元素中值较小的一个}ADT ComplexADT RationalNumber{数据对象：D={s,m|s,m 为自然数，且 m 不为 0}数据关系：R={<s,m>}基本操作：InitRationalNumber(&R,s,m)操作结果：构造一个有理数 R，其分子和分母分别为 s 和mDestroyRationalNumber(&R)操作结果：销毁有理数 RGet(R,k,&e)操作结果：用 e 返回有理数 R 的第k 元的值Put(&R,k,e)操作结果：改变有理数 R 的第k 元的值为 eIsAscending(R)操作结果：若有理数 R 的两个元素按升序排列，则返回 1，否则返回 0 IsDescending(R)操作结果：若有理数 R 的两个元素按降序排列，则返回 1，否则返回 0 Max(R,&e)操作结果：用 e 返回有理数 R 的两个元素中值较大的一个Min(R,&e)操作结果：用 e 返回有理数 R 的两个元素中值较小的一个}ADT RationalNumber1.5试画出与下列程序段等价的框图。

清华大学严蔚敏数据结构习题集（C版）答案清华大学严蔚敏数据结构习题集（C版）答案第一章绪论1.16void print_descending(int x,int y,int z)//按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<->为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; //冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f{int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp=0;temp[k-1]=1; //初始化for(i=k;i<=m;i++) //求出序列第k至第m个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果,此方法的时间复杂度仅为O(m^2).如果采用递归编程(大多数人都会首先想到递归方法),则时间复杂度将高达O(k^m).1.18typedef struct{char *sport;enum{male,female} gender; char schoolname; //校名为'A','B','C','D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中{scoretype score;i=0;while(result.sport!=NULL){switch(result.schoolname){case 'A':score[ 0 ].totalscore+=result.score;if(result.gender==0)score[ 0 ].malescore+=result.score;elsescore[ 0 ].femalescore+=result.score;break;case 'B':score.totalscore+=result.score;if(result.gender==0)score.malescore+=result.score;else score.femalescore+=result.score;break;………………}i++；}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score ofmale:%d\n",score.malescore);printf("Total score offemale:%d\n",score.femalescore);printf("Total score ofall:%d\n\n",score.totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint{last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 toa%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue第二章线性表2.10Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{if(i<1||k<0||i+k-1>a.length) returnINFEASIBLE;for(count=1;i+count-1<=a.length-k;c ount++) //注意循环结束的条件a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) returnERROR;va.length++;for(i=va.length-1;va.elem>x&&i>=0;i--)va.elem[i+1]=va.elem;va.elem[i+1]=x;return OK;}//Insert_SqList2.12int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B{for(i=1;A.elem||B.elem;i++)if(A.elem!=B.elem) returnA.elem-B.elem;return 0;}//ListComp2.13LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)//求链表的长度{for(k=0,p=L;p->next;p=p->next,k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb接在ha后面形成链表hc{hc=ha;p=ha;while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; //插入在链表头部}else{while(--i>1) p=p->next;q->next=p->next;p->next=q; //插入在第i个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素{if(i==1) L=L->next; //删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; //删除第i个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素{p=L;while(p->next->data<=mink) p=p->next;//p是最后一个不大于mink的元素if(p->next) //如果还有比mink更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q 是第一个不小于maxk的元素p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素{p=L->next;q=p->next; //p,q指向相邻两元素while(p->next){if(p->data!=q->data){p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步}else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)//顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2{p=L->next;q=p->next;s=q->next;p->next=NULL;while(s->next){q->next=p;p=q;q=s;s=s->next; //把L的元素逐个插入新表表头}q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.2.23void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A 和B的元素间隔排列,且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; //将B的元素插入if(s){t=q->next;q->next=s; //如A非空,将A的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList&A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa 和pb分别指向A,B的当前元素while(pa||pb){if(pa->data<pb->data||!pb){pc=pa;q=pa->next;pa->next=pre;p a=q; //将A的元素插入新表}else{pc=pb;q=pb->next;pb->next=pre;p b=q; //将B的元素插入新表}pre=pc;}C=A;A->next=pc; //构造新表头}//reverse_merge分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A 和B的元素的交集并存入C中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;if(A.elem>B.elem[j]) j++;if(A.elem==B.elem[j]){C.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素,i++;j++; //就添加到C中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题{p=A->next;q=B->next;pc=(LNode*)malloc(sizeof(LNode));while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else{s=(LNode*)malloc(sizeof(LNode));s->data=p->data;pc->next=s;pc=s;p=p->next;q=q->next;}}//whileC=pc;}//LinkList_Intersect2.27void SqList_Intersect_True(SqList&A,SqList B)//求元素递增排列的线性表A 和B的元素的交集并存回A中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;else if(A.elem>B.elem[j]) j++;else if(A.elem!=A.elem[k]){A.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素i++;j++; //且C中没有,就添加到C中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题{p=A->next;q=B->next;pc=A;while(p&&q){if(p->data<q->data) p=p->next; else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){pc=pc->next;pc->data=p->data;p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList&A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置while(i<A.length&&j<B.length&&k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;else{same=B.elem[j];//找到了相同元素same while(B.elem[j]==same) j++;while(C.elem[k]==same)k++; //j,k后移到新的元素while(i<A.length&&A.elem<same)A.elem[m++]=A.elem[i++];//需保留的元素移动到新位置while(i<A.length&&A.elem==same) i++; //跳过相同的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。

严蔚敏《数据结构（C语言版）习题集》答案第一章绪论void print_descending(int x,int y,int z)....+f[m-k]=f[m-1]+f[m-2]+......+f[m-k]+f[m-k-1]-f[m-k-1]=2*f[m-1]-f[m-k-1]所以上述算法的时间复杂度仅为O(m). 如果采用递归设计,将达到O(k^m). 即使采用暂存中间结果的方法,也将达到O(m^2).typedef struct{char *sport;enum{male,female} gender;char schoolname; port!=NULL){switch(result[i].schoolname){case 'A':score[ 0 ].totalscore+=result[i].score;if(result[i].gender==0) score[ 0 ].malescore+=result[i].score;else score[ 0 ].femalescore+=result[i].score;break;case 'B':score[ 0 ].totalscore+=result[i].score;if(result[i].gender==0) score[ 0 ].malescore+=result[i].score;else score[ 0 ].femalescore+=result[i].score;break;………………}i++；}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score of male:%d\n",score[i].malescore);printf("Total score of female:%d\n",score[i].femalescore);printf("Total score of all:%d\n\n",score[i].totalscore);}}void polyvalue(){float temp;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input value of x:");scanf("%f",&x);printf("Input the %d coefficients from a0 to a%d:\n",n+1,n);p=a;xp=1;sum=0;Status Insert(LinkList &L,int i,int b)void merge1(LinkList &A,LinkList &B,LinkList &C)void SqList_Intersect(SqList A,SqList B,SqList &C)void LinkList_Intersect_Delete(LinkList &A,LinkList B,LinkList C)iList为带头结点的单循环链表类型.{s=L->next;A=(CiList*)malloc(sizeof(CiLNode));p=A;B=(CiList*)malloc(sizeof(CiLNode));q=B;C=(CiList*)malloc(sizeof(CiLNode));r=C; .4,2的顺序重排双向循环链表L中的所有结点{p=;while(p->next!=L&&p->next->next!=L){p->next=p->next->next;p=p->next;} 同时进行调整的话,必须使用堆栈保存偶数结点的指针,否则将会破坏链表结构,造成结点丢失.DuLNode * Locate_DuList(DuLinkedList &L,int x) int x;int y;} coordinate;void Repaint_Color(int g[m][n],int i,int j,int color)归形式的算法该怎么写呢?void NiBoLan(char *str,char *new)题中暂不考虑串的具体操作的实现,而将其看作一种抽象数据类型stringtype,对其可以进行连接操作:c=link(a,b).Status g(int m,int n,int &s)void InitCiQueue(CiQueue &Q)Status EnCyQueue(CyQueue &Q,int x)省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place', T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?int Delete_SubString(Stringtype &s,Stringtype t)读者用此程序取代作者早些时候对题给出的程序.void StrAssign(Stringtype &T,char chars&#;)h&&T[j].ch!=c) j++; h) T[j].num++;else T[j]={c,1};}h;j++)printf("%c: %d\n",T[j].ch,T[j].num);}前一个程序的区别在于,串s业已存在.{for(p=s->next,q=t->next;p&&q;p=p->next,q=q->next){p->ch=q->ch;pre=p;}while(q){p=(LStrNode*)malloc(sizeof(LStrNode));p->ch=q->ch;pre->next=p;pre=p;}p->next=NULL;}算法的思想是,依次把串S的一个副本S2向右错位平移1格,2格,3格,...与自身S1相匹配,如果存在最长重复子串,则必然能在此过程中被发现.用变量lrs1,lrs2,maxlen来记录已发现的最长重复子串第一次出现位置,第二次出现位置和长度.题目中未说明"重复子串"是否允许有重叠部分,本算法假定允许.如不允许,只需在第二个for语句的循环条件中加上k<=i即可.本算法时间复杂度为O(Strlen(S)^2).void Get_LPubSub(Stringtype S,Stringtype T) for(k=0,j=jmin;j<=jmax;j++){if(A[j]==B[j-i]) k++;else k=0;if(k>maxlen){lps1=j-k+1;lps2=j-i-k+1;maxlen=k;}}一的区别是,由于A,B互不相同,因此B不仅要向右错位,而且还要向左错位,以保证不漏掉一些情况.当B相对于A的位置不同时,需要匹配的区间的计算公式也各不相同,请读者自己画图以帮助理解.本算法的时间复杂度是o（strlrn（s）*strlen（t））。