严慰敏C语言版复习提纲,每章的重点归纳ds复习纲要

合集下载

数据结构复习题集答案(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 y{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;p=p->next;}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{q=p;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 pleftright;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...。

数据结构(c语言版)严蔚敏

第一章概论1.数据：信息的载体,能被计算机识别、存储和加工处理。

2.数据元素：数据的基本单位，可由若干个数据项组成，数据项是具有独立含义的最小标识单位。

3.数据结构：数据之间的相互关系，即数据的组织形式。

它包括：1）数据的逻辑结构，从逻辑关系上描述数据，与数据存储无关，独立于计算机；2）数据的存储结构，是逻辑结构用计算机语言的实现，依赖于计算机语言。

3）数据的运算，定义在逻辑结构上，每种逻辑结构都有一个运算集合。

常用的运算：检索/插入/删除/更新/排序。

4.数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。

数据的存储结构是逻辑结构用计算机语言的实现。

5.数据类型：一个值的集合及在值上定义的一组操作的总称。

分为：原子类型和结构类型。

6.抽象数据类型：抽象数据的组织和与之相关的操作。

优点：将数据和操作封装在一起实现了信息隐藏。

7. 抽象数据类型ADT：是在概念层上描述问题；类：是在实现层上描述问题；在应用层上操作对象（类的实例）解决问题。

8.数据的逻辑结构，简称为数据结构，有：（1）线性结构，若结构是非空集则仅有一个开始和终端结点，并且所有结点最多只有一个直接前趋和后继。

（2）非线性结构，一个结点可能有多个直接前趋和后继。

9.数据的存储结构有：1）顺序存储，把逻辑相邻的结点存储在物理上相邻的存储单元内。

2）链接存储，结点间的逻辑关系由附加指针字段表示。

3）索引存储，存储结点信息的同时，建立附加索引表，有稠密索引和稀疏索引。

4）散列存储，按结点的关键字直接计算出存储地址。

10.评价算法的好坏是：算法是正确的；执行算法所耗的时间；执行算法的存储空间（辅助存储空间）；易于理解、编码、调试。

11.算法的时间复杂度T(n)：是该算法的时间耗费，是求解问题规模n的函数。

记为O(n)。

时间复杂度按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、……k次方阶O(n^k)、指数阶O(2^n)。

数据结构严蔚敏C语言版学习复习提纲

期末复习复习第一章绪论数据：计算机处理的信息总称数据项：最小单位数据元素：最基本单数据对象：元素集合数据结构：相互之间存在一种或多种特定关系的数据元素集合。

概念：数据元素之间的关系线性结构：一对逻辑结构非线性结构数据结构树：一对多图：多对多顺序存储结构链表存储结构存储结构。

索引。

基。

散列。

础知数据运算识算法描述：指令的有限有序序列有穷性确定性算法特性可行性算法输入输出时间复杂度算法分析空间复杂度、计算机算法必须具备输入、输出、可行性、确定性、有穷性５个特性。

1 2、算法分析的两个主要方面是空间复杂度和时间复杂度。

3、数据元素是数据的基本单位。

4、数据项是数据的最小单位。

5、数据结构是带结构的数据元素的集合。

6、数据的存储结构包括顺序、链接、散列和索引四种基本类型。

线性表复习第二章定义逻辑关系：前趋后继节省空间基本特点随机存取插、删效率低顺序存储结构插入基本运算删除一个数据一个指针多占空特查找费插、删效率无法查找前趋结单链运算特点：单链表+前趋指针域链表存储双向结构链表插入运算删除特点：单链表的尾结点指针循环指向附加头结点。

链表运算：联接1 、一个指向后继结点的指针、在双链表中，每个结点有两个指针域，包括一个指向前驱结点的指针 2、线性表采用顺序存储，必须占用一片连续的存储单元、线性表采用链式存储，便于进行插入和删除操作3 、线性表采用顺序存储和链式存储优缺点比较。

4 5、简单算法复习栈和队列第三章．栈的概念：在一端操作的线性表LIFO栈的特点：先进后出存储结初始化push 进栈运算算法pop出栈队列概念：在两端操作的线性表FIFO队列特点：先进先出假溢出顺序队列front=rear队空：循环队列front=(rear+1)%MAXSIZE队满：队列front∧队空：链队列rear初始化判空顺序：进队基本运算链队：出队取队首元素1栈和队列的异同点。

、、2栈和队列的基本运算出栈和出队、3 、4基本运算复习串第四章．n(≥)个字符组成的有限序列1定义：由”c……cS=”cc n231串长度、空白串、空串。

数据结构期末复习要点(严蔚敏版)

数据结构期末复习要点第一章绪论1、掌握基本概念和术语，看教材P4—P6部分内容；2、看P10—P11关于类C的语法描述，算法设计写代码时可用到；3、掌握算法的特征（5个）和要求（5个）（P13—P14），能够结合具体算法分析算法的时间复杂度和空间复杂度（比如线性表的插入、删除操作，查找、排序等操作），理解O(n)、O(1)等时间复杂度的具体含义（P14—P17）。

第二章线性表1、看教材P21—P26，掌握有关线性表顺序存储的内容：（1）顺序表的随机存取（P21计算地址的公式）；（2）顺序表的表示（P22的Typedef）；（3）顺序表为空、为满的判定，插入和删除操作的特征以及时间复杂度的分析（P23—P25）；（4）有关顺序表的编程题。

2、看教材P27—P30，掌握有关线性表链式存储的内容：（1）单链表的表示（P28的Typedef）；（2）单链表为空的判定（带头结点、不带头结点）；（3）单链表插入、删除操作的特征（操作点的确定以和指针的修改）以及时间复杂度分析（P29—P30）；（4）有关单链表的编程。

3、为节约时间，循环链表、双向链表以及多项式加法可以不看；4、算法设计题要求写代码，在本章体现的可能性比较大。

第三章栈和队列1、顺序栈的表示，栈操作的特点以及为空、为满的判定（P46—P47）；2、栈的应用举例看个标题就足够了；3、链队列的表示以及入队、出队操作（P61—P62）；4、循环队列为空、为满的判定（P65的代码中）；5、离散事件模拟这节不用看；6、第四章只需要看P70就够了，掌握串的特点（元素受限），串长度、空串、串的位置、串相等几个概念即可。

第六章树和二叉树1、看教材P120，了解有关树的概念和术语；2、了解二叉树的链式存储结构（P127），掌握二叉树的性质（P123—P125），并会做题（参考课件或指导书相关内容）；3、掌握二叉树的各种遍历算法（P128—P129或课件）：（1）能够根据二叉树写出各种遍历序列；（2）能够由两种遍历序列（必须包含中序序列）恢复二叉树；（3）理解二叉树遍历算法的递归代码，能够读懂代码含义。

数据结构 C语言版(严蔚敏版)第2章线性表1

• }
• 4. 求线性表L的长度
• int GetLength(SQ_LIST L)
• {
• • } • 5. 判断线性表L是否为空 • int IsEmpty(SQ_LIST L) return (L.length);
• {
• • • } if (L.length==0) return TRUE; else return FALSE;
• 2. 销毁线性表L
• void DestroyList(SQ_LIST *L) • { • if (L->item) free(L->item); 所有存储空间 //释放线性表占据的
• } • 3. 清空线性表L
• void ClearList(SQ_LIST *L) • { • L->length=0; //将线性表的长度置为0
学习提要
3. 熟练掌握线性表在顺序存储结构上实现基本操作：查找、插入和删除的算法。 4. 熟练掌握在各种链表结构中实现线性表操作的基本方法，能在实际应用中选用适当的链表结构。 5. 能够从时间和空间复杂度的角度综合比较线性表两种存储结构的不同特点及其适用场合。
2.1线性表及运算
线性表是n个元素的有限序列，它们之间的关系可以排成一个线性序列：
典型操作的算法实现
• • • • • • • • 1. 初始化线性表L int InitList(SQ_LIST *L) { L->item=(EntryType *)malloc(LIST_MAX_LENGTH *sizeof(EntryType)); //分配空间 if (L->item==NULL) return ERROR; //若分配空间不成功，返回ERROR L->length=0; //将当前线性表长度置0 return OK; //成功返回OK }

数据结构 (严蔚敏C语言版) 学习、复习提纲

期末复习第一章绪论复习1、计算机算法必须具备输入、输出、可行性、确定性、有穷性５个特性。

2、算法分析的两个主要方面是空间复杂度和时间复杂度。

3、数据元素是数据的基本单位。

4、数据项是数据的最小单位。

5、数据结构是带结构的数据元素的集合。

6、数据的存储结构包括顺序、链接、散列和索引四种基本类型。

数据结构算法数据：计算机处理的信息总称数据项：最小单位数据元素：最基本单位数据对象：元素集合数据结构：相互之间存在一种或多种特定关系的数据元素集合。

概念：数据元素之间的关系线性结构：一对一非线性结构树：一对多图：多对多顺序存储结构链表存储结构索引。

散列。

算法描述：指令的有限有序序列有穷性确定性可行性输入输出时间复杂度空间复杂度第二章线性表复习1、在双链表中，每个结点有两个指针域，包括一个指向前驱结点的指针、一个指向后继结点的指针2、线性表采用顺序存储，必须占用一片连续的存储单元3、线性表采用链式存储，便于进行插入和删除操作4、线性表采用顺序存储和链式存储优缺点比较。

5、简单算法第三章栈和队列复习定义逻辑关系：前趋后继节省空间随机存取插、删效率低插入删除1、栈和队列的异同点。

2、栈和队列的基本运算3、出栈和出队4、基本运算第四章串复习存储结构栈的概念：在一端操作的线性表运算算法栈的特点：先进后出 LIFO初始化进栈push 出栈pop顺序队列循环队列队列概念：在两端操作的线性表假溢出链队列队列特点：先进先出 FIFO基本运算顺序：链队：队空：front=rear队满：front=(rear+1)%MAXSIZE队空：rear 初始化判空进队出队取队首元素第五章数组和广义表复习定义：由n(≥1)个字符组成的有限序列 S=”c 1c 2c 3 ……cn ”串长度、空白串、空串。

紧缩格式非紧缩格式以字节为单位的存储格式（C 语言用数组或指针表示）基本运算strlen(s) 串长度 strcat(s1,s2) 联接 strcmp(s1,s2) 比较 strcpy(s1,s2) 复制 strstr(s1,s2) 子串查询模式匹配失败链接值匹配算法单字符链表串多字符链表串串变量的存储映像：串名、串值对应关系表顺序存储方式压缩存储方式行优先顺序存放列优先顺序存放C语言数组：行优先下标从[0]开始，公式变化稀疏矩阵应用表达式程序调用广义表定义：n(≥0)个元素的有限序列表头：Head(A)= a1概念：长度、深度、原子、子表表尾：Tail(A)=(a2,a3,…,a n)表结点特殊矩阵对称矩阵三角矩阵对角矩阵三元组存储：三元组m n t链表存储：十字链表原子结点第六章树复习1、三个结点可以组成2种不同形态的树。

严蔚敏数据结构复习整理完整版

对各种操作的时间复杂性的分析。

主要是链表，树，排序等简单一些的分析。

分析的时候，从简单的入手，学会方法。

后续的各种豆可能让你分析时间复杂度。

线性链表（顺序表和单链表）链表循环链表双向链表1.线性结构队列（循环队列）栈链表主要操作：找某一个元素，插入一个（在哪个位置增加），删除一个（在哪个位置删除）。

栈：查找，插入（位置固定），删除（位置固定）队列：查找，插入（位置固定），删除（位置固定）顺序表（可以视为一个数组）单链表：（删除）（插入）倒置：（查找）双向链表栈：（插入删除查找）队列（插入删除查找）循环队列的实现，并不是像上面的图那样，实现了一个循环的样子。

2.二叉树基本概念二叉树是每个节点最多有两个子树的有序树。

二叉树常被用于实现二叉查找树和二叉堆。

值得注意的是，二叉树不是树的特殊情形。

二叉树是每个结点最多有两个子树的有序树。

通常根的子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

二叉树常被用作二叉查找树和二叉堆或是二叉排序树。

二叉树的每个结点至多只有二棵子树(不存在出度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

二叉树不是树的一种特殊情形，尽管其与树有许多相似之处，但树和二叉树有两个主要差别：1. 树中结点的最大度数没有限制，而二叉树结点的最大度数为2；2. 树的结点无左、右之分，而二叉树的结点有左、右之分。

二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：(1)空二叉树——如图(a)；(2)只有一个根结点的二叉树——如图(b)；(3)只有左子树——如图(c)；(4)只有右子树——如图(d)；(5)完全二叉树——如图(e)注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形性质(1) 在非空二叉树中，第i层的结点总数不超过, i>=1；(2) 深度为h的二叉树最多有2^h-1个结点(h>=1)，最少有h个结点；(3) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；(4) 具有n个结点的完全二叉树的深度为(5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：若I为结点编号则如果I>1，则其父结点的编号为I/2；如果2*I<=N，则其左儿子（即左子树的根结点）的编号为2*I；若2*I>N，则无左儿子；如果2*I+1<=N，则其右儿子的结点编号为2*I+1；若2*I+1>N，则无右儿子。

C语言复习提纲(全)

C语言复习提纲:第一章 C语言程序设计概述一、Visual C++6.0开发环境1、了解Visual C++6.0的安装过程；2、了解Visual C++6.0的工作界面，菜单和工具栏的使用；▲二、掌握C语言程序运行的过程1、编辑：是指把按照C语法规则编写的程序代码通过编辑器（Visual C++ 6.0,Turbo C 3.0）输入计算机，并存盘。

在存盘时，C源文件的扩展名为 .c2、编译：将C语言源程序编译成目标程序，即对源程序进行编译，并将源程序转换为扩展名为.obj的二进制目标代码（即把已经编辑好的源程序翻译成二进制目标代码的过程）。

3、连接：将用户程序生成的目标代码文件（.obj）和系统提供的库文件（.lib）中的某些代码连接在一起，生成一个可执行文件（.exe）。

4、执行：执行生成的可执行代码，并输出结果。

5、调试：是将编制的程序投入实际运行前，用手工或编译程序等方法进行测试，修正语法错误和逻辑错误的过程。

▲三、结构化程序设计的基本概念1、概念以模块化设计为中心，将待开发的软件系统划分为若干个相互独立的模块，将原来较为复杂的问题化简为一系列简单模块的设计，任何模块都可以使用一些基本的结构来实现，任何复杂的程序，都可以使用这些基本结构按一定的顺序组合起来，这些基本结构的特点都是只有一个入口、一个出口，这样的程序设计方法称为结构化程序设计。

2、基本思想结构化程序设计的基本思想是采用"自顶向下，逐步细化、模块化设计、结构化编码"的程序设计方法和"单入口单出口"的控制结构。

3、三种基本结构⑴顺序结构⑵选择结构⑶循环结构4、三种基本结构的特点⑴只有一个入口⑵只有一个出口⑶每一个基本结构中的每一部分都有机会执行到⑷结构内不存在“死循环”5、设计原则⑴自顶向下⑶逐步细化⑶模块化设计⑷结构化编码▲四、C程序的基本组成：C程序是由若干个函数构成的，至少有一个主函数main()，main()的位置可以任意，其他各函数在程序中的前后位置也是可以任意的。

严蔚敏数据结构（C语言版）知识点总结笔记课后答案

严蔚敏数据结构（C语⾔版）知识点总结笔记课后答案第1章绪论1.1复习笔记⼀、数据结构的定义数据结构是⼀门研究⾮数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。

⼆、基本概念和术语数据数据（data）是对客观事物的符号表⽰，在计算机科学中是指所有能输⼊到计算机中并被计算机程序处理的符号的总称，它是计算机程序加⼯的“原料”。

2.数据元素数据元素（data element）是数据的基本单位，在计算机程序中通常作为⼀个整体进⾏考虑和处理。

3.数据对象数据对象（data object）是性质相同的数据元素的集合，是数据的⼀个⼦集。

4．数据结构数据结构（data structure）是相互之间存在⼀种或多种特定关系的数据元素的集合。

（1）数据结构的基本结构根据数据元素之间关系的不同特性，通常有下列四类基本结构：①集合。

数据元素之间除了“同属于⼀个集合”的关系外，别⽆其它关系。

②线性结构。

数据元素之间存在⼀个对⼀个的关系。

③树形结构。

数据元素之间存在⼀个对多个的关系。

④图状结构或⽹状结构。

数据元素之间存在多个对多个的关系。

如图1-1所⽰为上述四类基本结构的关系图。

图1-1 四类基本结构的关系图（2）数据结构的形式定义数据结构的形式定义为：数据结构是⼀个⼆元组Data_Structure==（D，S）其中：D表⽰数据元素的有限集，S表⽰D上关系的有限集。

（3）数据结构在计算机中的表⽰数据结构在计算机中的表⽰（⼜称映象）称为数据的物理结构，⼜称存储结构。

它包括数据元素的表⽰和关系的表⽰。

①元素的表⽰。

计算机数据元素⽤⼀个由若⼲位组合起来形成的⼀个位串表⽰。

②关系的表⽰。

计算机中数据元素之间的关系有两种不同的表⽰⽅法：顺序映象和⾮顺序映象。

并由这两种不同的表⽰⽅法得到两种不同的存储结构：顺序存储结构和链式存储结构。

a.顺序映象的特点是借助元素在存储器中的相对位置来表⽰数据元素之间的逻辑关系。

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

严蔚敏数据结构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试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。

解：ADTComplex{数据对象：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，否则返回0Max(C,&e)操作结果：用e返回复数C的两个元素中值较大的一个Min(C,&e)操作结果：用e返回复数C的两个元素中值较小的一个}ADTComplexADTRationalNumber{数据对象：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的两个元素中值较小的一个}ADTRationalNumber1.5试画出与下列程序段等价的框图。

严蔚敏《数据结构》(C语言版)教材精讲(绪论)【圣才出品】

ADT 的形式化定义是三元组：ADT＝（D，S，P），其中，D 是数据对象，S 是 D 上的关系集，P 是对 D 的基本操作集。
ADT 的一般定义形式是： ADT 抽象数据类型名 {
数据对象:<数据对象的定义> 数据关系:<数据关系的定义> 基本操作:<基本操作的定义> }ADT 抽象数据类型名
4 / 11
二、数据结构的形式定义数据结构的形式定义是一个二元组：Data_Structure＝（D，S），其中，D 是数据元素的有限集，S 是 D 上关系的有限集。数据元素之间的关系可以是元素之间代表某种含义的自然关系，也可以是为处理问题方便而人为定义的关系，返种自然或人为定义的“关系”称为数据元素之间的逡辑关系，相应的结构称为逡辑结构。
1.3 抽象数据类型的表示与实现
抽象数据类型（Abstract Data Type，简称 ADT）：是指一个数学模型以及定义在该模型上的一组操作。
ADT 的定义仅取决亍它的一组逡辑特性，不其在计算机内的表示和实现无关。因此，丌论 ADT 的内部结构如何变化，只要其数学特性丌变，都丌影响其外部使用。
圣才电子书十万种考研考证电子书、题库视频学习平台

其中数据对象和数据关系的定义用伪码描述。基本操作的定义格式是：基本操作名(参数表)
初始条件:<初始条件描述> 操作结果:<操作结果描述> 其中，初始条件描述的是操作执行之前数据结构和参数应满足的条件；若丌满足，则操作失败，迒回相应的出错信息；操作结果描述的是操作正常完成之后，数据结构的变化状况和应迒回的结果；若初始条件为穸，则省略之。
圣才电子书十万种考研考证电子书、题库视频学习平台

数据结构老师给的复习要点（严蔚敏版）

数据结构⽼师给的复习要点（严蔚敏版）第⼀章1. 怎样理解“算法+数据结构=程序”这个公式？举例说明。

算法是语句序列解决特定问题的固有程序⽚段。

数据结构是确定数据间的关系。

从具体问题抽象出⼀个合适的数学模型、然后设计⼀个解决此数学模型的算法，最后编写出程序。

寻求数学模型的是指就是数据结构要完成的⼯作。

参看书p1前两段的描述。

2. 数据结构的概念，它包含哪三⽅⾯的内容？数据结构：是⼀门研究⾮数值计算的程序设计问题中计算机的操作对象以及它们之间饿关系和操作的学科。

参看书p3包含三⽅⾯的内容:1、数据之间的逻辑关系2、数据在计算机中的存储⽅式3、在数据上定义的运算的集合。

3. 数据、数据元素、数据项的基本概念。

举例说明数据元素和数据项的联系与区别。

数据：描述客观事物的数字、字符以及所有能直接输⼊到计算机中并被计算机程序处理的符号的集合。

数据元素：数据的基本单位，在计算机程序中通常作为⼀个整体进⾏考虑或处理。

数据项：数据项是具有独⽴含义的最⼩标识单位，是数据元的⼀个具体值，是数据记录中最基本的、不可分的有名数据单位。

例1：class A{int c[123];int i;};class B{A a;}B b;b.a是数据项，B是数据元素例2：⼀本书的数⽬信息为⼀个数据元素，⽽数⽬信息中每⼀项（如书名、作者名等）为⼀个数据项4. 从逻辑结构来看，数据结构有哪四种基本结构，各⾃的特点是什么？1、集合（数据元素之间同属于⼀个集合，再⽆其他关系）2、线性结构（数据元素之间存在⼀对⼀的关系）3、树形结构（数据元素之间⼀对多的关系）4、图状结构或⽹状结构（数据元素之间多对多的关系）5. 从物理结构来看，数据结构有哪两种基本结构，各⾃的特点是什么？1、顺序存储结构特点：借助元素在存储器中的相应位置来表⽰数据元素之间的逻辑关系。

2、链式存储结构特定：借助元素在存储地址的指针表⽰数据元素之间的逻辑关系。

6. 算法的5个特征，4个评价标准是什么？特征:有穷性、确定性、可⾏性、输⼊、输出。

《数据结构C语言版》严蔚敏第二章逻辑代数基础

ABC
BC A 00 01 11 10
00 0 1 0 10 0 1 1
ABC ABC BC
ABC
（2-45）
BC A 00 01 11 10
00 0 1 0
10 0 1 1 ?
AB
（2-46）
化简过程：
BC BC A 00 01 11 10 00 0 1 0 10 0 1 1
F=AB+BC
数字电路
第二章逻辑代数基础
（2-1）
§ 1.2 逻辑代数及运算规则
1.2.1 逻辑代数与基本逻辑关系
在数字电路中，我们要研究的是电路的输入输出之间的逻辑关系，所以数字电路又称逻辑电路，相应的研究工具是逻辑代数（布尔代数）。
在逻辑代数中，逻辑函数的变量只能取两个值（二值变量），即0和1，中间值没有意义，这里的0和1只表示两个对立的逻辑状态，如电位的低高（0表示低电位， 1表示高电位）、开关的开合等。
（2-19）
5. 反演定理（特例）：
A•B A B A B A•B
可以用列真值表的方法证明：
A
B AB A• B A
B AB
00
01
1
1
1
01
01
1
0
1
10
01
0
1
1
11
10
0
0
0
（2-20）
6. 对偶定理：对任何一个逻辑式Y，
• ， •，0 1，1 0，原变量 Y反变量YD 若两反逻变辑量式相等原，变则它量们的对偶式也相等。
逻辑符号
R
EA
F
（2-7）
逻辑式
FA
AF 01 10

严蔚敏数据结构c语言版

严蔚敏数据结构c语言版1.介绍数据结构是计算机科学中的一门重要学科，也是程序员必备的基础知识。

严蔚敏的《数据结构(C语言版)》是一本经典的教材，对于初学者来说是一本不可或缺的参考书。

本文将重点介绍书中所涉及的内容以及其对于学习数据结构的帮助。

2.数据结构的基础本书从数据结构的基础开始讲解，包括什么是数据结构、什么是算法、什么是抽象数据类型等等。

这一部分的讲解对于没有接触过数据结构的初学者来说非常容易理解，让人可以迅速了解数据结构的基本概念，为后面的学习打下良好的基础。

3.线性表线性表是数据结构中最基础的一种，本书也从线性表开始讲解。

线性表分为顺序表和链表两种，本书分别从这两种结构入手，详细地讲解它们的定义、特点、创建、遍历等方面的内容。

此外，本书还讲解了线性表的应用，例如栈、队列等数据结构。

4.树树是一种重要的“非线性”数据结构，在本书中也有专门的章节进行讲解。

树的分支和节点构成了一种层级结构，是构建许多算法的基础。

本书讲解了两种经典的树结构——二叉树和堆，从定义、分类、创建、查找、删除等方方面面进行详细的讲解。

此外，本书还讲解了树的遍历算法、赫夫曼编码等重要知识点。

5.图图是另一种非常重要的数据结构，它是描述复杂关系网络的有效方式。

本书也有独立章节进行讲解，详细讲解了图的定义、分类、创建、遍历等方面的内容。

此外，本书还讲解了最短路径算法、拓扑排序算法、最小生成树算法等重要知识点。

6.算法设计与分析本书最后一章讲解了算法设计与分析，是对前面所讲解内容的总结和拓展。

本章涵盖了算法的基础、算法分析、递归算法、分治算法、动态规划算法等知识点。

这些知识点是复杂算法设计的基础，对于程序员的职业发展有着重要的帮助。

7.总结严蔚敏教授的《数据结构(C语言版)》是一本非常经典、权威的教材。

本书完整地讲解了数据结构的基础和常用的算法，配以清晰的图示和实例程序，使读者可以迅速掌握知识点。

对于学习数据结构的初学者和希望拓展算法设计能力的程序员来说，这是一本非常好的参考书。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

第一章绪论一、内容提要1 数据结构研究的内容。

2 基本概念：数据、数据元素、数据对象、数据结构、数据类型、抽象数据类型、多形数据类型。

3 算法的定义及五个特征。

4 算法描述：类PASCAL语言。

5 算法设计要求。

6 算法分析。

二、学习重点1 数据结构的“三要素”：逻辑结构、物理（存储）结构及在这种结构上所定义的操作（运算）。

2 抽象数据类型的定义、表示和实现方法。

3 类PASCAL书写规范，过程（函数）中值参和变参的差别，过程调用规则。

4 用计算语句频度来估算算法的时间复杂度。

三、例题解析1 写出以下各语句执行次数（左边括号内数字为语句序号）(1) FOR i:=1 TO n DO(2) FOR j:=1 to n DO(3) [ c[I,j] := 0;(4) FOR k:=1 TO n DO(5)(5)c[I,j]:=c[I,j]+a[I,k]*b[k,j]][答案]：各语句执行次数（频度）分别为n+1，n(n+1), n2 , n2(n+1), n3[分析]：最容易发生的错误，是将第一个语句的执行次数答成n。

2 编写最优算法，从小到大依次输出顺序读入的三个整数PROC asscending;{本算法对读入的三个整数进行排序，然后按从小到大输出}{算法中核心语句如下}read(a,b,c);IF a>bTHEN [t:=a; a:=b; b:=t]; {a,b按正序排序} IF b>cTHEN [t:=c; c:=b; {c为最大}IF a<t THEN b:=t {b为中间值}ELSE [b:=a; a:=t] {a,b正序}WRITELN(a:4,b:4,c:4);ENDP; {assending}[分析]：本题正确算法有多种，但上面是最优算法：最好情况下只经过两次比较且无数据移动，而在最坏情况下，也只是经过三次比较，七个赋值语句就完成了排序。

在本课程教学中，强调“好”的算法, 不仅仅是结果正确, 而且是最优的算法。

这与PASCAL语言教学中的要求有很大不同。

算法是供人来阅读的，必须牢记这一点。

算法中语句的书写格式采用缩进规则，保留字用大写，其余标识符小写，提高了算法的易读性。

第二章第二章线性表一、内容提要1．线性表是元素间约束力最强的一类数据结构。

2．线性表的逻辑结构定义，对线性表定义的操作。

3．线性表的存储结构：顺序存储结构和链式存储结构。

4．线性表的操作在两种存储结构中的实现。

5．一元多项式的线性表表示方法，及高次（稀疏）多项式的抽象数据类型定义、表示和加法的实现。

二、学习重点1．1．线性表的逻辑结构，指线性表的数据元素间存在着线性关系。

在顺序存储结构中，元素存储的先后位置反映出这种线性关系，而在链式存储结构中，是靠指针来反映这种关系的。

2．2．顺序存储结构用向量（一维数组）表示，给定下标，可以存取相应元素，属于随机存取的存储结构。

3．3．尽管“只要知道某结点的指针就可以存取该元素”，但因链表的存取都需要从头指针开始，顺链而行，故链表不属于随机存取结构。

4．4．链表是本章学习的重点和难点。

要理解头结点，首元结点和元素结点的差别。

理解头结点是为了在插入、删除等操作时，为了算法的统一而设立的（若无头结点，则在第一元素前插入元素或删除第一元素时，链表的头指针总在变化）。

掌握通过画出结点图来进行链表的生成、插入、删除、遍历等操作。

5．5．链表操作中应注意不要使链意外“断开”。

因此，若在某结点前插入一个元素，或删除某元素，必须知道该元素的前驱结点的指针。

6．6．从时间和空间复杂度的角度综合比较线性表在顺序和链式两种存储结构下的特点。

7．7．静态链表是又一重点和难点。

应和链表进行比较、理解。

例如，在有头结点的链表情况下，第一元素是p:=la^.next，而在静态链表中则i:=sa[0].next；相对p:=p^.next,有i:=sa[i].next来找到第i个元素的后继。

三、例题解析１．设线性表以顺序存储结构存于a(1..n)中，试编写算法将该线性表就地逆置。

【分析】向量逆置有几种方法，如逆向读入到另一数组中，在正向对应赋值，即：FOR i:=n DOWNTO 1 DO b[n-i+1]:=a[i]; FOR i:=1TO n DO a[i]:=b[i];这里要求“就地逆置”，即不能另用一数组空间。

【算法】PROC invert(V AR a:arr; n:integer);{a是存储线性表的一维数组，有n 个元素，本算法将a逆置。

}FOR i:=1TO (n DIV 2) DO a[i]↔a[n-i+1];endp;【讨论】将n个元素的一维数组逆置，为什么循环控制变量用n div 2，而不用n？２．编写在单链表上进行排序的算法【分析】这里使用插入排序。

链表中插入元素要知道待插入元素位置的前驱，以pre表示之。

结束的条件是链表为空。

【算法】PROC insertsort(V AR la:linklist);{la是带头结点的单链表的指针，本算法将链表中元素正序排序。

算法的基本思想是先假定第一个元素有序，然后从第二个元素开始，依次插入到有序的表中，直到全部元素插入完为止}p:= la^.next^.next;{假定链表非空，即至少有一个结点}la^.next^.next:=nil;{设有序链表中当前只有一个结点}found:=false;WHILE (p<>nil)AND NOT found DO[s:=p^.next;{记住下一个结点}pre:=la;q:=la^.next;found:=false;WHILE(q<>nil)AND NOT found DOIF q^.data<p^.data THEN [pre:=q;q:=q^.next]ELSE found:=true;p^.next:=q;pre^.next:=p;{p结点插入}p:=s;{取下一个结点}]ENDP; {insertsort}【讨论】算法中found为一布尔变量，为的是在链表到尾前，如找到p的插入位置，即可退出WHILE循环。

这里循环条件未写成：（p<>nil）AND (q^.data<p^.data)因为若q=nil ，则再引用q^.data是无意义的。

请记住这种退出循环，引入布尔变量的作法。

3．设两个非递减有序的线性表各有m和n个元素（m>0,n>0）,分别存于一维数组a和b中，且a 的存储空间足够大。

试编写算法将两线性表合并成一线性表，结果仍是非递减有序，要求算法的时间复杂度是o(m+n)。

【分析】两个有序线性表合并成一个有序表，教材中已有讨论，算法非常简单。

本算法要求复杂度为O(m+n)，这是着重点。

题目叙述中有“a的空间足够大”，暗示出若将m+n个元素合并到a中，不会溢出。

为使数据移动次数最少，应先将两表中最大元素置于m+n的位置上，然后相应指针减1，再比较之，直到两表中有一个指针减到0，则结束，否则，将b中剩余元素传到a中相应位置即可。

【算法】PROC union(V AR a:seqlisttp;b:seqlisttp);{a,b是两个非递减有序表，顺序存储结构存储，各有m和n个元素，本算法将两表合并到a中，仍为有序表，算法时间复杂度为O(m+n)}i:=m; j:=n ;k:=m+n; {i,j,k分别为表a,b和结果表的指针}WHILE (i>0) AND (j>0) DOIF a[i]>b[j] THEN [a[k]:=a[i]; i:=i-1; k:=k-1]ELSE [a[k]:=b[j]; j:=j-1; k:=k-1];WHILE (j>0) DO [a[k]:=b[j]; j:=j-1; k:=k-1];{若b表中尚有元素，则传至a中相应位置}【讨论】本算法至多比较m+n次，往a中赋值m+n次。

最好情况是比较n次，往a 中赋值n次，该种情况是b中最小元素不小于a中最大元素。

问题：为什么在退出第一个WHILE循环后，不讨论（即没有）WHILE i>0的情况？第三章栈和队列一、一、内容提要1．1．从数据结构角度讲，栈和队列也是线性表，其操作是线性表操作的子集，属操作受限的线性表。

但从数据类型的角度看，它们是和线性表大不相同的重要抽象数据类型。

2．2．栈的定义及操作。

栈是只准在一端进行插入和删除操作的线性表，该端称为栈的顶端。

3．3．栈的顺序和链式存储结构，及在这两种结构下实现栈的操作。

4．4．栈的应用：表达式求值，递归过程及消除递归。

5．5．队列的定义及操作，队列的删除在一端（尾），而插入则在队列的另一端（头）。

因此在两种存储结构中，都需要队头和队尾两个指针。

6．6．链队列空的条件是首尾指针相等，而循环队列满的条件的判定，则有队尾加1等于队头和设标记两种方法。

二、二、学习重点1．栈和队列操作在两种存储结构下的实现。

2．中缀表达式转成前缀、后缀表达式并求值。

3．用递归解决的问题：定义是递归的，数据结构是递归的，及问题的解法是递归的，掌握典型问题的算法。

4．4．链队列删除时为空的处理（令队尾指针指向队头）。

特别是仅设尾指针的循环链队列的各种操作的实现。

5．5．循环队列队空定义为队头指针等于队尾指针，队满则可用一个单元（教材中所示）及设标记办法（下面例题）。

这里特别注意取模运算。

6．6．在后续章节中要注意栈和队列的应用，如串中心对称的判定，二叉树遍历的递归和非递归算法，图的深度优先遍历等都用到栈，而树的层次遍历、图的宽度优先遍历等则用到队列。

三、三、例题解析1．1．两栈共享一向量空间，编写入栈和出栈算法。

TYPETwoWayStack=RECORD {双栈共享一向量空间}elem:ARRAY[1..m] OF elemtype;top:ARRAY[0..1] OF 0..m+1; {两个栈顶指针}END;PROC inistack(VAR tws:TwoWayStack); {初始化}{初始化双向栈tws为空}tws.top[0]:=0; { 左端栈指针}tws.top[1]:=m+1; { 右端栈指针}ENDP; {inistack}PROC PUSH(VAR tws:TwoWayStack;i:0..1; x:elemtype;VAR ofw:boolean);{若双向栈tws不满,则将x插入到i端,成功时ofw为true,失败为false}IF(tws.top[1]-tws.top[0])<>1THEN {栈未满}CASE i OF0:tws.top[0]:=tws.top[0]+1;tws.elem[tws.top[0]]:=x;ofw:=true1:tws.top[1]:=tws.top[1]-1;tws.elem[tws.top[1]]:=x;ofw:=trueENDCELSE ofw:=false;( 栈满)ENDP; {push}PROC POP(VAR tws:TwoWayStack;i:0..1;VAR x:elemtype;VAR underflow:boolean); {若双向栈tws非空,则将i端退栈,栈空时underflow为true}CASE i OF0:IF tws.top[0]=0 {栈空}THEN[underflow:=true;return(underflow)]ELSE[ tws.top[0]:=tws.top[0]-1;x:=tws.elem[tws.top[0]+1]; {弹出元素}];1:IF tws.top[1]=m+1 {栈空}THEN[underflow:=true;return(underflow)]ELSE[ tws.top[1]:=tws.top[1]+1;x:=tws.elem[tws.top[1]-1]; {弹出元素}];ENDCENDP; {pop }【讨论】上面算法中用0和1代表两端，且按操作在哪端来分两种情况进行讨论，逻辑清楚。