严蔚敏数据结构c语言版习题集答案第四章串

合集下载

严蔚敏《数据结构(c语言版)习题集》答案第四章串

《一定能摸到红球吗？》说课稿
林银花
一、教材说明：
１、课题：《一定能摸到红球吗？》
２、本节内容的地位和作用
在现代社会中，人们面临着更多的机会和选择，常常需要在不确定情境中作出合理的决策,概率正是通过对不确定现象和事件发生的可能性的刻画,来为人们更好的制定决策提供依据和建议.本节内容又是义务教育阶段,唯一培养学生从不确定的角度来观察世界的数学内容,让学生了解可能性是普遍的,有助于他们理解社会,适应生活.
(１) 每位同学从盒子中轮流摸球,记录下所摸球的颜色,并将球放回盒中.
(２) 做１０次这样的活动,将最终结果填在表中.
(３) 全班将各小组活动进行汇总，摸到红球的次数是多少?摸到黄球的次数是多少?他们各占总数的百分比是多少?
(４) 你认为哪种颜色的球多?打开看一看.
(５) 如果从盒中任意摸出一球,你认为摸到哪种颜色的球可能性大? 学生阅读学习目标.
学生两人一组进行活动.一人摸一人记录.并交流.
题(1)：学生先想象后画图，并通过搭建几何体验证学习成果。
题(2)：学生四人一组进行活动，一人搭几何体，另三人画图并交流，如有异义，举手询问。依次轮流。使学生明确学习目标，进入学习角色，做到有的放矢。
目的是使学生体会到进行概率试验时,一定要保证随机性.
课堂组织策略：创设贴近学生生活，生动有趣的问题情境，开展活泼、主动、有效的数学活动，组织学生主动参与、勤于动手、积极思考，使他们在自主探索和合作交流的过程中真正理解和掌握概率有关内容。
学生学习策略：明确学习目标，了解所需掌握的知识，在教师的组织、引导、点拨下主动地从事观察、试验、猜测、验证与交流等数学活动，从而真正有效地理解和掌握知识。
（３）、情感目标：

严蔚敏版数据结构课后习题答案-完整版

2n
2
，g
n
n n2
n5
解： (1)g(n) 快 (2)g(n) 快 (3)f(n) 快 (4) f(n) 快
1.15 试用数学归纳法证明：
n
(1)
i 2 n n 1 2n 1 / 6
i1
n0
n
(2)
xi
i0
xn 1 1 / x 1
x 1, n 0
n
(3)
2i 1 2n 1
i1
n1
n
(4)
2i 1 n 2
(2) 以函数的返回值判断正确与否常用于子程序的测试，便于实现程序的局部控制。
(3) 用整型函数进行错误处理的优点是可以给出错误类型，便于迅速确定错误。 1.7 在程序设计中，可采用下列三种方法实现输出和输入：
(1) 通过 scanf 和 printf 语句； (2) 通过函数的参数显式传递； (3) 通过全局变量隐式传递。试讨论这三种方法的优缺点。
解：(1) 用 scanf 和 printf 直接进行输入输出的好处是形象、直观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则会引起整个系统的崩溃。
(2) 通过函数的参数传递进行输入输出，便于实现信息的隐蔽，减少出错的可能。
(3) 通过全局变量的隐式传递进行输入输出最为方便，只需修改变量的值即可，但过多的全局变量使程序的维护较为困难。 1.8 设 n 为正整数。试确定下列各程序段中前置以记号 @的语句的频度：
i1
n1
1.16 试写一算法，自大至小依次输出顺序读入的三个整数 X，Y 和 Z
的值
解：
int max3(int x,int y,int z)
{

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

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

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

严蔚敏数据结构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。

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版习题集解析部分第4章串——《数据结构题集》-严蔚敏.吴伟民版源码使⽤说明链接☛☛☛课本源码合辑链接☛☛☛习题集全解析链接☛☛☛相关测试数据下载链接☛本习题⽂档的存放⽬录：数据结构\▼配套习题解析\▼04 串⽂档中源码的存放⽬录：数据结构\▼配套习题解析\▼04 串\▼习题测试⽂档-04源码测试数据存放⽬录：数据结构\▼配套习题解析\▼04 串\▼习题测试⽂档-04\Data⼀、基础知识题4.1❶简述空串和空格串（或称空格符串）的区别。

4.2❷对于教科书4.1节中所述串的各个基本操作，讨论是否可由其他基本操作构造⽽得，如何构造？4.3❶设s = ‘I AM A STUDENT’，t = ‘GOOD’，q = ‘WORKER’。

求：StrLength(s)，StrLength(t)，SubString(s, 8, 7)，SubString(t, 2, 1)，Index(s, ‘A’)，Index(s, t)，Replace(s, ‘STUDENT’, q)，Concat(SubString(s, 6, 2), Concat(t, SubString(s, 7, 8)))。

4.4❶已知下列字符串a = ‘THIS’,　f = ‘A SAMPLE’,　c = ‘GOOD’,　d = ‘NE’,b = ‘ ’.s = Concat(a, Concat(SubString(f, 2, 7), Concat(b, SubString(a, 3, 2)))),t = Replace(f, SubString(f, 3, 6), c),u = Concat(SubString(c, 3, 1), d),g = ‘IS’,v = Concat(s, Concat(b, Concat(t, Concat(b, u)))),试问：s，t，v，StrLength(s)，Index(v, g)，Index(u, g)各是什么？4.5❶试问执⾏以下函数会产⽣怎样的输出结果？void demonstrate(){StrAssign(s, ‘THIS IS A BOOK’);Replace(s, SubString(s, 3, 7), ‘ESE ARE’);StrAssign(t, Concat(s, ‘S’));StrAssign(u, ‘XYXYXYXYXYXY’);StrAssign(v, SubString(u, 6, 3));StrAssign(w, ‘W’);printf(‘t=’, t, ‘v=’, v, ‘u=’, Replace(u, v, w));}//demonstrate4.6❷已知：s = ‘(XYZ)+*’,t = ‘(X+Z)*Y’。

数据结构C语言版第版习题答案—严蔚敏精修订

数据结构C语言版第版习题答案—严蔚敏GE GROUP system office room 【GEIHUA16H-GEIHUA GEIHUA8Q8-数据结构（C语言版）（第2版）课后习题答案李冬梅2015.3目录第1章绪论............................................. 第2章线性表 ........................................... 第3章栈和队列 ......................................... 第4章串、数组和广义表.................................. 第5章树和二叉树 ....................................... 第6章图................................................ 第7章查找 ............................................. 第8章排序.............................................第1章绪论1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。

答案：数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。

如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。

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

在有些情况下，数据元素也称为元素、结点、记录等。

数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。

数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。

例如，学生基本信息表中的学号、姓名、性别等都是数据项。

数据结构习题集答案(C语言版严蔚详细版敏)(1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1.3 设有数据结构(D,R)，其中，，试按图论中图的画法惯例画出其逻辑结构图。

解：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和mDestroyRationalNumber(&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语言版严蔚敏课后习题答案

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

严蔚敏数据结构课后习题及答案解析

第一章绪论一、选择题1.组成数据的基本单位是（）（A）数据项（B）数据类型（C）数据元素（D）数据变量2.数据结构是研究数据的（）以及它们之间的相互关系。

（A）理想结构，物理结构（B）理想结构，抽象结构（C）物理结构，逻辑结构（D）抽象结构，逻辑结构3.在数据结构中，从逻辑上可以把数据结构分成（）（A）动态结构和静态结构（B）紧凑结构和非紧凑结构（C）线性结构和非线性结构（D）内部结构和外部结构4.数据结构是一门研究非数值计算的程序设计问题中计算机的（①）以及它们之间的（②）和运算等的学科。

①（A）数据元素（B）计算方法（C）逻辑存储（D）数据映像②（A）结构（B）关系（C）运算（D）算法5.算法分析的目的是（）。

（A）找出数据结构的合理性（B）研究算法中的输入和输出的关系（C）分析算法的效率以求改进（D）分析算法的易懂性和文档性6.计算机算法指的是（①）,它必须具备输入、输出和（②）等5个特性。

①（A）计算方法（B）排序方法（C）解决问题的有限运算序列（D）调度方法②（A）可执行性、可移植性和可扩充性（B）可行性、确定性和有穷性（C）确定性、有穷性和稳定性（D）易读性、稳定性和安全性二、判断题1.数据的机内表示称为数据的存储结构。

（）2.算法就是程序。

（）3.数据元素是数据的最小单位。

（）4.算法的五个特性为：有穷性、输入、输出、完成性和确定性。

（）5.算法的时间复杂度取决于问题的规模和待处理数据的初态。

（）三、填空题1.数据逻辑结构包括________、________、_________ 和_________四种类型,其中树形结构和图形结构合称为_____。

2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点。

3.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________。

《数据结构(C语言版第2版)》(严蔚敏著)第四章练习题答案

《数据结构（C语言版第2版）》（严蔚敏著）第四章练习题答案第4章串、数组和广义表1．选择题（1）串是一种特殊的线性表，其特殊性体现在（）。

A．可以顺序存储B．数据元素是一个字符C．可以链式存储D．数据元素可以是多个字符若答案：B（2）串下面关于串的的叙述中，（）是不正确的？A．串是字符的有限序列B．空串是由空格构成的串C．模式匹配是串的一种重要运算D．串既可以采用顺序存储，也可以采用链式存储答案：B解释：空格常常是串的字符集合中的一个元素，有一个或多个空格组成的串成为空格串，零个字符的串成为空串，其长度为零。

（3）串“ababaaababaa”的next数组为（）。

A．012345678999 B．012121111212 C．011234223456 D．0123012322345答案：C（4）串“ababaabab”的nextval为（）。

A．010104101B．010102101 C．010100011 D．010101011答案：A（5）串的长度是指（）。

A．串中所含不同字母的个数B．串中所含字符的个数C．串中所含不同字符的个数D．串中所含非空格字符的个数答案：B解释：串中字符的数目称为串的长度。

（6）假设以行序为主序存储二维数组A=array[1..100,1..100]，设每个数据元素占2个存储单元，基地址为10，则LOC[5,5]=（）。

A．808 B．818 C．1010 D．1020答案：B解释：以行序为主，则LOC[5,5]=[（5-1）*100+（5-1）]*2+10=818。

（7）设有数组A[i,j]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以列为主存放时，元素A[5,8]的存储首地址为（）。

A．BA+141 B．BA+180 C．BA+222 D．BA+225答案：B解释：以列序为主，则LOC[5,8]=[（8-1）*8+（5-1）]*3+BA=BA+180。

严蔚敏数据结构课后习题及答案解析

第一章绪论一、选择题1.组成数据的基本单位是A数据项B数据类型C数据元素D数据变量2.数据结构是研究数据的以及它们之间的相互关系;A理想结构,物理结构B理想结构,抽象结构C物理结构,逻辑结构D抽象结构,逻辑结构3.在数据结构中,从逻辑上可以把数据结构分成A动态结构和静态结构B紧凑结构和非紧凑结构C线性结构和非线性结构D内部结构和外部结构4.数据结构是一门研究非数值计算的程序设计问题中计算机的①以及它们之间的②和运算等的学科;① A数据元素B计算方法C逻辑存储D数据映像② A结构B关系C运算D算法5.算法分析的目的是;A 找出数据结构的合理性B研究算法中的输入和输出的关系C分析算法的效率以求改进D分析算法的易懂性和文档性6.计算机算法指的是①,它必须具备输入、输出和②等5个特性;① A计算方法B排序方法C解决问题的有限运算序列D调度方法② A可执行性、可移植性和可扩充性B可行性、确定性和有穷性C确定性、有穷性和稳定性D易读性、稳定性和安全性二、判断题1.数据的机内表示称为数据的存储结构;2.算法就是程序;3.数据元素是数据的最小单位;4.算法的五个特性为：有穷性、输入、输出、完成性和确定性;5.算法的时间复杂度取决于问题的规模和待处理数据的初态;三、填空题1.数据逻辑结构包括________、________、_________ 和_________四种类型,其中树形结构和图形结构合称为_____;2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点;3.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________;4.在图形结构中,每个结点的前驱结点数和后续结点数可以_________;5.线性结构中元素之间存在________关系,树形结构中元素之间存在______关系,图形结构中元素之间存在_______关系;6.算法的五个重要特性是_______、_______、______、_______、_______;7.数据结构的三要素是指______、_______和________;8.链式存储结构与顺序存储结构相比较,主要优点是________________________________;9.设有一批数据元素,为了最快的存储某元素,数据结构宜用_________结构,为了方便插入一个元素,数据结构宜用____________结构;四、算法分析题1.求下列算法段的语句频度及时间复杂度参考答案：一、选择题1. C 3. C 4. A、B 5. C 、B二、判断题:1、√2、×3、×4、×5、√三、填空题1、线性、树形、图形、集合；非线性网状2、没有；1；没有；13、前驱；1；后继；任意多个4、任意多个5、一对一；一对多；多对多6、有穷性；确定性；可行性；输入；输出7、数据元素；逻辑结构；存储结构8、插入、删除、合并等操作较方便9、顺序存储；链式存储四、算法分析题fori=1; i<=n; i++forj =1; j <=i ; j++x=x+1;分析：该算法为一个二重循环,执行次数为内、外循环次数相乘,但内循环次数不固定,与外循环有关,因些,时间频度Tn=1+2+3+…+n=nn+1/2有1/4≤Tn/n2≤1,故它的时间复杂度为Ｏn2, 即Ｔn与n2 数量级相同; 2、分析下列算法段的时间频度及时间复杂度for i=1;i<=n;i++for j=1;j<=i;j++for k=1;k<=j;k++x=i+j-k;分析算法规律可知时间频度Tn=1+1+2+1+2+3+...+1+2+3+…+n由于有1/6 ≤ Tn/ n3 ≤1,故时间复杂度为Ｏn3第二章线性表一、选择题1.一个线性表第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是A110 B108C100 D1202. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动个元素;A64B63 C D73.线性表采用链式存储结构时,其地址;A 必须是连续的B 部分地址必须是连续的C 一定是不连续的D 连续与否均可以4. 在一个单链表中,若p所指结点不是最后结点,在p之后插入s所指结点,则执行As->next=p;p->next=s; B s->next=p->next;p->next=s;Cs->next=p->next;p=s; Dp->next=s;s->next=p;5.在一个单链表中,若删除p所指结点的后续结点,则执行Ap->next=p->next->next; Bp=p->next; p->next=p->next->next;Cp->next=p->next; Dp =p->next->next;6.下列有关线性表的叙述中,正确的是A线性表中的元素之间隔是线性关系B线性表中至少有一个元素C线性表中任何一个元素有且仅有一个直接前趋D线性表中任何一个元素有且仅有一个直接后继7.线性表是具有n个的有限序列n≠0A表元素B字符C数据元素D数据项二、判断题1.线性表的链接存储,表中元素的逻辑顺序与物理顺序一定相同;2.如果没有提供指针类型的语言,就无法构造链式结构;3.线性结构的特点是只有一个结点没有前驱,只有一个结点没有后继,其余的结点只有一个前驱和后继;4.语句p=p->next完成了指针赋值并使p指针得到了p指针所指后继结点的数据域值;5.要想删除p指针的后继结点,我们应该执行q=p->next ；p->next=q->next；freeq;三、填空题1.已知P为单链表中的非首尾结点,在P结点后插入S结点的语句为：_______________________ ;2.顺序表中逻辑上相邻的元素物理位置相邻, 单链表中逻辑上相邻的元素物理位置_________相邻;3.线性表L＝a1,a2,...,an采用顺序存储,假定在不同的n＋1个位置上插入的概率相同,则插入一个新元素平均需要移动的元素个数是________________________4.在非空双向循环链表中,在结点q的前面插入结点p的过程如下：p->prior=q->prior;q->prior->next=p;p->next=q;______________________;5.已知L是无表头结点的单链表,是从下列提供的答案中选择合适的语句序列,分别实现：1表尾插入s结点的语句序列是_______________________________2 表尾插入s结点的语句序列是_______________________________1.p->next=s;2.p=L;3.L=s;4.p->next=s->next;5.s->next=p->next;6.s->next=L;7.s->next=null;8.whilep->next= Q p=p-next;9.whilep->next=null p=p->next;四、算法设计题1.试编写一个求已知单链表的数据域的平均值的函数数据域数据类型为整型;2.已知带有头结点的循环链表中头指针为head,试写出删除并释放数据域值为x的所有结点的c函数;3.某百货公司仓库中有一批电视机,按其价格从低到高的次序构成一个循环链表,每个结点有价格、数量和链指针三个域;现出库销售m台价格为h的电视机,试编写算法修改原链表;4.某百货公司仓库中有一批电视机,按其价格从低到高的次序构成一个循环链表,每个结点有价格、数量和链指针三个域;现新到m台价格为h的电视机,试编写算法修改原链表;5.线性表中的元素值按递增有序排列,针对顺序表和循环链表两种不同的存储方式,分别编写C函数删除线性表中值介于a与ba≤b之间的元素;6.设A=a0,a1,a2,...,an-1,B=b0,b1,b2,...,bm-1是两个给定的线性表,它们的结点个数分别是n和m,且结点值均是整数;若n=m,且ai= bi 0≤i<n ,则A=B；若n<m ,且ai=bi 0≤i<n ,则A<B；若存在一个j, j<m ,j<n ,且ai=bi 0≤i<j , 若aj<bj,则A<B,否则A>B;试编写一个比较A和B的C函数,该函数返回-1或0或1,分别表示A<B或A=B或A>B;7.试编写算法,删除双向循环链表中第k个结点;8.线性表由前后两部分性质不同的元素组成a0,a1,...,an-1,b0,b1,...,bm-1,m和n为两部分元素的个数,若线性表分别采用数组和链表两种方式存储,编写算法将两部分元素换位成b0,b1,...,bm-1,a0,a1,...,an-1,分析两种存储方式下算法的时间和空间复杂度;9.用循环链表作线性表a0,a1,...,an-1和b0,b1,...,bm-1的存储结构,头指针分别为ah和bh,设计C函数,把两个线性表合并成形如a0,b0,a1,b1,…的线性表,要求不开辟新的动态空间,利用原来循环链表的结点完成合并操作,结构仍为循环链表,头指针为head,并分析算法的时间复杂度;10.试写出将一个线性表分解为两个带有头结点的循环链表,并将两个循环链表的长度放在各自的头结点的数据域中的C函数;其中,线性表中序号为偶数的元素分解到第一个循环链表中,序号为奇数的元素分解到第二个循环链表中;11.试写出把线性链表改为循环链表的C函数;12.己知非空线性链表中x结点的直接前驱结点为y,试写出删除x结点的C函数;参考答案：一、选择题1. B 3. D 4. B 5. A 7、C二、判断题:参考答案：1、×2、√3、×4、×5、√三、填空题1、s->next=p->next; p->next=s;2、一定；不一定3、n/24、q->prior=p;5、16 32 2 91 7四、算法设计题1、include ""include ""typedef struct node{int data;struct node link;}NODE;int averNODE head{int i=0,sum=0,ave; NODE p;p=head;whilep=NULL{p=p->link;++i;sum=sum+p->data;}ave=sum/i;return ave;}2、include ""include ""typedef struct node{int data; / 假设数据域为整型/struct node link;}NODE;void del_linkNODE head,int x / 删除数据域为x的结点/ {NODE p,q,s;p=head;q=head->link;whileq=head{ifq->data==x{p->link=q->link;s=q;q=q->link;frees;}else{p=q;q=q->link;}}}3、void delNODE head,float price,int num {NODE p,q,s;p=head;q=head->next;whileq->price<price&&q=head{p=q;q=q->next;}ifq->price==priceq->num=q->num-num; elseprintf"无此产品"; ifq->num==0{p->next=q->next; freeq;}}4、include ""include ""typedef struct node {float price;int num;struct node next;}NODE;void insNODE head,float price,int num {NODE p,q,s;p=head;q=head->next;whileq->price<price&&q=head{p=q;q=q->next;}ifq->price==priceq->num=q->num+num;else{s=NODE mallocsizeofNODE;s->price=price;s->num=num;s->next=p->next;p->next=s;}}5、顺序表：算法思想：从0开始扫描线性表,用k记录下元素值在a与b之间的元素个数,对于不满足该条件的元素,前移k个位置,最后修改线性表的长度;void delelemtype list,int n,elemtype a,elemtype b{int i=0,k=0；whilei<n{iflisti>=a&&listi<=b k++;elselisti-k=listi;i++;}n=n-k; / 修改线性表的长度/}循环链表:void delNODE head,elemtype a,elemtype b{NODE p,q;p= head;q=p->link; / 假设循环链表带有头结点/ whileq=head && q->data<a{p=q;q=q->link;}whileq=head && q->data<b{r=q;q=q->link;freer;}ifp=qp->link=q;}6、define MAXSIZE 100int listAMAXSIZE,listBMAXSIZE; int n,m;int compareint a,int b{int i=0;whileai==bi&&i<n&&i<mi++;ifn==m&&i==n return0;ifn<m&&i==n return-1;ifn>m&&i==m return1;ifi<n&&i<mifai<bi return-1;else ifai>bi return1;}7、void delDUNODE head,int i{DUNODE p;{head=head->next;head->prior=NULL;return0;}Else{forj=0;j<i&&p=NULL;j++p=p->next;ifp==NULL||j>i return1;p->prior->next=p->next;p->next->prior=p->proir;freep;return0;}8.顺序存储:void convertelemtype list,int l,int h / 将数组中第l个到第h个元素逆置/ {elemtype temp;fori=h;i<=l+h/2;i++{temp=listi;listi=listl+h-i;listl+h-i=temp;}}void exchangeelemtype list,int n,int m; {convertlist,0,n+m-1;convertlist,0,m-1;convertlist,m,n+m-1;}该算法的时间复杂度为On+m,空间复杂度为O1 链接存储:不带头结点的单链表typedef struct node{elemtype data;struct node link;}NODE;void convertNODE head,int n,int m{NODE p,q,r;int i;p=head;q=head;fori=0;i<n-1;i++q=q->link; /q指向an-1结点/r=q->link;q->link=NULL;whiler->link=NULLr=r->link; /r指向最后一个bm-1结点/head=q;r->link=p;}该算法的时间复杂度为On+m,但比顺序存储节省时间不需要移动元素,只需改变指针,空间复杂度为O1typedef struct node{elemtype data;struct node link;}NODE;NODE unionNODE ah,NODE bh {NODE a,b,head,r,q;head=ah;a=ah;b=bh;whilea->link=ah&&b->link=bh {r=a->link;q=b->link;a->link=b;b->link=r;a=r;}ifa->link==ah /a的结点个数小于等于b的结点个数/{a->link=b;whileb->link=bhb=b->link;b->link=head;}ifb->link==bh /b的结点个数小于a的结点个数/{r=a->link;a->link=b;b->link=r;}returnhead;}该算法的时间复杂度为On+m,其中n和m为两个循环链表的结点个数.10.typedef struct node{elemtype data;struct node link;}NODE;void analyzeNODE a{NODE rh,qh,r,q,p；int i=0,j=0；/i为序号是奇数的结点个数j为序号是偶数的结点个数/ p=a；rh=NODE mallocsizeofNODE；/rh为序号是奇数的链表头指针/qh=NODE mallocsizeofNODE; /qh为序号是偶数的链表头指针/r=rh;q=qh;whilep=NULL{r->link=p;r=p;i++;p=p->link;ifp=NULL{q->link=p;q=p;j++;p=p->link;}}rh->data=i;r->link=rh;qh->data=j;q->link=qh;}11.typedef struct node {elemtype data;struct node link;}NODE;void changeNODE head {NODE p;p=head;ifhead=NULL{whilep->link=NULLp=p->link;p->link=head;}}12.typedef struct node {elemtype data;struct node link;}NODE;void delNODE x,NODE y{NODE p,q;elemtype d1;p=y;q=x;whileq->next=NULL / 把后一个结点数据域前移到前一个结点/ {p->data=q->data;q=q->link;p=q;p->link=NULL; / 删除最后一个结点/freeq;}第三章栈和队列一、选择题1. 一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是;A edcbaBdecbaCdceab Dabcde2.栈结构通常采用的两种存储结构是;A 线性存储结构和链表存储结构B散列方式和索引方式C链表存储结构和数组D线性存储结构和非线性存储结构3.判定一个栈ST最多元素为m0为空的条件是;A ST-〉top=0 BST-〉top==0CST-〉top=m0 DST-〉top=m04.判定一个栈ST最多元素为m0为栈满的条件是;AST->top=0 BST->top==0CST->top=m0-1DST->top==m0-15.一个队列的入列序列是1,2,3,4,则队列的输出序列是;A4,3,2,1B1,2,3,4C1,4,3,2D3,2,4,16.循环队列用数组A0,m-1存放其元素值,已知其头尾指针分别是front和rear则当前队列中的元素个数是Arear-front+m%m B rear-front+1 Crear-front-1Drear-front7.栈和队列的共同点是A 都是先进后出B都是先进先出C只允许在端点处插入和删除元素D没有共同点8.表达式ab+c-d的后缀表达式是;Aabcd+-Babc+d- Cabc+d-D-+abcd个元素a1,a2,a3和a4依次通过一个栈,在a4进栈前,栈的状态,则不可能的出栈序是Aa4,a3,a2,a1 Ba3,a2,a4,a1Ca3,a1,a4,a2 Da3,a4,a2,a110.以数组Q0..m－1存放循环队列中的元素,变量rear和qulen分别指示循环队列中队尾元素的实际位置和当前队列中元素的个数,队列第一个元素的实际位置是Arear－qulen Brear－qulen＋mCm－qulen D1＋rear＋m－qulen% m二、填空题1.栈的特点是_______________________,队列的特点是__________________________;2.线性表、栈和队列都是_____________________结构,可以在线性表的______________位置插入和删除元素,对于栈只能在________插入和删除元素,对于队列只能在_______插入元素和_________删除元素;3.一个栈的输入序列是12345,则栈有输出序列12345是____________;正确/错误4.设栈S和队列Q的初始状态皆为空,元素a1,a2,a3,a4,a5和a6依次通过一个栈,一个元素出栈后即进入队列Q,若6个元素出队列的顺序是a3,a5,a4,a6,a2,a1则栈S至少应该容纳_____个元素;三、算法设计题1.假设有两个栈s1和s2共享一个数组stackM,其中一个栈底设在stack0处,另一个栈底设在stackM-1处;试编写对任一栈作进栈和出栈运算的C函数pushx,i和popi,i=l,2;其中i=1表示左边的栈,,i=2表示右边的栈;要求在整个数组元素都被占用时才产生溢出;2.利用两个栈s1,s2模拟一个队列时,如何用栈的运算来实现该队列的运算写出模拟队列的插入和删除的C函数;一个栈s1用于插入元素,另一个栈s2用于删除元素.参考答案：一、选择题1. C 3. B 4. B 5. B 7、C 8、C 9、C 10、D二、填空题1、先进先出；先进后出2、线性；任何；栈顶；队尾；对头3、正确的4、3三、算法设计题1.define M 100elemtype stackM;int top1=0,top2=m-1;int pushelemtype x,int i{iftop1-top2==1 return1; /上溢处理/elseifi==1 stacktop1++=x;ifi==2stacktop2--=x;return0;}int popelemtype px,int iifi==1iftop1==0 return1; else{top1--;px=stacktop1;return0;}elseifi==2iftop2==M-1 return1; else{top2++;px=stacktop2;return0;}}elemtype s1MAXSIZE,s2MAZSIZE; int top1,top2;void enqueueelemtype x{iftop1==MAXSIZE return1;else{pushs1,x;return0;}}void dequeueelemtype px{elemtype x;top2=0;whileemptys1{pops1,&x;pushs2,x;pops2,&x;whileemptys2{pops2,&x;pushs1,x;}}第四章串一、选择题1.下列关于串的叙述中,正确的是A一个串的字符个数即该串的长度B一个串的长度至少是1C空串是由一个空格字符组成的串D两个串S1和S2若长度相同,则这两个串相等2.字符串"abaaabab"的nextval值为A0,1,01,1,0,4,1,0,1 B0,1,0,0,0,0,2,1,0,1C0,1,0,1,0,0,0,1,1 D0,1,0,1,0,1,0,1,13.字符串满足下式,其中head和tail的定义同广义表类似,如head‘xyz’=‘x’,tail‘xyz’= ‘yz’,则s= ; concatheadtails,headtailtails= ‘dc’; Aabcd Bacbd Cacdb Dadcb4.串是一种特殊的线性表,其特殊性表现在A可以顺序存储B数据元素是一个字符C可以链式存储D数据元素可以是多个字符5．设串S1=‘ABCDEFG’,s2=‘PQRST’,函数CONCATX,Y返回X和Y串的连接串,SUBSTRS,I,J 返回串S从序号I开始的J个字符组成的字串,LENGTHS返回串S的长度,则CONCATSUBSTRS1,2,LENGTHS2,SUBSTRS1,LENGTHS2,2的结果串是ABCDEF B BCDEFG CBCPQRST DBCDEFEF二、算法设计1.分别在顺序存储和一般链接存储两种方式下,用C语言写出实现把串s1复制到串s2的串复制函数strcpys1,s2;2.在一般链接存储一个结点存放一个字符方式下,写出采用简单算法实现串的模式匹配的C 语言函数int L_indext,p;参考答案：一、选择题1. A 3. D 4. D 5. D二、算法设计1.顺序存储：include ""define MAXN 100char sMAXN;int S_strlenchar s{int i;fori=0;si='\0';i++;returni;}void S_strcpychar s1,char s2 include "" typedef struct node{char data;struct node link;}NODE;int L_indexNODE t,NODE p{NODE t1,p1,t2;int i;t1=t;i=1;whilet1=NULL{p1=p;t2=t1->link;whilep1->data==t1->data&&p1=NULL{p1=p1->link;t1=t1->link;}ifp1==NULL returni;i++;t1=t2;}return0;}第五章数组和广义表一、选择题1. 常对数组进行的两种基本操作是A建立与删除B索引和修改C查找和修改D查找与索引2.二维数组M的元素是4个字符每个字符占一个存储单元组成的串,行下标i的范围从0到4,列下标j的范围从0到5,M按行存储时元素M35的起始地址与M按列存储时元素的起始地址相同;AM24BM34CM35DM443.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,存放该数组至少需要的单元数是;A80B100C240D2704.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按行存放时,元素A74的起始地址为;ASA+141BSA+144CSA+222DSA+2255.数组A810中,每个元素A的长度为3个字节,从首地址SA开始连续存放在存储器内,该数组按列存放时,元素A47的起始地址为;ASA+141BSA+180CSA+222DSA+2256.稀疏矩阵一般的压缩存储方法有两种,即;A 二维数组和三维数组B三元组和散列C三元组和十字链表D散列和十字链表7.若采用三元组压缩技术存储稀疏矩阵,只要把每个元素的行下标和列下标互换,就完成了对该矩阵的转置运算,这种观点;A正确B错误8.设矩阵A是一个对称矩阵,为了节省存储,将其下三角部分按行序存放在一维数组B1,nn-1/2中,对下三角部分中任一元素ai,ji<=j,在一组数组B的下标位置k的值是;Aii-1/2+j-1Bii-1/2+jCii+1/2+j-1 Dii+1/2+j二、填空题1.己知二维数组Amn采用行序为主方式存储,每个元素占k个存储单元,并且第一个元素的存储地址是LOCA00,则A00的地址是_____________________;2.二维数组A1020采用列序为主方式存储,每个元素占一个存储单元,并且A00的存储地址是200,则A612的地址是________________;3.有一个10阶对称矩阵A,采用压缩存储方式以行序为主,且A00=1,则A85的地址是__________________;4.设n行n列的下三角矩阵A已压缩到一维数组S1..nn+1/2中,若按行序为主存储,则Aij对应的S中的存储位置是________________;5.若A是按列序为主序进行存储的4×6的二维数组,其每个元素占用3个存储单元,并且A00的存储地址为1000,元素A13的存储地址为___________,该数组共占用_______________个存储单元;三、算法设计1.如果矩阵A中存在这样的一个元素Aij满足条件:Aij是第i行中值最小的元素,且又是第j 列中值最大的元素,则称之为该矩阵的一个马鞍点;编写一个函数计算出1×n的矩阵A的所有马鞍点;只猴子要选大王,选举办法如下:所有猴子按1,2,...,n编号围坐一圈,从1号开始按1、2、...、m报数,凡报m号的退出到圈外,如此循环报数,直到圈内剩下只猴子时,这只猴子就是大王;n 和m由键盘输入,打印出最后剩下的猴子号;编写一程序实现上述函数;3.数组和广义表的算法验证程序编写下列程序:1求广义表表头和表尾的函数head和tail;2计算广义表原子结点个数的函数count_GL;3计算广义表所有原子结点数据域设数据域为整型〉之和的函数sum_GL;参考答案：一、选择题1. C 3. C 4. C 5. B 7、B 8、B二、填空题1、locA00+ni+jk2、3323、424、ii+1/2+j+15、1039；72三、算法设计题1.算法思想：依题意,先求出每行的最小值元素,放入minm之中,再求出每列的最大值元素,放入maxn之中,若某元素既在mini中,又在maxj中,则该元素Aij便是马鞍点,找出所有这样的元素,即找到了所有马鞍点;因此,实现本题功能的程序如下:include <>define m 3define n 4void minmaxint amn{int i1,j,have=0;int minm,maxn;fori1=0;i1<m;i1++/计算出每行的最小值元素,放入minm之中/{mini1=ai10;forj=1;j<n;j++ifai1j<mini1 mini1=ai1j;}forj=0;j<n;j++/计算出每列的最大值元素,放入maxn之中/{maxj=a0j;fori1=1;i1<m;i1++ifai1j>max j maxj=ai1j;}fori1=0;i1<m;i1++forj=0;j<n;j++ifmini1==maxj{printf"%d,%d:%d\n",i1,j,ai1j;have=1;}ifhave printf"没有鞍点＼n";}2.算法思想:本题用一个含有n个元素的数组a,初始时ai中存放猴子的编号i,计数器似的值为0;从ai开始循环报数,每报一次,计数器的值加1,凡报到m时便打印出ai值退出圈外的猴子的编号,同时将ai的值改为O以后它不再参加报数,计数器值重新置为0;该函数一直进行到n 只猴子全部退出圈外为止,最后退出的猴子就是大王;因此,现本题功能的程序如下:include ""main{int a100;int count,d,j,m,n; scanf"%d %d",&m,&n;/ n>=m/ forj=0;j<n;j++aj=j+1;count=0;d=0;whiled<nforj=0;j<n;j++ifaj=0{count++;ifcount==m{printf"% d ",aj;aj=0;count=0;}}}3.include ""include ""typedef struct node { int tag;union{struct node sublist; char data;}dd;struct node link;}NODE;NODE creat_GLchar s {NODE h;char ch;s++;ifch='\0'{h=NODEmallocsizeofNODE; ifch==''{h->tag=1;h->=creat_GLs;}Else{h->tag=0;h->=ch;}}elseh=NULL;ch=s;s++;ifh=NULLifch==','h->link =creat_GLs; elseh->link=NULL; returnh;}void prn_GLNODE p {ifp=NULL{ifp->tag==1{printf"";ifp-> ==NULL printf" ";elseprn_GLp-> ;}elseprintf"%c",p->;ifp->tag==1printf"";ifp->link=NULL{printf",";prn_GLp->link;}}}NODE copy_GLNODE p{NODE q;ifp==NULL returnNULL;q=NODE mallocsizeofNODE; q->tag=p->tag;ifp->tagq-> =copy_GLp-> ;elseq-> =p->;q->link=copy_GLp->link;returnq;}NODE headNODE p /求表头函数/{returnp->;}NODE tailNODE p /求表尾函数/{returnp->link;}int sumNODE p /求原子结点的数据域之和函数/ { int m,n;ifp==NULL return0;else{ ifp->tag==0 n=p->;elsen=sump->;ifp->link=NULLm=sump->link;else m=0;returnn+m;}}int depthNODE p /求表的深度函数/ {int h,maxdh;NODE q;ifp->tag==0 return0;elseifp->tag==1&&p->==NULL return 1; else{maxdh=0;whilep=NULL{ifp->tag==0 h=0; else{q=p->;h=depthq;}ifh>maxdhmaxdh=h; p=p->link;}returnmaxdh+1;}}main{NODE hd,hc;char s100,p;p=getss;hd=creat_GL&p; prn_GLheadhd;prn_GLtailhd;hc=copy_GLhd;printf"copy after:";prn_GLhc;printf"sum:%d\n",sumhd;printf"depth:%d\n",depthhd;}第六章树和二叉树一、选择题1.在线索化二叉树中,t所指结点没有左子树的充要条件是At-〉left==NULL Bt-〉ltag==1Ct-〉ltag=1且t-〉left=NULLD以上都不对2.二叉树按某种顺序线索化后,任一结点均有指向其前趋和后继的线索,这种说法A正确B错误C不同情况下答案不确定3.二叉树的前序遍历序列中,任意一个结点均处在其子女结点的前面,这种说法A正确B错误C不同情况下答案不确定4.由于二叉树中每个结点的度最大为2,所以二叉树是一种特殊的树,这种说法A正确B错误C不同情况下答案不确定5.设高度为h的二叉树上只有度为0和度为2的结点,则此类二叉树中所包含的结点数至少为;A2h B2h-1C2h+1Dh+16.已知某二叉树的后序遍历序列是dabec;中序遍历序列是debac,它的前序遍历序列是;Aacbed BdecabCdeabc Dcedba7.如果T2是由有序树T转换而来的二叉树,那么T中结点的前序就是T2中结点的A前序B中序C后序D层次序8.某二叉树的前序遍历结点访问顺序是abdgcefh,中序遍历的结点访问顺序是dgbaechf,则其后序遍历的结点访问顺序是;Abdgcefha Bgdbecfha Cbdgaechf Dgdbehfca9.二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值;这种说法A正确B错误C不同情况下答案不确定10.按照二叉树的定义,具有3个结点的二叉树有种;A3B4C5D611.在一非空二叉树的中序遍历序列中,根结点的右边A只有右子树上的所有结点B只有右子树上的部分结点C只有左子树上的部分结点D只有左子树上的所有结点12.树最适合用来表示;A有序数据元素B无序数据元素C元素之间具有分支层次关系的数据D元素之间无联系的数据13.任何一棵二叉树的叶结点在先序、中序和后序遍历序列中的相对次序A不发生改变B发生改变C不能确定D.以上都不对14.实现任意二叉树的后序遍历的非递归算法而不使用栈结构,最佳方案是二叉树采用存储结构;A二叉链表B广义表存储结构C三叉链表D顺序存储结构15.对一个满二叉树,m个树叶,n个结点,深度为h,则An=h+m Bh+m=2nCm=h-1Dn=2h-116.如果某二叉树的前序为stuwv,中序为uwtvs,那么该二叉树的后序为Auwvts BvwutsCwuvts Dwutsv17.具有五层结点的二叉平衡树至少有个结点;A10B12C15D17二、判断题1.二叉树中任何一个结点的度都是2;2.由二叉树结点的先根序列和后根序列可以唯一地确定一棵二叉树;3.一棵哈夫曼树中不存在度为1的结点;4.平衡二叉排序树上任何一个结点的左、右子树的高度之差的绝对值不大于2三、填空题1.指出树和二叉树的三个主要差别___________,___________,_______________;2.从概念上讲,树与二叉树是两种不同的数据结构,将树转化为二叉树的基本目的是____________3.若结点A有三个兄弟包括A本身,并且B是A的双亲结点,B的度是_______________4.若一棵具有n个结点的二叉树采用标准链接存储结构,那么该二叉树所有结点共有_______个空指针域;5.已知二叉树的前序序列为ABDEGCFHIJ,中序序列为DBGEAHFIJC,写出后序序列_______________;6.已知二叉树的后序序列为FGDBHECA,中序序列为BFDGAEHC ,并写出前序序列_________________;7.找出满足下列条件的二叉树1先序和中序遍历,得到的结点访问顺序一样;_________________________2后序和中序遍历,得到的结点访问顺序一样;_________________________3先序和后序遍历,得到的结点访问顺序一样;__________________________8.一棵含有n个结点的k叉树,可能达到的最大深度和最小深度各是多少____________________9.一棵二叉树有67个结点,这些结点的度要么是0,要么是2;这棵二叉树中度为2的结点有______________________个;10.含有100个结点的树有_______________________________________条边;四、问答题1.一棵深度为h的满m叉树具有如下性质:第h层上的结点都是叶结点,其余各层上每个结点都有m棵非空子树;若按层次从上到下,每层从左到右的顺序从1开始对全部结点编号,试计算:1第k层结点数1≤k≤h;2整棵树结点数;3编号为i的结点的双亲结点的编号;4编号为i的结点的第j个孩子结点若有的编号;2.证明：一个满k叉树上的叶子结点数n0和非叶子结点数n1之间满足以下关系：n0=k-1n1+13.已知一组元素为50,28,78,65,23,36,13,42,71,请完成以下操作:1画出按元素排列顺序逐点插入所生成的二叉排序树BT;2分别计算在BT中查找各元素所要进行的元素间的比较次数及平均比较次数;3画出在BT中删除23〉后的二叉树;4.有七个带权结点,其权值分别为3,7,8,2,6,10,14,试以它们为叶结点构造一棵哈夫曼树请按照每个结点的左子树根结点的权小于等于右子树根结点的权的次序构造〉,并计算出带权路径长度WPL及该树的结点总数;5.有一电文共使用五种字符a,b,c,d,e,其出现频率依次为4,7,5,2,9;1试画出对应的编码哈夫曼树要求左子树根结点的权小于等于右子树根结点的权;2求出每个字符的晗夫曼编码;3求出传送电文的总长度;4并译出编码系列101的相应电文;五、算法设计已知一棵具有n个结点的完全二叉树被顺序存储在一维数组An中,试编写一个算法输出Ai结点的双亲和所有孩子;参考答案：一、选择题1. B 3. A 4. B 5. B 7、A 8、D 9、B 10、C 11、A 12、C 13、A 14、C 15、D 16、C 17 C。

数据结构c语言版严蔚敏课后习题答案

数据结构c语言版严蔚敏课后习题答案数据结构是计算机科学中非常重要的一门学科，它研究的是数据的组织、存储和管理方式。

而C语言作为一种广泛应用于系统编程和嵌入式开发的高级编程语言，与数据结构的学习息息相关。

本文将针对《数据结构（C语言版）》严蔚敏教材的课后习题提供一些答案，希望能够帮助读者更好地理解和掌握数据结构。

第一章：绪论在第一章中，主要介绍了数据结构的基本概念和基本术语。

课后习题主要是一些概念性的问题，例如数据结构与算法的关系、数据的逻辑结构和物理结构等。

这些问题的答案可以通过仔细阅读教材中的相关内容来得到。

第二章：线性表线性表是数据结构中最基本、最常用的一种结构。

课后习题主要涉及线性表的基本操作，如插入、删除、查找等。

这些问题的答案可以通过编写相应的C语言代码来实现。

第三章：栈和队列栈和队列是线性表的特殊形式，具有后进先出（LIFO）和先进先出（FIFO）的特点。

课后习题主要涉及栈和队列的基本操作，如进栈、出栈、入队、出队等。

这些问题的答案同样可以通过编写相应的C语言代码来实现。

第四章：串串是由零个或多个字符组成的有限序列，是一种特殊的线性表。

课后习题主要涉及串的模式匹配、串的替换等操作。

这些问题的答案可以通过使用C语言的字符串处理函数来实现。

第五章：数组和广义表数组是一种线性表的顺序存储结构，广义表是线性表的扩展。

课后习题主要涉及数组和广义表的创建、访问和操作等。

这些问题的答案可以通过编写相应的C语言代码来实现。

第六章：树树是一种非线性的数据结构，具有层次关系。

课后习题主要涉及树的遍历、节点的插入和删除等操作。

这些问题的答案可以通过使用C语言的指针和递归来实现。

第七章：图图是一种非线性的数据结构，由节点和边组成。

课后习题主要涉及图的遍历、最短路径、最小生成树等操作。

这些问题的答案可以通过使用C语言的图算法来实现。

通过以上的简要介绍，读者可以了解到《数据结构（C语言版）》严蔚敏教材的课后习题主要涵盖了线性表、栈和队列、串、数组和广义表、树、图等各个方面。

数据结构习题答案严蔚敏《数据结构(c语言版)习题集》答案

n (k 1) k 2*(k 1) 即：n=4k+3 k=(n-3)/4
而栈中最大元素个数为所有的操作符号和所有的左括号数目之和，即最大元素个数为：
k k 1 2k 1 2 * ((n 3) / 4) 1 (n 5) / 2
(2) 解答
优先级种类共三种，最大元素个数为 6×4＋3＝27
(4)答案
N 的取值 1 2 3 4 5
语句执行次数 100 68 51 44 35
N 的取值 6 7
8或9 10 到 14 15 或以上
语句执行次数 30 28 3*N 2*N N
第二章数组
2-7 答案 692
2-9 答案
n(n 1)
(1)
2
(2)
(2n i 2)(i 1) j i 2
第五章递归
5-1 答案
#include <iostream.h> class RecurveArray {
//数组类声明
private: int *Elements; int ArraySize; int CurrentSize;
//数组指针 //数组尺寸 //当前已有数组元素个数
public :
《数据结构》一些习题答案
第一章序论 1-5 (2) 简单易证，过程略。 1.7 求程序步数
(2)答案
n
i
j
n
1
i j n i(i 1)
i1 j 1 k 1
i1 j 1
i 1
2
1 2
n i 1
i2
n i 1
i
1 2
n(n
1)(2n 6
1)
n(n 1) 2
n(n 1)(n 2) 6

数据结构课后习题答案详解(C语言版_严蔚敏) 2

数据结构习题集答案(C语言版严蔚敏)第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(L,i+1,i*2);for(i=1;i<=3;i++) Del_LinkList(L,i);解：2.6 已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。

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

严蔚敏数据结构c语言版习题集全答案

说明: 1. 本文是对严蔚敏?数据构造(c语言版)习题集?一书中所有算法设计题目的解决方案,主要作者为kaoyan.计算机版版主一具.以下网友:siice,龙抬头,iamkent,zames,birdthinking等为答案的修订和完善工作提出了珍贵意见,在此表示感;2. 本解答中的所有算法均采用类c语言描述,设计原那么为面向交流、面向阅读,作者不保证程序能够上机正常运行(这种保证实际上也没有任何意义);3. 本解答原那么上只给出源代码以及必要的注释,对于一些难度较高或思路特殊的题目将给出简要的分析说明,对于作者无法解决的题目将给出必要的讨论.目前尚未解决的题目有: 5.20, 10.40;4. 请读者在自己已经解决了某个题目或进展了充分的思考之后,再参考本解答,以保证复习效果;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[i]=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[i]=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[i].sport!=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.totalscore+=result[i].score;if(result[i].gender==0) score.malescore+=result[i].score;else score.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);}}//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);}//polyvalue第二章线性表2.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[i]>x&&i>=0;i--)va.elem[i+1]=va.elem[i];va.elem[i+1]=x;return OK;}//Insert_SqList2.12int Listp(SqList A,SqList B)//比拟字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B {for(i=1;A.elem[i]||B.elem[i];i++)if(A.elem[i]!=B.elem[i]) return A.elem[i]-B.elem[i];return 0;}//Listp2.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{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){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[i]<->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){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[i]&&B.elem[j]){if(A.elem[i]<B.elem[j]) i++;if(A.elem[i]>B.elem[j]) j++;if(A.elem[i]==B.elem[j]){C.elem[++k]=A.elem[i]; //当发现了一个在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[i]&&B.elem[j]){if(A.elem[i]<B.elem[j]) i++;else if(A.elem[i]>B.elem[j]) j++;A.elem[++k]=A.elem[i]; //当发现了一个在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[i]<same)A.elem[m++]=A.elem[i++]; //需保存的元素移动到新位置while(i<A.length&&A.elem[i]==same) i++; //跳过一样的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++];//A的剩余元素重新存储。

数据结构(C语言版)习题及答案第四章

数据结构(C语言版)习题及答案第四章习题4.1选择题1、空串与空格串是（B）。

A、相同B、不相同Ｃ、不能确定2、串是一种特殊的线性表，其特殊性体现在（B）。

A、可以顺序存储B、数据元素是一个字符C、可以链式存储D、数据元素可以是多个字符3、设有两个串p和q，求q在p中首次出现的位置的操作是（B）。

A、连接B、模式匹配C、求子串D、求串长4、设串1=“ABCDEFG”，2=“PQRST”函数trconcat（，t）返回和t串的连接串，trub（，i，j）返回串中从第i个字符开始的、由连续j 个字符组成的子串。

trlength()返回串的长度。

则trconcat（trub（1，2，trlength（2）），trub（1，trlength（2），2））的结果串是（D）。

A、BCDEFB、BCDEFGC、BCPQRSTD、BCDEFEF5、若串=“oftware”，其子串个数是（B）。

A、8B、37C、36D、94.2简答题1、简述空串与空格串、主串与子串、串名与串值每对术语的区别？答：空串是指长度为0的串，即没有任何字符的串。

空格串是指由一个或多个空格组成的串，长度不为0。

子串是指由串中任意个连续字符组成的子序列，包含子串的串称为主串。

串名是串的一个名称，不指组成串的字符序列。

串值是指组成串的若干个字符序列，即双引号中的内容。

2、两个字符串相等的充要条件是什么？答：条件一是两个串的长度必须相等条件二是串中各个对应位置上的字符都相等。

3、串有哪几种存储结构？答：有三种存储结构，分别为：顺序存储、链式存储和索引存储。

4、已知两个串：1=”fgcdbcabcadr”,2=”abc”,试求两个串的长度，判断串2是否是串1的子串，并指出串2在串1中的位置。

答：（1）串1的长度为14，串2的长度为3。

（2）串2是串1的子串，在串2中的位置为9。

5、已知：1=〃I’matudent〃，2=〃tudent〃，3=〃teacher〃，试求下列各操作的结果：trlength(1)；答：13trconcat(2,3)；答：”tudentteachar”trdelub(1,4,10)；答：I’m6、设1=”AB”，2=”ABCD”，3=”EFGHIJK，试画出它们在各种存储结构下的结构图。

严蔚敏《数据结构(c语言版)习题集》答案第四章串

第四章串4.10void String_Reverse(Stringtype s,Stringtype &r)//求s的逆串r{StrAssign(r,''); //初始化r为空串for(i=Strlen(s);i;i--){StrAssign(c,SubString(s,i,1));StrAssign(r,Concat(r,c)); //把s的字符从后往前添加到r中}}//String_Reverse4.11void String_Subtract(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s 中而t中没有的字符构成的新串r{StrAssign(r,'');for(i=1;i<=Strlen(s);i++){StrAssign(c,SubString(s,i,1));for(j=1;j<i&&StrCompare(c,SubString(s,j,1));j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=Strlen(t)&&StrCompare(c,SubString(t,k,1));k++); //判断当前字符是否包含在t中if(k>Strlen(t)) StrAssign(r,Concat(r,c));}}//for}//String_Subtract4.12int Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T替换为V,并返回置换次数{for(n=0,i=1;i<=Strlen(S)-Strlen(T)+1;i++) //注意i的取值范围if(!StrCompare(SubString(S,i,Strlen(T)),T)) //找到了与T匹配的子串{ //分别把T的前面和后面部分保存为head和tailStrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(T),Strlen(S)-i-Strlen(T)+1));StrAssign(S,Concat(head,V));StrAssign(S,Concat(S,tail)); //把head,V,tail连接为新串i+=Strlen(V); //当前指针跳到插入串以后n++;}//ifreturn n;}//Replace分析:i+=Strlen(V);这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:设S='place', T='ace', V='face',则省掉i+=Strlen(V);运行时会出现什么结果?4.13int Delete_SubString(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=Strlen(s)-Strlen(t)+1;i++)if(!StrCompare(SubString(s,i,Strlen(t)),t)){StrAssign(head,SubString(S,1,i-1));StrAssign(tail,SubString(S,i+Strlen(t),Strlen(s)-i-Strlen(t)+1));StrAssign(S,Concat(head,tail)); //把head,tail连接为新串n++;}//ifreturn n,}//Delete_SubString4.14Status NiBoLan_to_BoLan(Stringtype str,Stringtype &new)//把前缀表达式str转换为后缀式new{Initstack(s); //s的元素为Stringtype类型for(i=1;i<=Strlen(str);i++){r=SubString(str,i,1);if(r为字母) push(s,r);else{if(StackEmpty(s)) return ERROR;pop(s,a);if(StackEmpty(s)) return ERROR;pop(s,b);StrAssign(t,Concat(r,b));StrAssign(c,Concat(t,a)); //把算符r,子前缀表达式a,b连接为新子前缀表达式c push(s,c);}}//forpop(s,new);if(!StackEmpty(s)) return ERROR;return OK;}//NiBoLan_to_BoLan分析:基本思想见书后注释3.23.请读者用此程序取代作者早些时候对3.23题给出的程序.4.15void StrAssign(Stringtype &T,char chars&#;)//用字符数组chars给串T赋值,Stringtype 的定义见课本{for(i=0,T[0]=0;chars[i];T[0]++,i++) T[i+1]=chars[i];}//StrAssign4.16char StrCompare(Stringtype s,Stringtype t)//串的比较,s>t时返回正数,s=t时返回0,s<t时返回负数{for(i=1;i<=s[0]&&i<=t[0]&&s[i]==t[i];i++);if(i>s[0]&&i>t[0]) return 0;else if(i>s[0]) return -t[i];else if(i>t[0]) return s[i];else return s[i]-t[i];}//StrCompare4.17int String_Replace(Stringtype &S,Stringtype T,Stringtype V);//将串S中所有子串T 替换为V,并返回置换次数{for(n=0,i=1;i<=S[0]-T[0]+1;i++){for(j=i,k=1;T[k]&&S[j]==T[k];j++,k++);if(k>T[0]) //找到了与T匹配的子串:分三种情况处理{if(T[0]==V[0])for(l=1;l<=T[0];l++) //新子串长度与原子串相同时:直接替换S[i+l-1]=V[l];else if(T[0]<V[0]) //新子串长度大于原子串时:先将后部右移{for(l=S[0];l>=i+T[0];l--)S[l+V[0]-T[0]]=S[l];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V[0];l<=S[0]+V[0]-T[0];l++)S[l]=S[l-V[0]+T[0]];for(l=1;l<=V[0];l++)S[i+l-1]=V[l];}S[0]=S[0]-T[0]+V[0];i+=V[0];n++;}//if}//forreturn n;}//String_Replace4.18typedef struct {char ch;int num;} mytype;void StrAnalyze(Stringtype S)//统计串S中字符的种类和个数{mytype T[MAXSIZE]; //用结构数组T存储统计结果for(i=1;i<=S[0];i++){c=S[i];j=0;while(T[j].ch&&T[j].ch!=c) j++; //查找当前字符c是否已记录过if(T[j].ch) T[j].num++;else T[j]={c,1};}//forfor(j=0;T[j].ch;j++)printf("%c: %d\n",T[j].ch,T[j].num);}//StrAnalyze4.19void Subtract_String(Stringtype s,Stringtype t,Stringtype &r)//求所有包含在串s 中而t中没有的字符构成的新串r{r[0]=0;for(i=1;i<=s[0];i++){c=s[i];for(j=1;j<i&&s[j]!=c;j++); //判断s的当前字符c是否第一次出现if(i==j){for(k=1;k<=t[0]&&t[k]!=c;k++); //判断当前字符是否包含在t中if(k>t[0]) r[++r[0]]=c;}}//for}//Subtract_String4.20int SubString_Delete(Stringtype &s,Stringtype t)//从串s中删除所有与t相同的子串,并返回删除次数{for(n=0,i=1;i<=s[0]-t[0]+1;i++){for(j=1;j<=t[0]&&s[i+j-1]==t[i];j++);if(j>m) //找到了与t匹配的子串{for(k=i;k<=s[0]-t[0];k++) s[k]=s[k+t[0]]; //左移删除s[0]-=t[0];n++;}}//forreturn n;}//Delete_SubString4.21typedef struct{char ch;LStrNode *next;} LStrNode,*LString; //链串结构void StringAssign(LString &s,LString t)//把串t赋值给串s{s=malloc(sizeof(LStrNode));for(q=s,p=t->next;p;p=p->next){r=(LStrNode*)malloc(sizeof(LStrNode));r->ch=p->ch;q->next=r;q=r;}q->next=NULL;}//StringAssignvoid StringCopy(LString &s,LString t)//把串t复制为串s.与前一个程序的区别在于,串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;}//StringCopychar StringCompare(LString s,LString t)//串的比较,s>t时返回正数,s=t时返回0,s<t 时返回负数{for(p=s->next,q=t->next;p&&q&&p->ch==q->ch;p=p->next,q=q->next);if(!p&&!q) return 0;else if(!p) return -(q->ch);else if(!q) return p->ch;else return p->ch-q->ch;}//StringCompareint StringLen(LString s)//求串s的长度(元素个数){for(i=0,p=s->next;p;p=p->next,i++);return i;}//StringLenLString * Concat(LString s,LString t)//连接串s和串t形成新串,并返回指针{p=malloc(sizeof(LStrNode));for(q=p,r=s->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串sfor(r=t->next;r;r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;}//for //复制串tq->next=NULL;return p;}//ConcatLString * Sub_String(LString s,int start,int len)//返回一个串,其值等于串s从start 位置起长为len的子串{p=malloc(sizeof(LStrNode));q=p;for(r=s;start;start--,r=r->next); //找到start所对应的结点指针rfor(i=1;i<=len;i++,r=r->next){q->next=(LStrNode*)malloc(sizeof(LStrNode));q=q->next;q->ch=r->ch;} //复制串tq->next=NULL;return p;}//Sub_String4.22void LString_Concat(LString &t,LString &s,char c)//用块链存储结构,把串s插入到串t的字符c之后{p=t.head;while(p&&!(i=Find_Char(p,c))) p=p->next; //查找字符cif(!p) //没找到{t.tail->next=s.head;t.tail=s.tail; //把s连接在t的后面}else{q=p->next;r=(Chunk*)malloc(sizeof(Chunk)); //将包含字符c的节点p分裂为两个for(j=0;j<i;j++) r->ch[j]='#'; //原结点p包含c及其以前的部分for(j=i;j<CHUNKSIZE;j++) //新结点r包含c以后的部分{r->ch[j]=p->ch[j];p->ch[j]='#'; //p的后半部分和r的前半部分的字符改为无效字符'#'}p->next=s.head;s.tail->next=r;r->next=q; //把串s插入到结点p和r之间}//elset.curlen+=s.curlen; //修改串长s.curlen=0;}//LString_Concatint Find_Char(Chunk *p,char c)//在某个块中查找字符c,如找到则返回位置是第几个字符,如没找到则返回0{for(i=0;i<CHUNKSIZE&&p->ch[i]!=c;i++);if(i==CHUNKSIZE) return 0;else return i+1;}//Find_Char4.23int LString_Palindrome(LString L)//判断以块链结构存储的串L是否为回文序列,是则返回1,否则返回0{InitStack(S);p=S.head;i=0;k=1; //i指示元素在块中的下标,k指示元素在整个序列中的序号(从1开始)for(k=1;k<=S.curlen;k++){if(k<=S.curlen/2) Push(S,p->ch[i]); //将前半段的字符入串else if(k>(S.curlen+1)/2){Pop(S,c); //将后半段的字符与栈中的元素相匹配if(p->ch[i]!=c) return 0; //失配}if(++i==CHUNKSIZE) //转到下一个元素,当为块中最后一个元素时,转到下一块{p=p->next;i=0;}}//forreturn 1; //成功匹配}//LString_Palindrome4.24void HString_Concat(HString s1,HString s2,HString &t)//将堆结构表示的串s1和s2连接为新串t{if(t.ch) free(t.ch);t.ch=malloc((s1.length+s2.length)*sizeof(char));for(i=1;i<=s1.length;i++) t.ch[i-1]=s1.ch[i-1];for(j=1;j<=s2.length;j++,i++) t.ch[i-1]=s2.ch[j-1];t.length=s1.length+s2.length;}//HString_Concat4.25int HString_Replace(HString &S,HString T,HString V)//堆结构串上的置换操作,返回置换次数{for(n=0,i=0;i<=S.length-T.length;i++){for(j=i,k=0;k<T.length&&S.ch[j]==T.ch[k];j++,k++);if(k==T.length) //找到了与T匹配的子串:分三种情况处理{if(T.length==V.length)for(l=1;l<=T.length;l++) //新子串长度与原子串相同时:直接替换S.ch[i+l-1]=V.ch[l-1];else if(T.length<V.length) //新子串长度大于原子串时:先将后部右移{for(l=S.length-1;l>=i+T.length;l--)S.ch[l+V.length-T.length]=S.ch[l];for(l=0;l<V.length;l++)S[i+l]=V[l];}else //新子串长度小于原子串时:先将后部左移{for(l=i+V.length;l<S.length+V.length-T.length;l++)S.ch[l]=S.ch[l-V.length+T.length];for(l=0;l<V.length;l++)S[i+l]=V[l];}S.length+=V.length-T.length;i+=V.length;n++;}//if}//forreturn n;}//HString_Replace4.26Status HString_Insert(HString &S,int pos,HString T)//把T插入堆结构表示的串S的第pos个字符之前{if(pos<1) return ERROR;if(pos>S.length) pos=S.length+1;//当插入位置大于串长时,看作添加在串尾S.ch=realloc(S.ch,(S.length+T.length)*sizeof(char));for(i=S.length-1;i>=pos-1;i--)S.ch[i+T.length]=S.ch[i]; //后移为插入字符串让出位置for(i=0;i<T.length;i++)S.ch[pos+i-1]=T.ch[pos]; //插入串TS.length+=T.length;return OK;}//HString_Insert4.27int Index_New(Stringtype s,Stringtype t)//改进的定位算法{i=1;j=1;while(i<=s[0]&&j<=t[0]){if((j!=1&&s[i]==t[j])||(j==1&&s[i]==t[j]&&s[i+t[0]-1]==t[t[0]])){ //当j==1即匹配模式串的第一个字符时,需同时匹配其最后一个i=i+j-2;j=1;}else{i++;j++;}}//whileif(j>t[0]) return i-t[0];}//Index_New4.28void LGet_next(LString &T)//链串上的get_next算法{p=T->succ;p->next=T;q=T;while(p->succ){if(q==T||p->data==q->data){p=p->succ;q=q->succ;p->next=q;}else q=q->next;}//while}//LGet_next4.29LStrNode * LIndex_KMP(LString S,LString T,LStrNode *pos)//链串上的KMP匹配算法,返回值为匹配的子串首指针{p=pos;q=T->succ;while(p&&q){if(q==T||p->chdata==q->chdata){p=p->succ;q=q->succ;}else q=q->next;}//whileif(!q){for(i=1;i<=Strlen(T);i++)p=p->next;return p;} //发现匹配后,要往回找子串的头return NULL;}//LIndex_KMP4.30void Get_LRepSub(Stringtype S)//求S的最长重复子串的位置和长度{for(maxlen=0,i=1;i<S[0];i++)//串S2向右移i格{for(k=0,j=1;j<=S[0]-i;j++)//j为串S2的当前指针,此时串S1的当前指针为i+j,两指针同步移动{if(S[j]==S[j+i]) k++; //用k记录连续相同的字符数else k=0; //失配时k归零if(k>maxlen) //发现了比以前发现的更长的重复子串{lrs1=j-k+1;lrs2=mrs1+i;maxlen=k; //作记录}}//for}//forif(maxlen){printf("Longest Repeating Substring length:%d\n",maxlen);printf("Position1:%d Position 2:%d\n",lrs1,lrs2);}else printf("No Repeating Substring found!\n");}//Get_LRepSub分析:i代表"错位值".本算法的思想是,依次把串S的一个副本S2向右错位平移1格,2格,3格,...与自身S1相匹配,如果存在最长重复子串,则必然能在此过程中被发现.用变量lrs1,lrs2,maxlen来记录已发现的最长重复子串第一次出现位置,第二次出现位置和长度.题目中未说明"重复子串"是否允许有重叠部分,本算法假定允许.如不允许,只需在第二个for语句的循环条件中加上k<=i即可.本算法时间复杂度为O(Strlen(S)^2).4.31void Get_LPubSub(Stringtype S,Stringtype T)//求串S和串T的最长公共子串位置和长度{if(S[0]>=T[0]){StrAssign(A,S);StrAssign(B,T);}else{StrAssign(A,T);StrAssign(B,S);} //为简化设计,令S和T中较长的那个为A,较短的那个为Bfor(maxlen=0,i=1-B[0];i<A[0];i++){if(i<0) //i为B相对于A的错位值,向左为负,左端对齐为0,向右为正{jmin=1;jmax=i+B[0];}//B有一部分在A左端的左边else if(i>A[0]-B[0]){jmin=i;jmax=A[0];}//B有一部分在A右端的右边else{jmin=i;jmax=i+B[0];}//B在A左右两端之间.//以上是根据A和B不同的相对位置确定A上需要匹配的区间(与B重合的区间)的端点:jmin,jmax.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;}}//for}//forif(maxlen){if(S[0]>=T[0]){lpsS=lps1;lpsT=lps2;}else{lpsS=lps2;lpsT=lps1;} //将A,B上的位置映射回S,T上的位置printf("Longest Public Substring length:%d\n",maxlen);printf("Position in S:%d Position in T:%d\n",lpsS,lpsT);}//ifelse printf("No Repeating Substring found!\n");}//Get_LPubSub分析:本题基本思路与上题同.唯一的区别是,由于A,B互不相同,因此B不仅要向右错位,而且还要向左错位,以保证不漏掉一些情况.当B相对于A的位置不同时,需要匹配的区间的计算公式也各不相同,请读者自己画图以帮助理解.本算法的时间复杂度是o（strlrn（s）*strlen （t））。

《数据结构(C语言版第2版)》(严蔚敏著)第四章练习题答案

《数据结构（C语言版第2版）》（严蔚敏著）第四章练习题答案第4章串、数组和广义表1．选择题（1）串是一种特殊的线性表，其特殊性体现在（）。

（3）串“ababaaababaa”的next数组为（）。

A．012345678999 B．012121111212 C．011234223456 D．0123012322345答案：C（4）串“ababaabab”的nextval为（）。

A．010104101B．010102101 C．010100011 D．010101011答案：A（5）串的长度是指（）。

（6）假设以行序为主序存储二维数组A=array[1..100,1..100]，设每个数据元素占2个存储单元，基地址为10，则LOC[5,5]=（）。

A．808 B．818 C．1010 D．1020答案：B解释：以行序为主，则LOC[5,5]=[（5-1）*100+（5-1）]*2+10=818。

A．BA+141 B．BA+180 C．BA+222 D．BA+225答案：B解释：以列序为主，则LOC[5,8]=[（8-1）*8+（5-1）]*3+BA=BA+180。

严蔚敏数据结构c语言版习题集答案第四章串

严蔚敏《数据结构(c语言版)习题集》答案第四章 串

严蔚敏版数据结构课后习题答案-完整版

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

串-第4章-《数据结构题集》答案解析-严蔚敏吴伟民版

数据结构C语言版第版习题答案—严蔚敏精修订

数据结构习题集答案(C语言版严蔚详细版敏)(1)

数据结构c语言版严蔚敏课后习题答案

严蔚敏数据结构课后习题及答案解析

《数据结构(C语言版 第2版)》(严蔚敏 著)第四章练习题答案

严蔚敏数据结构课后习题及答案解析

数据结构c语言版严蔚敏课后习题答案

数据结构习题答案 严蔚敏《数据结构(c语言版)习题集》答案

数据结构课后习题答案详解(C语言版_严蔚敏) 2

严蔚敏数据结构c语言版习题集全答案

数据结构(C语言版)习题及答案第四章

严蔚敏《数据结构(c语言版)习题集》答案第四章 串

《数据结构(C语言版 第2版)》(严蔚敏 著)第四章练习题答案

严蔚敏《数据结构(c语言版)习题集》答案第四章串

《数据结构(C语言版第2版)》(严蔚敏著)第四章练习题答案

数据结构习题答案严蔚敏《数据结构(c语言版)习题集》答案

严蔚敏《数据结构(c语言版)习题集》答案第四章串

《数据结构(C语言版第2版)》(严蔚敏著)第四章练习题答案