数据结构课后习题答案1--7
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)
第1章4．答案：（1）顺序存储结构顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。
（2）链式存储结构顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。
但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。
所以链式存储结构通常借助于程序设计语言的指针类型来描述。
5. 选择题(1)~(6)：CCBDDA6．（1）O(1) （2）O(m*n) （3）O(n2)（4）O(log3n) （5）O(n2) （6）O(n)第2章1．选择题（1）~（5）：BABAD （6）~（10）：BCABD （11）~（15）：CDDAC 2．算法设计题（1）将两个递增的有序链表合并为一个递增的有序链表。
要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。
表中不允许有重复的数据。
[题目分析]合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。
如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。
当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){//合并链表La和Lb，合并后的新表使用头指针Lc指向pa=La->next; pb=Lb->next;//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点Lc=pc=La; //用La的头结点作为Lc的头结点while(pa && pb){ if(pa->data<pb->data){pc->next=pa; pc=pa; pa=pa->next;}//取较小者La中的元素，将pa链接在pc的后面，pa指针后移else if(pa->data>pb->data) {pc->next=pb; pc=pb; pb=pb->next;}//取较小者Lb中的元素，将pb链接在pc的后面，pb指针后移else //相等时取La中的元素，删除Lb中的元素{pc->next=pa;pc=pa;pa=pa->next;q=pb->next; delete pb ; pb =q;}}pc->next=pa?pa:pb; //插入剩余段delete Lb; //释放Lb的头结点}（5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A中的元素为非零整数，要求B、C表利用A表的结点）。
严蔚敏 数据结构课后习题及答案解析
第一章绪论一、选择题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.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________。
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)【第一章绪论】1. 数据结构是计算机科学中的重要基础知识，它研究的是如何组织和存储数据，以及如何通过高效的算法进行数据的操作和处理。
本章主要介绍了数据结构的基本概念和发展历程。
【第二章线性表】1. 线性表是由一组数据元素组成的数据结构，它的特点是元素之间存在着一对一的线性关系。
本章主要介绍了线性表的顺序存储结构和链式存储结构，以及它们的操作和应用。
【第三章栈与队列】1. 栈是一种特殊的线性表，它的特点是只能在表的一端进行插入和删除操作。
本章主要介绍了栈的顺序存储结构和链式存储结构，以及栈的应用场景。
2. 队列也是一种特殊的线性表，它的特点是只能在表的一端进行插入操作，而在另一端进行删除操作。
本章主要介绍了队列的顺序存储结构和链式存储结构，以及队列的应用场景。
【第四章串】1. 串是由零个或多个字符组成的有限序列，它是一种线性表的特例。
本章主要介绍了串的存储结构和基本操作，以及串的模式匹配算法。
【第五章数组与广义表】1. 数组是一种线性表的顺序存储结构，它的特点是所有元素都具有相同数据类型。
本章主要介绍了一维数组和多维数组的存储结构和基本操作，以及广义表的概念和表示方法。
【第六章树与二叉树】1. 树是一种非线性的数据结构，它的特点是一个节点可以有多个子节点。
本章主要介绍了树的基本概念和属性，以及树的存储结构和遍历算法。
2. 二叉树是一种特殊的树，它的每个节点最多只有两个子节点。
本章主要介绍了二叉树的存储结构和遍历算法，以及一些特殊的二叉树。
【第七章图】1. 图是一种非线性的数据结构，它由顶点集合和边集合组成。
本章主要介绍了图的基本概念和属性，以及图的存储结构和遍历算法。
【总结】1. 数据结构是计算机科学中非常重要的一门基础课程，它关注的是如何高效地组织和存储数据，以及如何通过算法进行数据的操作和处理。
本文对《数据结构》第二版严蔚敏的课后习题作业提供了参考答案，涵盖了第1-7章的内容。
数据结构课后习题答案第七章
第七章图（参考答案）7．1（1）邻接矩阵中非零元素的个数的一半为无向图的边数；（2）A[i][j]= =0为顶点，I 和j无边，否则j和j有边相通；（3）任一顶点I的度是第I行非0元素的个数。
7．2（1）任一顶点间均有通路，故是强连通；（2）简单路径V4 V3 V1 V2;（3）0 1 ∞ 1∞ 0 1 ∞1 ∞ 0 ∞∞∞ 1 0邻接矩阵邻接表（2）从顶点4开始的DFS序列：V5,V3,V4,V6,V2,V1（3）从顶点4开始的BFS序列：V4,V5,V3,V6,V1,V27．4（1）①adjlisttp g; vtxptr i,j; //全程变量② void dfs(vtxptr x)//从顶点x开始深度优先遍历图g。
在遍历中若发现顶点j，则说明顶点i和j间有路径。
{ visited[x]=1; //置访问标记if (y= =j){ found=1;exit(0);}//有通路，退出else { p=g[x].firstarc;//找x的第一邻接点while (p!=null){ k=p->adjvex;if （!visited[k]）dfs(k);p=p->nextarc;//下一邻接点}}③ void connect_DFS (adjlisttp g)//基于图的深度优先遍历策略，本算法判断一邻接表为存储结构的图g种，是否存在顶点i //到顶点j的路径。
设 1<=i ,j<=n,i<>j.{ visited[1..n]=0;found=0;scanf (&i,&j);dfs (i);if (found) printf （” 顶点”,i,”和顶点”,j,”有路径”）；else printf （” 顶点”,i,”和顶点”,j,”无路径”）；}// void connect_DFS(2)宽度优先遍历全程变量，调用函数与（1）相同，下面仅写宽度优先遍历部分。
《数据结构》课后参考答案
单元练习1一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）（√）（1）数据的逻辑结构与数据元素本身的内容和形式无关。
（√）（2）一个数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。
（ㄨ）（3）数据元素是数据的最小单位。
（ㄨ）（4）数据的逻辑结构和数据的存储结构是相同的。
（ㄨ）（5）程序和算法原则上没有区别，所以在讨论数据结构时可以通用。
（√）（6）从逻辑关系上讲，数据结构主要分为线性结构和非线性结构两类。
（√）（7）数据的存储结构是数据的逻辑结构的存储映像。
（√）（8）数据的物理结构是指数据在计算机内实际的存储形式。
（ㄨ）（9）数据的逻辑结构是依赖于计算机的。
（√）（10）算法是对解题方法和步骤的描述。
二．填空题（1）数据有逻辑结构和存储结构两种结构。
（2）数据逻辑结构除了集合以外，还包括：线性结构、树形结构和图形结构。
（3）数据结构按逻辑结构可分为两大类，它们是线性结构和非线性结构。
（4）树形结构和图形结构合称为非线性结构。
（5）在树形结构中，除了树根结点以外，其余每个结点只有 1 个前趋结点。
（6）在图形结构中，每个结点的前趋结点数和后续结点数可以任意多个。
（7）数据的存储结构又叫物理结构。
（8）数据的存储结构形式包括：顺序存储、链式存储、索引存储和散列存储。
（9）线性结构中的元素之间存在一对一的关系。
（10）树形结构结构中的元素之间存在一对多的关系，（11）图形结构的元素之间存在多对多的关系。
（12）数据结构主要研究数据的逻辑结构、存储结构和算法（或运算）三个方面的内容。
（13）数据结构被定义为(D，R)，其中D是数据的有限集合，R是D上的关系的有限集合。
（14）算法是一个有穷指令的集合。
（15）算法效率的度量可以分为事先估算法和事后统计法。
（16）一个算法的时间复杂性是算法输入规模的函数。
（17）算法的空间复杂度是指该算法所耗费的存储空间，它是该算法求解问题规模n 的函数。
数据结构课后习题答案1--7
数据结构课后习题答案1--7题目1：请你设计一个栈数据结构，使其具备以下功能：可以在O(1)的时间复杂度内获取栈的最小元素。
解答1：要实现在O(1)的时间复杂度内获取栈的最小元素，可以使用两个栈来实现。
一个栈用来保存原始数据，另一个栈用来保存当前栈的最小元素。
具体实现如下：1. 初始化两个栈：stack和min_stack，其中stack用于保存所有元素，min_stack用于保存当前栈中的最小元素。
2. 插入元素时，先将元素插入stack中，然后判断插入的元素是否比min_stack的栈顶元素小，如果是，则将元素也插入到min_stack中；如果不是，则将min_stack的栈顶元素再次插入到min_stack中。
3. 删除元素时，分别从stack和min_stack中弹出栈顶元素。
这样，min_stack的栈顶元素始终是stack中的最小元素。
题目2：请你设计一个队列数据结构，使其具备以下功能：可以在O(1)的时间复杂度内获取队列的最大元素。
解答2：要实现在O(1)的时间复杂度内获取队列的最大元素，可以使用两个队列来实现。
一个队列用来保存原始数据，另一个队列用来保存当前队列的最大元素。
具体实现如下：1. 初始化两个队列：queue和max_queue，其中queue用于保存所有元素，max_queue用于保存当前队列中的最大元素。
2. 插入元素时，先将元素插入queue中，然后判断插入的元素是否比max_queue的队尾元素大，如果是，则将元素也插入到max_queue的队尾；如果不是，则将max_queue中所有比插入元素小的元素都弹出，再将插入元素插入到max_queue的队尾。
3. 删除元素时，分别从queue和max_queue中弹出队头元素。
这样，max_queue的队头元素始终是queue中的最大元素。
题目3：请你设计一个栈数据结构，使其除了具有常规的入栈和出栈功能外，还具备以下功能：能够在O(1)的时间复杂度内获取栈中的最大元素。
(完整版)C++与数据结构基础简明教程课后习题答案
C++与数据结构基础简明教程课后习题答案1-7-1//输出一个数的10 倍#include <iostream>using namespace std;int main(){}1-7-2cout<<"Please input an interger:\n"; int a;cin>>a;cout<<"result="<<a*10<<endl; return 0;//输出两个数中的较小的#include <iostream> using namespace std; int main(){}1-7-3double x,y,min;cout<<"please input two numbers"<<endl; cin>>x>>y;min=(x>y?y:x);cout<<"the smaller is"<<' '<<min<<endl; return 0;//输入半径计算周长和面积#include <iostream>using namespace std;int main(){cout<<"请输入半径\n";double rad;cin>>rad;double c,s;c=2*3.14*rad;s=3.14*rad*rad;cout<<"周长是"<<c<<endl;cout<<"面积是"<<s<<endl;return 0;}1-7-4//将10000 秒化成小时分钟秒#include <iostream>using namespace std;int main(){int hour,min,second;hour=10000/3600;min=(10000%3600)/60;second=10000-hour*3600-60*min;cout<<hour<<"hours"<<min<<"minutes"<<second<<"seconds"<<endl;return 0;}1-7-5//将一个三位数倒叙输出#include <iostream>using namespace std;int main(){int num,num_bai,num_shi,num_ge;cout<<"请输入一个三位数";cin>>num;num_bai=num/100;num_shi=(num-num_bai*100)/10;num_ge=num-num_bai*100-num_shi*10; cout<<num_ge<<endl;cout<<num_shi<<endl;cout<<num_bai<<endl;return 0;}2-3//简单的输入输出#include <iostream>using namespace std;int main(){double y,n;cout<<"please input a number\n";cin>>n;if (n>0) y=n+1;if (n<0) y=n*n;} 2-4if (n==0) y=0;cout<<"the result is:"<<' '<<y; return 0;//输出学生学号和对应的成绩等级#include <iostream>using namespace std;int main(){double fenshu;int xuehao;char dengji;int i;for (i=1;i<=10;i++){onerror:cout<<"please input student score\n";cin>>fenshu;if (fenshu>=90&&fenshu<=100) dengji='A';if (fenshu>=80&&fenshu<90) dengji='B';if (fenshu>=600&&fenshu<80) dengji='C';if (fenshu>=0&&fenshu<60) dengji='D';if (fenshu<0){cout<<"error";goto onerror;}if (fenshu>100){cout<<"error";goto onerror;}cout<<"the id is"<<i<<endl;cout<<"the score is"<<dengji<<endl;}return 0;}2-5//判断输入字符类别#include <iostream>using namespace std;int main(){char zifu;int ascii;cout<<"please input a characteristic\n";cin>>zifu;ascii=zifu;if (ascii>=48&&ascii<=57){cout<<"数字\n";goto end;}if (ascii>=97&&ascii<=122){cout<<"小写字母\n";goto end;}if (ascii>=65&&ascii<=90){cout<<"大写字母\n";goto end;}cout<<"其他字符";cout<<endl;end:return 0;}2-6//求圆周率的近似值#include <iostream>#include <iomanip>using namespace std;int main(){int xishu=-1;double danshu=1.0;int i=1;double sifenzhipi=0;do{xishu=xishu*(-1);danshu=1.0/(2*i-1);sifenzhipi=sifenzhipi+xishu*danshu;i++;}while(danshu>=0.000001);cout<<setprecision(15)<<sifenzhipi*4<<endl; return 0;}2-7//输出斐波那契数列前40 个数，以8*5 的格式输出#include <iostream>#include <iomanip>using namespace std;int main(){int b=2;int feibo1=0;int feibo2=1;cout<<setw(9)<<'0'<<setw(9)<<'1';for(int i=1;i<=38;i++){int a=feibo2;feibo2=feibo1+feibo2;feibo1=a;cout<<setw(9)<<feibo2;b=b+1;if(b%8==0) cout<<endl;}return 0;}2-8//统计输入的元音字母个数#include <iostream>using namespace std;int main(){char zimu;int a,e,i,o,u;a=e=u=i=o=0;begin:cin>>zimu;switch(zimu){case 'a' :a++;break;case 'e' :e++;break;case 'i' :i++;break;case 'o' :o++;break;case 'u' :u++;break;case '#' :goto end;}goto begin;end:cout<<a<<endl<<e<<endl<<i<<endl<<o<<endl<<u<<endl<<a+e+i+o+u;return 0;}2-10// 计算5!+6!+7!#include <iostream>using namespace std; int main(){}2-11int i,j;int sum=0;for (i=5;i<=7;i++){int jiecheng=1;for (j=1;j<=i;j++) jiecheng=jiecheng*j; sum=sum+jiecheng;}cout<<sum;return 0;//从2 开始100 个素数#include <iostream>using namespace std;int main(){int num=1;int sushu=0;start:;num++;for (int i=2;i<=num;i++){if(num%i==0) break;}if (i==num){cout<<num<<endl;sushu+=1;}}2-12if(sushu!=100) goto start; return 0;//百钱买百鸡问题#include <iostream>using namespace std;int main(){int x,y,z;for(x=0;x<=100;x++){for(y=0;y<=100;y++){for(z=0;z<=100;z++)if (x+y+z==100&&5*x+3*y+z/3==100&&z%3==0) cout<< x<<'\t'<<y<<'\t'<<z<<endl;}}return 0;}2-13#include <iostream>using namespace std;int main(){int a,b,c,d,e;c=0;cin>>a;cout<<"输入"<<a<<endl<<"该数的三次方是"<<a<<"个连续奇数";b=1;e=a*a*a;while (c!=e){d=b;c=0;for (int i=1;i<=a;i++){c=c+d;d=d+2;}b=b+2;}//cout<<b-2;int f=b-4;for (int j=1;j<=a;j++){f=f+2;cout<<f<<' ';}cout<<"的和\n";return 0;}2-14//输出四方*形状#include <iostream>using namespace std;int main(){int i,j;for (i=1;i<=9;i++){j=1;for(j=1;j<=9;j++){}3-1-1}cout<<endl;}return 0;if(i+j>=6&&i+j<=14&&j-i<=4&&i-j<=4) cout<<'*';else cout<<' ';//向数组a 中输入10 个整数，求其中的最大值，最小值和10 个数的算术平均值#include <iostream>using namespace std;int main(){int a[10];for(int i=0;i<=9;i++)cin>>a[i];int max=a[0],min=a[0],sum=a[0];for(int j=0;j<=9;j++){sum=sum+a[j];max=(max>a[j]?max:a[j]);min=(min<a[j]?min:a[j]);}double ave=sum/10.00;cout<<max<<endl<<min<<endl<<ave<<endl;return 0;}3-1-2#include <iostream>using namespace std;int main(){int score[10];int sum=0,a=0,b=0;for(int i=0;i<=9;i++){cin>>score[i];sum=sum+score[i];}double ave=sum/10.0;for(int j=0;j<=9;j++){if(score[j]>ave) a++;if(score[j]<60) b++; }l;}3-3-1cout<<"成绩大于平均值的人数是"<<a<<endl<<"成绩小于60 的人数"<<b<<end return 0;#include <iostream>using namespace std;int main(){int a[10],sum=0,min,max;double ave;int *ptoa=a;for (int i=0;i<=9;i++){cin>>*(a+i);sum+=*(a+i);}min=*(a);max=*(a);for (int j=1;j<=9;j++){min=(min<*(a+j)?min:*(a+j));max=(max>*(a+j)?max:*(a+j)); }}3-3-2cout<<max<<endl<<min<<endl; ave=sum/10.0; cout<<ave<<endl; return 0;#include <iostream>using namespace std;int main(){int a[10],sum=0,j=0,c=0; //定义数组a，sum 是各学生成绩之和，j 是小于60 的个数，c 是大于平均值的个数double ave=0; //定义平均值int *ptoa=a; //使用指针for (int i=0;i<=9;i++) //输入并算和，统计小于60 的{cin>>*(ptoa+i);sum+=*(ptoa+i);if (*(ptoa+i)<60){j++;}}ave=sum/10.0; //计算平均值//cout<<ave<<endl; //可以输出平均值for (int k=0;k<=9;k++) //计算大于平均值的{if (*(ptoa+k)>ave){c++;}}}3-3-3cout<<c<<endl<<j; return 0;#include <iostream>using namespace std;int main(){char string[100];cin>>string;int i=0,an=0,in=0;cout<<"您输入的字符串";while (string[i]!='\0'){if(string[i]=='a') an++;if(string[i]=='i') in++;cout<<string[i];i++;}cout<<endl<<an<<endl<<in<<endl;return 0;}3-3-3a#include <iostream>using namespace std;int main(){char a[100]; //定义存放字符串的数组char *ptoa=a; //使用指针int i=0,an=0,in=0; //an，in 分别为a，i 的个数cin>>a;while (*(ptoa+i)!='\0') //a【i】{cout<<*(ptoa+i);switch (*(ptoa+i)) //判断{}i++; }case 'a' : an++;break; case 'i' : in++;break;}3-3-4cout<<endl<<an<<endl<<in; return 0;#include <iostream> using namespace std; int main(){int a[3][3];for (int i=0;i<=2;i++){for(int j=0;j<=2;j++){cin>>*(*(a+i)+j);}}cout<<*(*(a+0)+0)+*(*(a+1)+1)+*(*(a+2)+2)<<endl;cout<<*(*(a+0)+2)+*(*(a+1)+1)+*(*(a+2)+0)<<endl;return 0;}3-3-5v1#include <iostream>using namespace std;int main(){int a[11]={2,4,5,8,12,14,16,18,20,30,0},b,i,m,j;cin>>b;a[10]=b;if (b<2){m=0;goto end;}if (b>30){goto end2;}for(i=0;i<=9;i++) {if (a[i+1]>b){} end:;m=i+1;goto end; }for (j=10;j>=m+1;j--) {a[j]=a[j-1];}end2:; }a[m]=b;for (int k=0;k<=10;k++)cout<<a[k]<<endl; return 0;3-3-5v2#include <iostream>using namespace std;int main(){int i,j,temp;int a[11]={2,4,5,8,12,14,16,18,20,30};cin>>a[10];for (i=0;i<=10;i++){for(j=0;j<=10-i-1;j++){if(a[j]>a[j+1]){temp=a[j+1];a[j+1]=a[j];a[j]=temp;}}}for (int k=0;k<=10;k++) cout<<a[k]<<' ';cout<<'\n';return 0;}3-3-5v3#include <iostream>using namespace std;int main(){int a[11]={2,4,5,8,12,14,16,18,20,30},num,i,j;cout<<"请输入一个整数";cin>>num;if (num>a[9]){a[10]=num;}else{for (i=0;i<=11;i++){if(a[i]>num){for(j=9;j>=i;j--){a[j+1]=a[j];}a[i]=num;break;}}}for (i=0;i<=10;i++){cout<<a[i]<<' ';}return 0;}3-3-5final#include<iostream.h>void main(){int a[11]={2,4,5,8,12,14,16,18,20,30},b,i=0,j=10;cin>>b;while(a[i]<b&&i<=9)i++;while(j>i){a[j]=a[j-1];j--;}a[i]=b;cout<<"输入插入后的结果：";}3-3-6for(i=0;i<11;i++)cout<<a[i]<<" "; cout<<endl;#include <iostream>using namespace std;int main(){int a[5][3],s[5]={0,0,0,0,0},temp;for (int i=0;i<=4;i++){cout<<"请输入第"<<i+1<<"行的数据"<<endl;for (int j=0;j<=2;j++){cin>>*(*(a+i)+j);*(s+i)+=*(*(a+i)+j);}}/*//注释掉的部分可以输出每行数据之和for (int k=0;k<=4;k++){cout<<*(s+k)<<endl;}*/for (int m=0;m<=4;m++){for (int n=0;n<=4-m-1;n++)if (*(s+n)>*(s+n+1)){ temp=*(s+n+1);*(s+n+1)=*(s+n);*(s+n)=temp;}}for (int l=0;l<=4;l++){cout<<endl<<*(s+l);}} 4-3cout<<endl; system("pause"); return 0;#include <iostream> using namespace std; int fun1(int x,int y); int fun2(int x,int y); int fun3(int x,int y); int fun4(int x,int y);int main(){int a,b;cout<<"输入两个数";cin>>a>>b;cout<<"两个数的和的平方是"<<fun1(a,b)<<endl;cout<<"两个数的平方和是"<<fun2(a,b)<<endl;cout<<"两个数的差的平方是"<<fun3(a,b)<<endl;cout<<"两个数平方的差是"<<fun4(a,b)<<endl;return 0;}int fun1(int x,int y){int z=(x+y)*(x+y);return z;}int fun2(int x,int y){int z=x*x+y*y;return z;}int fun3(int x,int y){int z=(x-y)*(x-y);return z;}int fun4(int x,int y){} 4-4int z=x*x-y*y; return z;#include <iostream>using namespace std;double jc(int x);int sm(int x);int main(){int m,n,s2;double s1;cin>>m>>n;s1=jc(m)/(jc(n)*jc(m-n));s2=sm(m)-sm(n);cout<<s1<<endl<<s2;return 0;}double jc(int x){double s=1;for (int i=1;i<=x;i++) s*=i;return s;}int sm(int x){} 4-6int s=0;for (int i=1;i<=x;i++) s+=i; return s;#include <iostream> #include <cmath> using namespace std; double jxf(int n); double txf(int n); double f(double x);//const pi=3.1415927; int main(){int n;double y1,y2;cin>>n;y1=jxf(n);y2=txf(n);cout<<y1<<endl<<y2;return 0;}double jxf(int n){double sum=0,s;for (int i=0;i<=n-1;i++){s=(i*3.14)/n;sum+=(3.14/n)*f(s);}return sum;}double txf(int n){double sum=0,s1,s2;for (int i=0;i<=n-1;i++){s1=i*3.14/n;s2=(i+1)*3.14/n;sum+=3.14/n*(f(s1)+f(s2));}sum/=2.0;return sum; }double f(double x) {}4-6v1double y;y=sin(x)+cos(x); return y;#include <iostream>#include <cmath>using namespace std;double jxf(int n);double txf(int n);double f(double x);const pi=3.1415927;int main(){int n;double y1,y2;cin>>n;y1=jxf(n);y2=txf(n);if (abs(y1-2)>abs(y2-2)) cout<<"矩形法";else cout<<"梯形法";return 0;}double jxf(int n){double sum=0;for (int i=0;i<=n-1;i++) sum+=pi/n*f(i*pi/n);return sum;}double txf(int n){double sum=0;for (int i=0;i<=n-1;i++) sum+=pi/n*(f(i*pi/n)+f((i+1)*pi/n));sum/=2;return sum;}double f(double x){double y;y=sin(x)+cos(x);return y;}4-6v2error#include <iostream>#include <cmath>using namespace std;double jxf(int n);double txf(int n);double f(double x);const pi=3.1415927;int main(){int n;double y1,y2;cin>>n;y1=jxf(n);y2=txf(n);if (abs(y1-2)>abs(y2-2)) cout<<"矩形法";else cout<<"梯形法";return 0;}double jxf(int n){double sum=0;for (int i=0;i<=n-1;i++) sum+=pi/n*f(i*pi/n);return sum;}double txf(int n){double sum=0;for (int i=0;i<=n-1;i++) sum+=pi/n*(f(i*pi/n)+f((i+1)*pi/n));sum/=2;return sum;}double f(double x){} 4-7double y;y=sin(x)+cos(x); return y;#include <iostream> using namespace std; int my(int x,int y);int mb(int x,int y);int main(){int a,b,max,min;cin>>a>>b;max=my(a,b);min=mb(a,b);cout<<max<<endl<<min<<endl;system("pause");return 0;}int my(int x,int y){for (int i=(x>y?y:x);i>=1;i--)if (x%i==0&&y%i==0) return i; }int mb(int x,int y){}4-11for (int i=(x>y?x:y);i>=1;i++)if (i%x==0&&i%y==0) return i;#include <iostream>using namespace std;void delchar(char *s1,char s2); int main(){char s1[100];char s2;cin>>s1>>s2;delchar(s1,s2);return 0;}void delchar(char *s1,char s2){for (int i=1;*(s1+i)!='\0';i++){if (*(s1+i)==s2){for (int j=0;*(s1+i+j)!='\0';j++){*(s1+i+j)=*(s1+i+j+1);}}}cout<<s1;}4-12#include <iostream>#include <cmath>using namespace std;int check(int a,int b,int c);double s(double a,double b,double c);int main(){double a,b,c;cin>>a>>b>>c;if (check(a,b,c)) cout<<s(a,b,c);else cout<<"error";system("pause");return 0;}int check(int a,int b,int c){if (a+b>c&&abs(a-b)<c) return 1;else return 0;}double s(double a,double b,double c){}4-13double p=(a+b+c)/2;double area=sqrt(p*(p-a)*(p-b)*(p-c)); return area;#include <iostream> #include <cmath> using namespace std; fun (int n,int k);pow10 (int x);int main(){int n,k;cin>>n>>k;cout<<fun(n,k)<<endl;system("pause");return 0;}int fun (int n,int k){if (k>n||k<1) return 0;else{int s;s=n/pow10(k-1);s=s%10;return s;}}int pow10 (int x){}4-14int s=1;for (int i=1;i<=x;i++) s*=10; return s;#include<iostream>using namespace std;double ave(int p[][4],int i);int main(){int a[5][4];for (int i=0;i<=4;i++)for (int j=0;j<=3;j++)cin>>a[i][j];for (i=0;i<=4;i++)cout<<ave(a,i)<<endl;system("pause");return 0;}double ave(int p[][4],int i){double sum=0;for(int j=0;j<=3;j++)sum+=p[i][j];sum/=4;return sum;}4-15#include <iostream>using namespace std;int find(char str[],char a);int main(){char str[100],a;cin>>str>>a;cout<<find(str,a)+1;system("pause");return 0;}int find(char str[],char a){for (int i=0;str[i]!='\0';i++){if (str[i]==a){return i;break;}}if (str[i]=='\0') return -1; }4-16//4_16#include<iostream>using namespace std;int change (int n,int R,int *a);int main(){cout<<"Please input n and R(2<=R<=16)"<<endl;int n,R,a[10];cin>>n>>R;int i=change(n,R,a);for (int j=i-1;j>=0;j--){switch (a[j]){case 11:cout<<'A';break;case 12:cout<<'B';break;case 13:cout<<'C';break;case 14:cout<<'D';break;case 15:cout<<'E';break;default: cout<<a[j];}}system("pause");return 0;}int change (int n,int R,int *a) {int i=0;while (n!=0){*(a+i)=n%R;n/=R;i++;}return i;}4-17#include <iostream>using namespace std; const int N=5;int init(int a[][N]);void fun1(int a[][N]);void fun2(int a[][N]);void fun3(int a[][N],int sum); void fun4(int a[][N]);int main(){int sum=0;int a[2][N];sum=init(a);cout<<"(1)"<<endl;fun1(a);cout<<"(2)"<<endl;fun2(a);cout<<"(3)"<<endl;fun3(a,sum);cout<<"(4)"<<endl;fun4(a);return 0;}int init(int a[][N]){int sum=0;for (int i=0;i<=N-1;i++){a[0][i]=i+1;cin>>a[1][i];sum+=a[1][i];}return sum;}void fun1(int a[][N]){for (int i=0;i<=N-1;i++)if (a[1][i]>85){cout<<a[0][i]<<' '<<a[1][i]<<endl;}}void fun2(int a[][N]){for (int i=0;i<=N-1;i++)if (a[1][i]<60){cout<<a[0][i]<<' '<<a[1][i]<<endl;}}void fun3(int a[][N],int sum){int aveplus=0;double ave=sum/N;for (int i=0;i<=N-1;i++)if (a[1][i]>=ave)aveplus++;cout<<aveplus<<endl;}void fun4(int a[][N]){for (int i=0;i<=N-1;i++)for (int j=0;j<=N-1;j++){if (a[1][j]>a[1][j+1]){int temp1=a[1][j+1];a[1][j+1]=a[1][j];a[1][j]=temp1;int temp2=a[0][j+1];a[0][j+1]=a[0][j];a[0][j]=temp2;}}for (i=0;i<=N-1;i++){cout<<a[0][i]<<' '<<a[1][i]<<endl;}}5-5//计算当前日期是一年之中的第几天#include <iostream>using namespace std;//定义日期类class Date{private://y 年m 月d 天nod 一年中的第几天ly 是否是闰年int y,m,d,nod,ly;public:Date (int ioy=2009,int iom=5,int iod=1){y=ioy;m=iom;d=iod;}int checkdate();int Issleapyear();void Print();int NumberOfDays();};//是否是闰年int Date::Issleapyear(){return ly=(y%400==0)||(y%4==0&&y%100!=0); }//计算一年之中的第几天int Date::NumberOfDays (){int a[2][13]={{0,31,29,31,30,31,30,31,31,30,31,30,31},{0,31,28,31,30,31,30,31, 31,30,31,30,31}};nod=0;for (int i=0;i<=m-1;i++)nod+=a[Issleapyear()][i];nod+=d;return nod;}//判断日期是否合法int Date::checkdate (){return (m>0&&m<13)&&(d>0&&d<=31);}//输出void Date::Print (){cout<<y<<"年"<<m<<"月"<<d<<"日"<<"是该年的第"<<NumberOfDays ()<<"天"<<endl;}//主函数int main(){Date d1;Date d2(1991,5,2);int y,m,d;cout<<"请依次输入年月日";cin>>y>>m>>d;Date d3(y,m,d);d1.Print();d2.Print();if(d3.checkdate()){} else {}d3.Print(); cout<<"Error";} 5-6system("pause"); system("cls"); system("pause"); return 0;//判断15，31 是否偶数，素数#include <iostream>using namespace std;//定义整数类class Interger{private:int d;public:int GetD();void SetD(int iod=0){d=iod;}int IsOdd();int IsPrime();};//返回D 的值int Interger::GetD(){return d;}//判断是否偶数int Interger::IsOdd(){return 1-d%2;}//判断是否素数int Interger::IsPrime(){for (int i=2;i<=d;i++)if (d%i==0) break;if (i==d) return 0;else return 1;}//主函数int main(){Interger num[2];num[0].SetD(31);num[1].SetD(15);for (int i=0;i<=1;i++){cout<<num[i].GetD();if (num[i].IsOdd()) cout<<"是偶数";else cout<<"不是偶数";if (num[i].IsPrime()) cout<<"不是素数";else cout<<"是素数";cout<<endl;}} 5-7system("pause"); return 0;//编写一个求n!的类，并在main()中分别输出2-9 的阶乘#include<iostream>using namespace std;//定义阶乘类（汗）class jc{private:int a,j;public://传值void set(int ioa){a=ioa;}//计算阶乘int fun(){j=1;for (int i=1;i<=a;i++)j*=i;return j;}};//主函数int main(){jc num[8];for (int i=0;i<=7;i++){num[i].set(i+2);cout<<i+2<<"!="<<num[i].fun()<<endl;}return 0;}5-8#include <iostream>using namespace std;//定义线类class Line{private:double A,B,C;public://IO 函数Line(double ioA,double ioB,double ioC){A=ioA;B=ioB;C=ioC;}//定义友元函数friend void judge(Line &,Line &);};//判断两线是否相交void judge(Line &l1,Line&l2){if (l1.A*l2.B==l2.A*l1.B) cout<<"平行(或重合)"<<endl;else{cout<<"相交，相交点是:("<<(l1.C*l2.B-l1.B*l2.C)/(l2.A*l1.B-l1.A*l2.B);cout<<","<<(l2.A*l1.C-l1.A*l2.C)/(l1.A*l2.B-l1.B*l2.A)<<")"<<endl;}}//主函数int main(){//定义两条直线，l1，l2，系数分别为a,b,c,d,e,fint a,b,c,d,e,f;system("color 79");cout<<"请输入直线1 的三个系数";cin>>a>>b>>c;cout<<"请输入直线2 的三个系数";cin>>d>>e>>f;system("color 07");Line l1(a,b,c),l2(d,e,f);judge(l1,l2);system("pause");。
数据结构习题(1-7)答案
第一章绪论一. 选择题1．BD 2．CA 3．B 4．C 5．A 6．D 7．A 8．A 9．A 10．C 二. 解答题第二章线性表一. 选择题1．A 2．B 3．A 4．D 5．A 6．C 7．A 8．B 9．A二.填空题1．.物理位置相邻指针2．.直接前驱直接后继3．顺序链式三. 算法设计题1．①int count(Linklist h,int x){int num=0;Linknode *p;p=h->next;while(p&&p->data<=x)//p指针向后移动，直至p指向第一个值大于x的结点p=p->next;while(p)if(p->next&&p->data==p->next->data)//若p没有指向链表中同一数值的最后一个结点，则向后移动p=p->next;else//若p指向数值相同的结点中的最后一个，则num加1，p指针后移，继续执行while循环{num++;p=p->next;}return num;}②void delevenl(Linklist &h,int x){Linknode *p,*r;p=h->next;r=h;while(p&&p->data<x){if(p->data%2==0){r->next=p->next;free(p);p=r->next;}else{r=p;p=p->next;}}}2．void converse(Linklist &h){Linknode *p,*q;p=h->next;h->next=NULL;while(p){q=p->next;p->next=h->next;h->next=p;p=q;}}3．void decompose(Linklist La,Linklist &Lb,Linklist &Lc) {Linknode *p;Lc=(Linknode *)malloc(sizeof(Linknode));Lc->next=NULL;p=La->next;Lb=La;Lb->next=NULL;while(p){La=p->next;if(p->data>0){p->next=Lc->next;Lc->next=p;}else{p->next=Lb->next;Lb->next=p;}p=La;}}4．int subset(LinkList la, LinkList lb){ LinkNode * pa,*pb;pa=la->next;while(pa){ pb=lb->next;while(pb&&(pb->data!=pa->data)) pb=pb->next;if(!pb) return 0;pa=pa->next;}return 1;}算法时间复杂度O（A.Length*B.Length）5．void priorset(DuLinkList &la){ p=la;q=la->next;while(q!=la){q->prior=p; p=q;q=q->next;} q->prior=p;}第三章栈和队列一. 选择题1．C C 2．C 3．B 4．D 5．C 6．A 7．C 8．D二. 解答题1栈底栈底2//双向栈类型定义#define STACK_SIZE 100;Typedef struct {SElemType * base_one, * base_two;//栈底指针SElemType * top_one, * top_two;//栈顶指针int stacksize;} SqStack;Status InitStack ( SqStack &S) {//初始化双向栈S.base_one=S.top_one=( SElemType *)malloc(STACK_SIZE * sizeof(SElemType));//第一个栈底和栈顶指向数组起点S.base_two=S.top_two=S.base_one +STACK_SIZE-1;// 第二个栈底和栈顶指向数组终点S.stacksize= STACK_SIZE ;return OK;}//InitStackStatus Push ( SqStack &S, int i, SElemType e){//入栈操作，i=0时将e存入前栈，i=1时将e存入后栈if( S.top_two < S.top_one) return OVERFLOW;//栈满，不考虑追加空间if( i = = 0 )*S.top_one++ = e;else*S.top_two-- = e;return OK;}//PushSElemType Pop ( SqStack &S, int i){//出栈操作，i=0出前栈，i=1出后栈if( i==0 ) {if ( S.top_one==S.base_one) return ERROR;S.top_one--; e=*S.top_one;}else {if ( S.top_two==S.base_two) return ERROR;S.top_two++; e=*S.top_two;}return e;}//Pop2．#define M 3struct Stack{Qelemtype data[M];int top;};struct Queue{Stack s1;Stack s2;};void InitQueue(Queue &Q)//初始化队列{Q.s1.top=0;Q.s2.top=0;}int IsEmpty(Queue &Q)//判断队列是否为空{if(Q.s1.top==0&&Q.s2.top==0)return 1;if(Q.s2.top==0&&Q.s1.top!=0){while(Q.s1.top!=0)Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];}return 0;}int IsFull(Queue &Q){if(Q.s1.top==M&&Q.s2.top!=0)return 1;if(Q.s1.top==M&&Q.s2.top==0){while(Q.s1.top!=0)Q.s2.data[Q.s2.top++]=Q.s1.data[--Q.s1.top];return 0;}if(Q.s1.top!=M)return 0;}void InQueue(Queue &Q,Qelemtype e) {if(IsFull(Q)){cout<<"OVERFLOW"<<endl;return;}Q.s1.data[Q.s1.top++]=e;}void DeQueue(Queue &Q,Qelemtype &e) {if(IsEmpty(Q)){cout<<"UNDERFLOW"<<endl;return;}e=Q.s2.data[--Q.s2.top];}3．(1)不能（2）可以原因略4．struct QueueNode{Qelemtype data;QueueNode *next;};struct LinkQueue{QueueNode *rear;};void InitQueue(LinkQueue &Q) //置空队{Q.rear=new QueueNode;Q.rear->next=Q.rear;}int EmptyQueue(LinkQueue Q) //判队空{return Q.rear==Q.rear->next;}void EnQueue(LinkQueue &Q, Qelemtype e)//元素入队{QueueNode *p;//新建一个结点，并置其值为ep=new QueueNode;p->data=e;//将结点插入队列末尾p->next=Q.rear->next;Q.rear->next=p;//修改队尾指针Q.rear=p;}void DeQueue(LinkQueue &Q,Qelemtype &e) //元素出队{QueueNode *p;if (EmptyQueue(Q)) //若队中无元素，则无法执行出队操作{cout<<"error"<<endl;return;}p=Q.rear->next->next; //让p指向队头元素e=p->data;if(p==Q.rear)//如队中只有一个元素，则要rear指向头结点，头结点的next指针指向自身{Q.rear=Q.rear->next;Q.rear->next=Q.rear;}else //若队中不只一个元素，则删除p所指向的结点。
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)
第1章4．答案：（1）顺序存储结构顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。
（2）链式存储结构顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。
但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。
所以链式存储结构通常借助于程序设计语言的指针类型来描述。
5. 选择题(1)~(6)：CCBDDA\6．（1）O(1) （2）O(m*n) （3）O(n2)（4）O(log3n) （5）O(n2) （6）O(n)（第2章1．选择题（1）~（5）：BABAD （6）~（10）： BCABD （11）~（15）：CDDAC\2．算法设计题（1）将两个递增的有序链表合并为一个递增的有序链表。
要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。
表中不允许有重复的数据。
[题目分析]合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。
如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。
当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){法设计题（1）将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。
当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。
两个栈均从两端向中间增长。
试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。
(完整版) 《数据结构》教材课后习题+答案
第1章绪论习题1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。
3．简述逻辑结构的四种基本关系并画出它们的关系图。
4．存储结构由哪两种基本的存储方法实现？5．选择题（1）在数据结构中，从逻辑上可以把数据结构分成（）。
A．动态结构和静态结构B．紧凑结构和非紧凑结构C．线性结构和非线性结构D．内部结构和外部结构（2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（）。
A．存储结构B．存储实现C．逻辑结构D．运算实现（3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（）。
A．数据具有同一特点B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致C．每个数据元素都一样D．数据元素所包含的数据项的个数要相等（4）以下说法正确的是（）。
A．数据元素是数据的最小单位B．数据项是数据的基本单位C．数据结构是带有结构的各数据项的集合D．一些表面上很不相同的数据可以有相同的逻辑结构（5）以下与数据的存储结构无关的术语是（）。
A．顺序队列 B. 链表 C. 有序表 D. 链栈（6）以下数据结构中，（）是非线性数据结构A．树B．字符串C．队D．栈6．试分析下面各程序段的时间复杂度。
（1）x=90; y=100;while(y>0)if(x>100){x=x-10;y--;}else x++;（2）for (i=0; i<n; i++)for (j=0; j<m; j++)a[i][j]=0;（3）s=0;for i=0; i<n; i++)for(j=0; j<n; j++)s+=B[i][j];sum=s;（4）i=1;while(i<=n)i=i*3;（5）x=0;for(i=1; i<n; i++)for (j=1; j<=n-i; j++)x++;（6）x=n; //n>1y=0;while(x≥(y+1)* (y+1))y++;（1）O（1）（2）O（m*n）（3）O（n2）（4）O（log3n）（5）因为x++共执行了n-1+n-2+……＋1= n(n-1)/2，所以执行时间为O（n2）（6）O(n)第2章线性表1．选择题（1）一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。
数据结构(C语言版)第三版习题答案
精神成就事业，态度决定一切。
附录习题参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表（Hash）存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下：数据：数据是信息的载体是计算机程序加工和处理的对象包括数值数据和非数值数据数据项：数据项指不可分割的、具有独立意义的最小数据单位数据项有时也称为字段或域数据元素：数据元素是数据的基本单位在计算机程序中通常作为一个整体进行考虑和处理一个数据元素可由若干个数据项组成数据逻辑结构：数据的逻辑结构就是指数据元素间的关系数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系数据类型：是指变量的取值范围和所能够进行的操作的总和算法：是对特定问题求解步骤的一种描述是指令的有限序列1.4 语句的时间复杂度为：(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3)1.5 参考程序：main(){int XYZ；scanf("%d %d%d"&X&YZ)；if (X>=Y)if(X>=Z)if (Y>=Z) { printf("%d %d%d"XYZ);}else{ printf("%d %d%d"XZY);}else{ printf("%d %d%d"ZXY);}else if(Z>=X)if (Y>=Z) { printf("%d %d%d"YZX);}else{ printf("%d%d%d"ZYX);}else{ printf("%d%d%d"YXZ);}}1.6 参考程序：main(){int in;float xa[]p;printf("\nn=");scanf("%f"&n);printf("\nx=");scanf("%f"&x);for(i=0;i<=n;i++)scanf("%f "&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf("%f"p)'}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). Ｏ(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路：将顺序表A中的元素输入数组a若数组a中元素个数为n将下标为012...（n-1）/2的元素依次与下标为nn-1...（n-1）/2的元素交换输出数组a的元素参考程序如下：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<=n-1;i++)scanf("%f "&a[i]);for(i=0;i<=(n-1)/2;i++){ t=a[i]; a[i] =a[n-1-i]; a[n-1-i]=t;} for(i=0;i<=n-1;i++)printf("%f"a[i]);}2.4 算法与程序：main(){int in;float ta[];printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]);for(i=1;i<n;i++)if(a[i]>a[0]{ t=a[i]; a[i] =a[0]; a[0]=t;}printf("%f"a[0]);for(i=2;i<n;i++)if(a[i]>a[1]{ t=a[i]; a[i] =a[1]; a[1]=t;}printf("%f"a[0]);}2.5 算法与程序：main(){int ijkn;float xta[];printf("\nx=");scanf("%f"&x);printf("\nn=");scanf("%f"&n);for(i=0;i<n;i++)scanf("%f "&a[i]); // 输入线性表中的元素for (i=0; i<n; i++) { // 对线性表中的元素递增排序k=i;for (j=i+1; j<n; j++) if (a[j]<a[k]) k=j; if (k<>j) {t=a[i];a[i]=a[k];a[k]=t;}}for(i=0;i<n;i++) // 在线性表中找到合适的位置if(a[i]>x) break;for(k=n-1;k>=i;i--) // 移动线性表中元素然后插入元素xa[k+1]=a[k];a[i]=x;for(i=0;i<=n;i++) // 依次输出线性表中的元素printf("%f"a[i]);}2.6 算法思路：依次扫描A和B的元素比较A、B当前的元素的值将较小值的元素赋给C如此直到一个线性表扫描完毕最后将未扫描完顺序表中的余下部分赋给C即可C的容量要能够容纳A、B两个线性表相加的长度有序表的合并算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st && j<=st )if (A.data[i]<=B.data[j])C->data[k++]=A.data[i++]；elseC->data[k++]=B.data[j++]；while (i<=st )C->data[k++]= A.data[i++]；while (j<=st )C->data[k++]=B.data[j++]；C->last=k-1；}2.7 算法思路：依次将A中的元素和B的元素比较将值相等的元素赋给C如此直到线性表扫描完毕线性表C就是所求递增有序线性表算法：void merge (SeqList ASeqList BSeqList *C){ int ijk；i=0；j=0；k=0；while ( i<=st)while（j<=st )if (A.data[i]=B.data[j])C->data[k++]=A.data[i++]；C->last=k-1；}习题3参考答案3.1.选择题(1). D (2). C (3). D (4). C (5). B (6). C (7). C (8). C (9). B (10).AB (11). D (12). B (13). D (14). C (15). C (16). D(17). D (18). C (19). C (20). C 3.2.填空题（1） FILOFIFO（2） -13 4 X * + 2 Y * 3 / -（3） stack.topstack.s[stack.top]=x（4） p>llink->rlink=p->rlinkp->rlink->llink=p->rlink（5） (R-F+M)%M（6） top1+1=top2（7） F==R（8） front==rear（9） front==(rear+1)%n（10） N-13.3 答：一般线性表使用数组来表示的线性表一般有插入、删除、读取等对于任意元素的操作而栈只是一种特殊的线性表栈只能在线性表的一端插入（称为入栈push）或者读取栈顶元素或者称为"弹出、出栈"(pop)3.4 答：相同点：栈和队列都是特殊的线性表只在端点处进行插入删除操作不同点：栈只在一端（栈顶）进行插入删除操作；队列在一端（top）删除一端(rear)插入3.5 答：可能序列有14种：ABCD; ACBD; ACDB; ABDC; ADCB; BACD; BADC; BCAD; BCDA; BDCA; CBAD; CBDA; CDBA; DCBA3.6 答：不能得到435612最先出栈的是4则按321的方式出不可能得到1在2前的序列可以得到135426按如下方式进行push(1)pop()push(2)push(3)pop()push(4)push(5)pop()pop()pop()push(6)pop()3.7 答：stack3.8 非递归:int vonvert (int noint a[]) //将十进制数转换为2进制存放在a[] 并返回位数{int r;SeStack s*p;P=&s;Init_stack(p);while(no){push(pno%2);no/=10;}r=0;while(!empty_stack(p)){pop(pa+r);r++;}return r;}递归算法:void convert(int no){if(no/2>0){Convert(no/2);Printf("%d"no%2);}elseprintf("%d"no);}3.9 参考程序：void view(SeStack s){SeStack *p; //假设栈元素为字符型char c;p=&s;while(!empty_stack(p)){c=pop(p);printf("%c"c);}printf("\n");}3.10 答：char3.11 参考程序：void out(linkqueue q){int e;while(q.rear !=q.front ){dequeue(qe);print(e); //打印}}习题4参考答案4.1 选择题：(1). A (2). D (3). C (4). C (5). B (6). B (7). D (8). A (9). B (10). D 4.2 填空题：（1）串长相等且对应位置字符相等（2）不含任何元素的串（3）所含字符均是空格所含空格数（4） 10（5） "hello boy"（6） 13（7） 1066（8）模式匹配（9）串中所含不同字符的个数（10） 364.3 StrLength (s)=14StrLength (t)=4SubStr( s87)=" STUDENT"SubStr(t21)="O"StrIndex(s"A")=3StrIndex (st)=0StrRep(s"STUDENT"q)=" I AM A WORKER"4.4 StrRep(s"Y""+");StrRep(s"+*""*Y");4.5 空串：不含任何字符；空格串：所含字符都是空格串变量和串常量:串常量在程序的执行过程中只能引用不能改变；串变量的值在程序执行过程中是可以改变和重新赋值的主串与子串：子串是主串的一个子集串变量的名字与串变量的值:串变量的名字表示串值的标识符4.6int EQUAl(ST){char *p*q;p=&S;q=&T;while(*p&&*q){if(*p!=*q)return *p-*q;p++;q++;}return *p-*q;}4.7(1)6*8*6=288(2)1000+47*6=1282(3)1000+(8+4)*8=1096(4)1000+(6*7+4)*8=13684.8习题5参考答案5.1 选择（1）C（2）B（3）C（4）B（5）C（6）D（7）C（8）C（9）B（10）C （11）B（12）C（13）C（14）C（15）C（16）B5.2 填空（1）1（2）1036；1040（3）2i（4） 1 ； n ; n-1 ; 2（5）2k-1；2k-1（6）ACDBGJKIHFE（7）p!=NULL（8）Huffman树（9）其第一个孩子; 下一个兄弟（10）先序遍历；中序遍历5.3叶子结点:C、F、G、L、I、M、K；非终端结点：A、B、D、E、J；各结点的度：结点： A B C D E F G L I J K M度： 4 3 0 1 2 0 0 0 0 1 0 0树深：4无序树形态如下：二叉树形态如下：5.5二叉链表如下:三叉链表如下:5.6先序遍历序列:ABDEHICFJG中序遍历序列:DBHEIAFJCG后序遍历序列:DHIEBJFGCA5.7(1) 先序序列和中序序列相同：空树或缺左子树的单支树；(2) 后序序列和中序序列相同：空树或缺右子树的单支树；(3) 先序序列和后序序列相同：空树或只有根结点的二叉树5.8这棵二叉树为:先根遍历序列:ABFGLCDIEJMK后根遍历序列:FGLBCIDMJKEA层次遍历序列:ABCDEFGLIJKM5.10证明：设树中结点总数为n叶子结点数为n0则n=n0 + n1 + ...... + nm （1）再设树中分支数目为B则B=n1 + 2n2 + 3n3 + ...... + m nm （2）因为除根结点外每个结点均对应一个进入它的分支所以有n= B + 1 （3）将（1）和（2）代入（3）得n0 + n1 + ...... + nm = n1 + 2n2 + 3n3 + ...... + m nm + 1 从而可得叶子结点数为：n0 = n2 + 2n3 + ...... + (m-1)nm + 15.11由5.10结论得n0 = (k-1)nk + 1又由 n=n0 + nk得nk= n-n0代入上式得n0 = (k-1)（n-n0）+ 1叶子结点数为：n0 = n (k-1) / k5.12int NodeCount(BiTree T){ //计算结点总数if(T)if (T-> lchild==NULL )&&( T --> rchild==NULL )return 1;elsereturn NodeCount(T-> lchild ) +Node ( T --> rchild )+1; elsereturn 0;}void ExchangeLR(Bitree bt){/* 将bt所指二叉树中所有结点的左、右子树相互交换 */ if (bt && (bt->lchild || bt->rchild)) {bt->lchild<->bt->rchild;Exchange-lr(bt->lchild);Exchange-lr(bt->rchild);}}/* ExchangeLR */5.14int IsFullBitree(Bitree T){/* 是则返回1否则返回0*/Init_Queue(Q); /* 初始化队列*/flag=0;In_Queue(QT); /* 根指针入队列按层次遍历*/while(!Empty_Queue (Q)){Out_Queue(Qp);if(!p) flag=1; /* 若本次出队列的是空指针时则修改flag值为1若以后出队列的指针存在非空则可断定不是完全二叉树 */else if (flag) return 0; /*断定不是完全二叉树 */ else{In_Queue(Qp->lchild);In_Queue(Qp->rchild); /* 不管孩子是否为空都入队列*/}}/* while */return 1; /* 只有从某个孩子指针开始之后所有孩子指针都为空才可断定为完全二叉树*/}/* IsFullBitree */转换的二叉树为：5.16对应的森林分别为：5.17typedef char elemtype;typedef struct{ elemtype data;int parent;} NodeType;(1) 求树中结点双亲的算法:int Parent(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标(根的双亲为-1 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) return t[i].parent; return -2;}/*Parent*/(2) 求树中结点孩子的算法:void Children(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++){if(x==t[i].data)break;/*找到x退出循环*/}/*for*/if(i>=MAXNODE) printf("x不存在\n"); else {flag=0;for(j=0;j<MAXNODE;j++)if(i==t[j].parent){ printf("x的孩子:%c\n"t[j].data);flag=1;}if(flag==0) printf("x无孩子\n");}/*Children*/5.18typedef char elemtype;typedef struct ChildNode{ int childcode;struct ChildNode *nextchild;}typedef struct{ elemtype data;struct ChildNode *firstchild;} NodeType;(1) 求树中结点双亲的算法:int ParentCL(NodeType t[ ]elemtype x){/* x不存在时返回-2否则返回x双亲的下标 */for(i=0;i<MAXNODE;i++)if(x==t[i].data) {loc=i;/*记下x的下标*/break;}if(i>=MAXNODE) return -2; /* x不存在 *//*搜索x的双亲*/for(i=0;i<MAXNODE;i++)for(p=t[i].firstchild;p!=NULL;p=p->nextchild) if(loc==p->childcode)return i; /*返回x结点的双亲下标*/}/* ParentL */(2) 求树中结点孩子的算法:void ChildrenCL(NodeType t[ ]elemtype x){for(i=0;i<MAXNODE;i++)if(x==t[i].data) /*依次打印x的孩子*/{flag=0; /* x存在 */for(p=t[i].firstchild;p;p=p->nextchild){ printf("x的孩子:%c\n"t[p-> childcode].data);flag=1;}if(flag==0) printf("x无孩子\n");return;}/*if*/printf("x不存在\n");return;}/* ChildrenL */5.19typedef char elemtype;typedef struct TreeNode{ elemtype data;struct TreeNode *firstchild; struct TreeNode *nextsibling; } NodeType;void ChildrenCSL(NodeType *telemtype x){ /* 层次遍历方法 */Init_Queue(Q); /* 初始化队列 */In_Queue(Qt);count=0;while(!Empty_Queue (Q)){Out_Queue(Qp);if(p->data==x){ /*输出x的孩子*/p=p->firstchild;if(!p) printf("无孩子\n");else{ printf("x的第%i个孩子:%c\n"++countp->data);/*输出第一个孩子*/p=p->nextsibling; /*沿右分支*/while(p){printf("x的第%i个孩子:%c\n"++countp->data);p=p-> nextsibling;}}return;}if(p-> firstchild) In_Queue(Qp-> firstchild);if(p-> nextsibling) In_Queue(Qp-> nextsibling);}}/* ChildrenCSL */5.20(1) 哈夫曼树为:(2) 在上述哈夫曼树的每个左分支上标以1右分支上标以0并设这7个字母分别为A、B、C、D、E、F和H如下图所示：则它们的哈夫曼树为分别为:A：1100B：1101C：10D：011E：00F：010H：111习题6参考答案6.1 选择题（1）C （2）A （3）B（4）C（5）B______条边（6）B（7）A（8）A（9）B（10）A（11）A（12）A（13）B（14）A（15）B（16）A（17）C 6.2 填空（1） 4（2） 1对多 ; 多对多（3） n-1 ; n（4） 0_（5）有向图（6） 1（7）一半（8）一半（9）___第i个链表中边表结点数___（10）___第i个链表中边表结点数___（11）深度优先遍历；广度优先遍历（12）O（n2）（13）___无回路6.3（1）邻接矩阵:（2）邻接链表：（3）每个顶点的度：顶点度V1 3V2 3V3 2V4 3V5 36.4（1）邻接链表：（2）逆邻接链表：（3）顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5（1）深度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 （1）广度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量：6.7顶点（1）（2）（3）（4）（5）Low Close Cost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexLow CloseCost VexV10 00 00 00 00 0V21 00 00 00 00 0V31 01 00 00 00 0V43 02 12 10 10 1V5∞ 05 13 22 30 3U{v1} {v1v2} {v1v2v3} {v1 v2 v3 v4} {v1 v2 v3 v4 v5} T {} { (v1 v2) } {(v1 v2) (v1 v3) } {(v1 v2) (v1 v3) (v2 v4) } {(v1 v2) (v1v3)(v2v4)(v4v5) }最小生成树的示意图如下：6.8拓扑排序结果： V3--> V1 --> V4 --> V5 --> V2 --> V66.9（1）建立无向图邻接矩阵算法：提示：参见算法6.1因为无向图的邻接矩阵是对称的所以有for (k=0; k<G ->e; k++) /*输入e条边建立无向图邻接矩阵*/{ scanf("\n%d%d"&i&j);G ->edges[i][j]= G ->edges[j][i]=1;}(2)建立无向网邻接矩阵算法:提示：参见算法6.1初始化邻接矩阵：#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息：不仅要输入边邻接的两个顶点序号还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边建立无向网邻接矩阵*/{ scanf("\n%d%d%d"&i&j&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示：参见算法6.16.10(1)建立无向图邻接链表算法：typedef VertexType char;int Create_NgAdjList(ALGraph *G){ /* 输入无向图的顶点数、边数、顶点信息和边的信息建立邻接表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*边数不能为负 */G->e=e;for(m=0;m< G->n ;m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e; m++){scanf("\n%d%d"&i&j); /* 输入一对邻接顶点序号*/if((i<0 || j<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/ p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/ p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;} /* for*/return 0; /*成功*/}//Create_NgAdjList(2)建立有向图逆邻接链表算法：typedef VertexType char;int Create_AdjList(ALGraph *G){ /* 输入有向图的顶点数、边数、顶点信息和边的信息建立逆邻接链表 */scanf("%d"&n); if(n<0) return -1; /* 顶点数不能为负 */G->n=n;scanf("%d"&e); if(e<0) return =1; /*弧数不能为负 */G->e=e;for(m=0;m< G->n; m++)G-> adjlist [m].firstedge=NULL; /*置每个单链表为空表*/for(m=0;m< G->n;m++)G->adjlist[m].vertex=getchar(); /*输入各顶点的符号*/for(m=1;m<= G->e ; m++){scanf("\n%d%d"&t&h); /* 输入弧尾和弧头序号*/if((t<0 || h<0) return -1;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第h+1个链表中插入一个边表结点*/ p->adjvex=t;p->next= G-> adjlist [h].firstedge;G-> adjlist [h].firstedge=p;} /* for*/return 0; /*成功*/}//Create_AdjList6.11void Create_AdjM(ALGraph *G1MGraph *G2){ /*通过无向图的邻接链表G1生成无向图的邻接矩阵G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G2->n;i++) /* 置G2每个元素为0 */for(j=0;j<G2->n;j++) G2->edges[i][j]= 0;for(m=0;m< G1->n;m++)G2->vexs[m]=G1->adjlist[m].vertex; /*复制顶点信息*/num=（G1->n/2==0?G1->n/2:G1->n/2+1）; /*只要搜索前n/2个单链表即可*/for(m=0;m< num;m++){ p=G1->adjlist[m].firstedge;while(p){ /* 无向图的存储具有对称性*/G2->edges[m][ p->adjvex ]= G2->edges[p->adjvex ] [m] =1;p==p->next;}}/* for */}/*Create_AdjM */void Create_AdjL(ALGraph *G1MGraph *G2){ /*通过无向图的邻接矩阵G1生成无向图的邻接链表G2*/G2->n=G1->n; G2->e=G1->e;for(i=0;i<G1->n;i++) /* 建立每个单链表 */{ G2->vexs[i]=G1->adjlist[i].vertex;G2->adjlist[i].firstedge=NULL；for(j=i; j<G1->n; j++) /*对称矩阵只要搜索主对角以上的元素即可*/{ if(G1->edges[i][j]== 1){ p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第i+1个链表中插入一个边表结点*/p->adjvex=j;p->next= G-> adjlist [i].firstedge;G-> adjlist [i].firstedge=p;p=(EdgeNode*)malloc(sizeof(EdgeNode));/*在第j+1个链表中插入一个边表结点*/p->adjvex=i;p->next= G-> adjlist [j].firstedge;G-> adjlist [j].firstedge=p;}/*if*/}/* for*/}/* for*/}/* Create_AdjL */6.13(1) 邻接矩阵中1的个数的一半;(2) 若位于[i-1j-1]或[j-1i-1]位置的元素值等于1则有边相连否则没有(3) 顶点i的度等于第i-1行中或第i-1列中1的个数6.14(1) 邻接链表中边表结点的个数的一半;(2) 若第i-1（或j-1）个单链表中存在adjvex域值等于j-1（或i-1）的边表结点则有边相连否则没有(3) 顶点i的度等于第i-1个单链表中边表结点的个数提示：参见算法6.2 和6.3习题 7参考答案7.1 选择题（1）C (2)C (3) C (4)B (5) A (6)A (7) D (8)B (9)D (10) B(11)B (12)A (13)C (14)C (15)A (16)D (17)C (18)BC (19)B (20)A7.2 填空题（1） O(n)O(log2n)（2） 12485log2(n+1)-1（3）小于大于（4）增序序列（5）m-1（6） 70; 342055（7） n/m（8）开放地址法链地址法（9）产生冲突的可能性就越大产生冲突的可能性就越小（10）关键码直接（11）②①⑦（12） 1616821（13）直接定址法数字分析法平方取中法折叠法除留余数法随机数法（14）开放地址法再哈希法链地址法建立一个公共溢出区（15）装满程度（16）索引快（17）哈希函数装填因子（18）一个结点（19）中序（20）等于7.3 一棵二叉排序树(又称二叉查找树)或者是一棵空树或者是一棵同时满足下列条件的二叉树：(1)若它的左子树不空则左子树上所有结点的键值均小于它根结点键值(2)若它的右子树不空则右子树上所有结点的键值均大于它根结点键值(3)它的左、右子树也分别为二叉排序树7.4 对地址单元d=H(K)如发生冲突以d为中心在左右两边交替进行探测按照二次探测法键值K的散列地址序列为：do=H(K)d1=(d0+12)mod md2=(d0-12)mod md3=(d0+22)mod md4=(d0-12)mod m......7.5 衡量算法的标准有很多时间复杂度只是其中之一尽管有些算法时间性能很好但是其他方面可能就存在着不足比如散列查找的时间性能很优越但是需要关注如何合理地构造散列函数问题而且总存在着冲突等现象为了解决冲突还得采用其他方法二分查找也是有代价的因为事先必须对整个查找区间进行排序而排序也是费时的所以常应用于频繁查找的场合对于顺序查找尽管效率不高但却比较简单常用于查找范围较小或偶而进行查找的情况7.6此法要求设立多个散列函数Hii=1...k当给定值K与闭散列表中的某个键值是相对于某个散列函数Hi的同义词因而发生冲突时继续计算该给定值K在下一个散列函数Hi+1下的散列地址直到不再产生冲突为止7.7散列表由两个一维数组组成一个称为基本表另一个称为溢出表插入首先在基本表上进行；假如发生冲突则将同义词存人溢出表7.8 结点个数为n时高度最小的树的高度为1有两层它有n-1个叶结点1个分支结点；高度最大的树的高度为n-l有n层它有1个叶结点n-1个分支结点7.9 设顺序查找以h为表头指针的有序链表若查找成功则返回结点指针p查找失败则返回null值pointer sqesrearch(pointer hint xpointerp){p=null；while(h)if(x>h->key)h=h->link；else{if(x==h->key)p=h；return(p)；}}虽然链表中的结点是按从小到大的顺序排列的但是其存储结构为单链表查找结点时只能从头指针开始逐步进行搜索故不能用折半(二分)查找7.10 分析：对二叉排序树来讲其中根遍历序列为一个递增有序序列因此对给定的二叉树进行中根遍历如果始终能保证前一个值比后一个值小则说明该二叉树是二叉排序树int bsbtr (bitreptr T) ／*predt记录当前结点前趋值初值为-∞*／{ if (T==NULL) return(1)；else{b1=bsbtr(T->lchild)；／*判断左子树*／if (!b1|| (predt>=T->data)) return(0)；*当前结点和前趋比较*／ predt=T->data；／*修改当前结点的前趋值*／return(bsbtr(T->rchild))；／*判断右子树并返回最终结果*／}}7.11 (1)使用线性探查再散列法来构造散列表如表下所示散列表───────────────────────────────地址 0 1 2 3 4 5 6 7 8 9 10───────────────────────────────数据 33 1 13 12 34 38 27 22───────────────────────────────（2）使用链地址法来构造散列表如下图(3)装填因子a=8／11使用线性探查再散列法查找成功所需的平均查找次数为Snl=0．5(1+1／(1-a))=0．5*(1+1／(1-8／11))=7／3使用线性探查再散列法查找不成功所需的平均查找次数为：Unl=0．5(1+1／(1-a)2)=0．5*(1+1／(1-8／11)2)=65／9 使用链地址法查找成功所需的平均查找次数为：Snc=l+a／2=1+8／22=15／11使用链地址法查找不成功所需的平均查找次数为： 'Unl=a+e-a=8／1l+e-8／117.12 分析：在等查区间的上、下界处设两个指针由此计算出中间元素的序号当中间元素大于给定值X时接下来到其低端区间去查找；当中间元素小于给定值X时接下来到其高端区间去查找；当中间元素等于给定值X时表示查找成功输出其序号Int binlist(sqtable Aint stkeytype X) ／*t、s分别为查找区间的上、下界*／{ if(s<t) return(0)；／*查找失败*／else{ mid=(S+t)／2；switCh(mid){case x<A.item[midJ.key： return(binlist(Asmid-lX))；／*在低端区间上递归*／case x==A.item[mid].key： return(mid)；／+查找成功*／ case x>A.item[mid].key： return(amid+ltX))；／*在高端区间上递归*／}}}int sqsearch0 (sqtable Akeytype X) /*数组有元素n个*／{ i=l；A.item[n+1].key=X；／t设置哨兵*／while (A.item[n+1].key!=X) i++；return (i% (n／1))；／*找不到返回0找到返回其下标*／}查找成功平均查找长度为：(1+2+3+...+n)／n：(1+n)／2查找不成功平均查找长度为：n+17.14散列函数：H(key)=100+(key个位数+key十位数) mod l0；形成的散列表：100 101 102 103 104 105 106 107 108 10998 75 63 46 49 79 61 53 17查找成功时的平均长度为：(1+2+1+1+5+1+1+5+5+3)/10=2.5次由于长度为10的哈希表已满因此在插人第11个记录时所需作的比较次数的期望值为10查找不成功时的平均长度为10习题 8参考答案8．1 选择题（1）B (2)A (3)D (4)C (5)B (6)A (7)B (8)C (9)A (10)C(11)D (12)C (13) C （14）D （15）C (16)B (17) D （18）C （19）B （20）D8.2填空题（1）快速归并（2） O（log2n）O(nlog2n)（3）归并（4）向上根结点（5） 1918162030（6）（7）4913275076386597（8）88（9）插入选择（每次选择最大的）（10）快速归并(11)O(1)O(nlog2n)(12)稳定(13)3(14)(15205040)(15)O(log2n)(16)O(n2)(17)冒泡排序快速排序(18)完全二叉树n/2(19)稳定不稳定(20)24(2015)8.3. 假定给定含有n个记录的文件(r1f2...rn)其相应的关键字为(k1k2...kn)则排序就是确定文件的一个序列rrr2...rn使得k1'≤k2'≤...≤kn'从而使得文件中n个记录按其对应关键字有序排列如果整个排序过程在内存中进行则排序叫内部排序假设在待排序的文件中存在两个或两个以上的记录具有相同的关键字若采用某种排序方法后使得这些具有相同关键字的记录在排序前后相对次序依然保持不变则认为该排序方法是稳定的否则就认为排序方法是不稳定的8.4．稳定的有：直接插入排序、二分法插入排序、起泡排序、归并排序和直接选择排序8.5．初始记录序列按关键字有序或基本有序时比较次数为最多8.6．设5个元素分别用abcde表示取a与b、c与d进行比较若a>bc>d(也可能是a<bc<d此时情况类似)显然此时进行了两次比较取b与d再比较若b>d则a>b>d若b<d则有c>d>b此时已进行了3次比较要使排序比较最多7次可把另外两个元素按折半检索排序插入到上面所得的有序序列中此时共需要4次比较从而可得算法共只需7次比较8.7．题目中所说的几种排序方法中其排序速度都很快但快速排序、归并排序、基数排序和Shell排序都是在排序结束后才能确定数据元素的全部序列而排序过程中无法知道部分连续位置上的最终元素而堆排序则是每次输出一个堆顶元素(即最大或最少值的元素)然后对堆进行再调整保证堆顶元素总是当前剩下元素的最大或最小的从而可知欲在一个大量数据的文件中如含有15000个元素的记录文件中选取前10个最大的元素可采用堆排序进行8.8．二分法排序8.9．void insertsort(seqlist r)  ；{ ／／对顺序表中记录R[0一N-1)按递增序进行插入排序&NBSP；int ij；  ；for(i=n-2；i>=0; i--) ／／在有序区中依次插入r[n-2]．．r[0]  ；if(r[i].key>r[i+1].key) ／／若不是这样则r[i]原位不动 ；{  ；r[n]=r[i]；j=i+l；／／r[n]是哨兵 ；do{ ／／从左向右在有序区中查找插入位置 ；r[j-1]= r[j]；／／将关键字小于r[i]．key的记录向右移 ；j++；  ；}whle(r[j].key r[j-1]=r[n]；／／将引i)插入到正确位置上 ；}／／endif ；}／／insertsort．  ；8.10．建立初始堆：[937 694 863 265 438 751 742129075 3011]&NBSP；&NBSP；第一次排序重建堆：[863 694 751 765 438 301 742 129 075]9378.11．在排序过程中每次比较会有两种情况出现若整个排序过程至少需作t次比较则显然会有2^t个情况由于n个结点总共有n!种不同的排列因而必须有n!种不同的比较路径于是： 2t≥n!即t≥log2n!因为log2nl=nlog2n-n／ln2+log2n／2+O(1)故有log2n!≈nlog2n从而t≧nlog2n得证8.12．依据堆定义可知：序列(1)、(2)、(4)是堆(3)不是堆从而可对其调整使之为如下的大根堆(1009580604095821020)8.13．第一趟：[265 301] [129 751] [863 937] [694 742] [076 438]&NBSP； &NBSP；第二趟：[129 265 301 751] [694 742 863 937] [076 438]&NBSP；&NBSP；第三趟：[129 265 301 694 742 751 863 937] [076 438]&NBSP；&NBSP；第四趟：[076 129 265 301 438 694 742 751 863 937]&NBSP；8.14．(1)归并排序：(1829) (2547) (1258) (1051)(18252947) (10125158)(1012182529475158)(2)快速排序：(1018251229585147)(1018251229475158)(1012182529475158)(3)堆排序：初始堆(大顶堆)：(58 47512918122510)第一次调整：(51 472529181210)(58)第二次调整：(47 2925101812)(5158)第三次调整：(29 18251012)(475158)第四次调整：(25 181210)(29475158)第五次调整：(18 1012)(2529475158)第六次调整：(12 10) (182529475158)第七次调整：(10 12182529475158)8.15．(1)直接插入排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 151=2 40 83 [63 13 84 35 96 57 39 79 61 15] 1=3 40 63 83 [13 84 35 96 57 39 79 61 15] 1=4 13 40 63 83 [84 3 5 96 57 39 79 61 15] I=5 13 40 63 83 84 [35 96 57 39 79 61 15] I=6 13 35 40 63 83 84 [96 57 39 79 61 15] 1=7 13 35 40 63 83 84 96 [57 39 79 61 15] 1=8 13 35 40 57 63 83 84 96 [ 39 79 61 15] 1=9 13 35 39 40 57 63 83 84 96 [79 61 15] I=10 13 35 39 40 57 63 79 83 84 96 [61 15] I=11 13 35 39 40 57 61 63 79 83 84 96 [15] 1=12 13 15 35 39 40 57 61 63 79 83 84 96 (2)直接选择排序序号 1 2 3 4 5 6 7 8 9 10 11 12 关键字 83 40 63 13 84 35 96 57 39 79 61 15i=1 13 [ 40 63 83 84 35 96 57 39 79 61 15] i=2 13 15 [63 83 84 35 96 57 39 79 61 40] i=3 13 15 35 [83 84 63 96 57 39 79 61 40] i=4 13 15 35 39 [84 63 96 57 83 79 61 40] i=5 13 15 35 39 40 [63 96 57 83 79 61 84] i=6 13 15 35 39 40 57 [96 63 83 79 61 84] i=7 13 15 35 39 40 57 61 [63 83 79 96 84] i=8 13 15 35 39 40 57 61 63 [83 79 96 84] i=9 13 15 35 39 40 57 61 63 79 183 96 84] i=10 13 15 35 39 40 57 61 63 79 83 [96 84] i=11 13 15 35 39 40 57 61 63 79 83 84 [96] (3)快速排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [15 40 63 13 61 35 79 57 39] 83 [96 84] 第二趟排序后 [13] 15 [63 40 61 35 79 57 39] 83 84 [96] 第三趟排序后 13 15 [39 40 61 35 57] 63 [79] 83 84 96 第四趟排序后 13 15 [35] 39 [61 40 57] 63 79 83 84 96第五趟排序后 13 15 35 39 [57 40] 61 63 79 83 84 96 第六趟排序后 13 15 35 39 40 [57] 61 63 79 83 84 96 第七趟排序后 13 15 35 39 40 57 61 63 79 83 84 96 (4)堆排序关键字 83 40 63 13 84 35 96 57 39 79 61 15排序成功的序列 96 84 83 79 63 61 57 40 39 35 15 13(5)归并排序关键字 83 40 63 13 84 35 96 57 39 79 61 15 第一趟排序后 [40 83] [13 63] [3584] [57 96] [39 79] [15 61]第二趟排序后 [13 40 63 83] [35 57 84 96] [15 39 61 79] 第三趟排序后 [13 35 40 57 63 83 84 96]] [15 39 61 79] 第四趟排序后 13 15 35 39 40 57 61 63 79 83 84 96。
数据结构---C语言描述-(耿国华)-课后习题答案
第一章习题答案2、××√3、（1）包含改变量定义的最小范围（2）数据抽象、信息隐蔽（3）数据对象、对象间的关系、一组处理数据的操作（4）指针类型（5）集合结构、线性结构、树形结构、图状结构（6）顺序存储、非顺序存储（7）一对一、一对多、多对多（8）一系列的操作（9）有限性、输入、可行性4、（1）A（2）C（3）C5、语句频度为1+（1+2）+（1+2+3）+…+（1+2+3+…+n）第二章习题答案1、（1）一半，插入、删除的位置（2）顺序和链式，显示，隐式（3）一定，不一定（4）头指针，头结点的指针域，其前驱的指针域2、（1）A（2）A：E、AB：H、L、I、E、AC：F、MD：L、J、A、G或J、A、G（3）D（4）D（5）C（6）A、C3、头指针：指向整个链表首地址的指针，标示着整个单链表的开始。
头结点：为了操作方便，可以在单链表的第一个结点之前附设一个结点，该结点的数据域可以存储一些关于线性表长度的附加信息，也可以什么都不存。
首元素结点：线性表中的第一个结点成为首元素结点。
4、算法如下：int Linser(SeqList *L,int X){ int i=0,k;if(L->last>=MAXSIZE-1){ printf(“表已满无法插入”)；return(0);}while(i<=L->last&&L->elem[i]<X)i++;for(k=L->last;k>=I;k--)L->elem[k+1]=L->elem[k];L->elem[i]=X;L->last++;return(1);}5、算法如下：#define OK 1#define ERROR 0Int LDel(Seqlist *L,int i,int k){ int j;if(i<1||(i+k)>(L->last+2)){ printf(“输入的i，k值不合法”);return ERROR;}if((i+k)==(L->last+2)){ L->last=i-2;ruturn OK;}else{for(j=i+k-1;j<=L->last;j++)elem[j-k]=elem[j];L->last=L->last-k;return OK;}}6、算法如下：#define OK 1#define ERROR 0Int Delet(LInkList L,int mink,int maxk){ Node *p,*q;p=L;while(p->next!=NULL)p=p->next;if(mink<maxk||(L->next->data>=mink)||(p->data<=maxk)) { printf(“参数不合法”);return ERROR;}else{ p=L;while(p->next-data<=mink)p=p->next;while(q->data<maxk){ p->next=q->next;free(q);q=p->next;}return OK;}}9、算法如下：int Dele(Node *S){ Node *p;P=s->next;If(p= =s){printf(“只有一个结点，不删除”)；return 0;}else{if((p->next= =s){s->next=s;free(p);return 1;}Else{ while(p->next->next!=s)P=p->next;P->next=s;Free(p);return 1;}}}第三章习题答案2、（1）3、栈有顺序栈和链栈两种存储结构。
《数据结构》课后习题答案(第2版)
1 填空题（1）数据元素（2）数据项数据元素（3）集合线性结构树结构图结构（4）顺序存储链接存储数据元素数据元素之间的关系（5）零或多个输入一个或多个输出有穷性确定性可行性（6）自然语言程序设计语言流程图伪代码，伪代码（7）问题规模（8）O(1) O(nlog2n)2 选择题（1）C D (2)B (3) B (4) A (5) D (6)A (7) C (8) C E3 判断题×××√×第二章1 填空题（1）表长一半表长位置（2）108（3）p->next=(p->next)->next;（4）运算方便（5）p->next=head;（6）s->next=rear->next rear->next=s; rear=s;q=rear->next->next; rear->next->next=q->next; delete q;（7）O(1) O(n)（8）循环单链表循环双链表双链表2 选择题（1） A B （2） D （3） B （4） A （5） A （6） D（7） B（8） B（9） C（10）B（11）B（12）D（13）A（14）A3 判断题×××××1 填空题（1）1003H（2）顺序栈和链栈top=-1或top==NULL top==数组长度或内存无可用空间（3）栈（4）abc+*d-（5）后进先出先进先出操作位置受限（6）假溢出（7）（rear-front+n）% n（8）O(1) O(n)2 选择题（1） C （2） D （3） C （4） B（5） B（6） B（7） D（8） A（9） C3 判断题×√√××第四章1 填空题（1）数据元素的类型是字符（2）长度相等且对应位置字符相等（3）存取修改顺序存储（4）1140（5）d+41（6）三元组顺序表十字链表2 选择题（1） B （2） D E K （3） B （4） C（5） D（6） C（7） D3 判断题×√√××1 填空题（1）有且仅有一个互不相交（2）度孩子双亲（3）2i-1(n+1)/2 （n-1）/2 （4）2h-1 2h-1（5）2k-1（6）50（7）12（8）CDBGFEA （9）2n n-1 n+1 （10）n n-12 选择题（1） D （2） D （3） B （4） C （5） B C （6） D（7） A（8） A B（9） D A（10）B（11）B（12）C（13）D（14）C3 判断题×√×√×第六章1 填空题（1）0 n(n-1)/2 0 n(n-1) （2）自身（3）邻接矩阵邻接表（4）O(n+e)（5）第j列所有元素之和（6）出度（7）前序栈层序队列（8）O(n2) O(elog2e) （9）回路（10）v i v j v k2 选择题（1） c （2） A G （3） C （4） B （5） D （6） C F（7） B（8） D（9） A（10）A（11）A（12）C（13）A（14）C C F（15）B3 判断题√√××××√×1 填空题（1）顺序存储和链接存储顺序存储按照关键码有序（2） 1 ，7（3）8，59/15（4） 4（5）62（6）开放定址法拉链法（7）散列查找（8）通过关键码计算记录的存储地址并进行一定的比较2 选择题（1） B （2） D B （3） A D （4） D （5） A（6） C（7） C（8） B（9） D（10）A（11）C（12）D3 判断题×××××第八章1 填空题（1）查找（2）正序n-1 反序n(n-1)/2 （3） 3（4） 3（5）O(nlog2n) O(n)（6）n-1（7）50（8）602 选择题（1） C （2） C （3） C （4） B （5） A （6） A（7） B C B（8） C（9） D（10）A D（11）B（12）D,B,E,A,C（13）C,A,D,B,B,D,F（14）C（15）D3 判断题×√××√。
数据结构课后习题答案-完整版
数据结构课后习题答案-完整版下面是《数据结构课后习题答案-完整版》的内容：---第一章：数组1. 题目：给定一个整数数组，判断是否存在两个元素之和等于目标值。
答案：使用双指针法，首先将数组排序，然后设置左指针指向数组头部，右指针指向数组尾部。
如果左指针和右指针指向的元素之和小于目标值，则左指针右移；如果大于目标值，则右指针左移；如果等于目标值，则找到了两个元素之和等于目标值的情况。
2. 题目：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数的下标。
答案：使用哈希表，在遍历数组的过程中，将每个元素的值和下标存储在哈希表中。
遍历到当前元素时，检查目标值与当前元素的差值是否在哈希表中，如果存在，则找到了两个数的下标。
---第二章：链表1. 题目：给定一个链表，判断链表中是否存在环。
答案：使用快慢指针法，定义两个指针，一个指针每次向前移动一个节点，另一个指针每次向前移动两个节点。
如果存在环，则两个指针必定会相遇。
2. 题目：给定一个链表，删除链表的倒数第N个节点。
答案：使用双指针法，定义两个指针，一个指针先移动N个节点，然后两个指针同时向前移动，直到第一个指针到达链表尾部。
此时第二个指针指向的节点即为要删除的节点。
---第三章：栈和队列1. 题目：设计一个栈，使得可以在常数时间内获取栈中的最小元素。
答案：使用辅助栈来保存当前栈中的最小元素。
每次压栈操作时，将当前元素与辅助栈的栈顶元素比较，只有当前元素较小才将其压入辅助栈。
2. 题目：设计一个队列，使得可以在常数时间内获取队列中的最大元素。
答案：使用双端队列来保存当前队列中的最大值。
每次入队操作时，将当前元素与双端队列的末尾元素比较，只有当前元素较大才将其压入双端队列。
---第四章：树和二叉树1. 题目：给定一个二叉树，判断它是否是平衡二叉树。
答案：通过递归遍历二叉树的每个节点，计算每个节点的左子树高度和右子树高度的差值。
如果任意节点的差值大于1，则该二叉树不是平衡二叉树。
《数据结构》第二版严蔚敏课后习题作业参考答案(1-7章)
第1章4．答案：（1）顺序存储结构顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。
（2）链式存储结构顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。
但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。
所以链式存储结构通常借助于程序设计语言的指针类型来描述。
5. 选择题(1)~(6)：CCBDDA\6．（1）O(1) （2）O(m*n) （3）O(n2)（4）O(log3n) （5）O(n2) （6）O(n)（第2章1．选择题（1）~（5）：BABAD （6）~（10）： BCABD （11）~（15）：CDDAC\2．算法设计题（1）将两个递增的有序链表合并为一个递增的有序链表。
要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。
表中不允许有重复的数据。
[题目分析]合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。
如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。
当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){法设计题（1）将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。
当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。
两个栈均从两端向中间增长。
试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。
数据结构课后习题部分参考答案
数据结构课后习题部分参考答案第一章一、选择题1．C 2．C 3．A 4．D 5．B二、判断题1．╳2．╳ 3．╳ 4．╳5．∨三、简答题1．常见逻辑结构：集合结构，数据元素之间的关系仅仅是属于同一个集合。
线性结构，除第一个元素只有一个直接后继、最后一个元素只有一个直接前驱，其余元素有且只有唯一一个直接前驱、有且只有唯一一个直接后继，数据元素之间存在一对一的关系。
树形结构，树中只有唯一一个根元素，除根元素之外，其余元素只有一个直接前驱，但可以有多个直接后继元素，数据元素之间存在一对多的关系。
图形结构，元素之间关系任意，数据元素之间存在多对多的关系。
常用的存储结构：顺序存储，把逻辑上相邻的元素存储在物理位置相邻的存储单元中，由此得到的存储表示称为顺序存储结构。
通常用数组实现。
链式存储，对逻辑上相邻的元素不要求其物理位置相邻，元素间的逻辑关系通过附加的指针字段来表示，由此得到的存储表示称为链式存储结构。
通常用指针来实现。
除上述两种方法外，有时为了查找方便还采用索引存储方法和散列存储方法。
索引存储：在存储结点信息的同时，还建立附加的索引表来标识结点的地址。
散列存储：根据元素的关键码确定元素存储位置的存储方式。
2．算法与程序的区别：程序不一定满足有穷性(如操作系统)；程序中的指令必须是机器可执行的，算法中的指令则无此限制；算法代表了对问题的解，程序则是算法在计算机上的特定的实现(一个算法若用程序设计语言来描述，它才是一个程序);数据结构+算法=程序。
3．例如有一张学生成绩表，记录了一个班的学生各门课的成绩。
按学生的姓名为一行记成的表。
这个表就是一个数据结构。
每个记录就是一个结点，对于整个表来说，只有一个开始结点和一个终端结点，其他的结点则各有一个也只有一个直接前趋和直接后继。
这几个关系就确定了这个表的逻辑结构——线形结构。
那么我们怎样把这个表中的数据存储到里呢? 用高级语言如何表示各结点之间的关系呢? 是用一片连续的内存单元来存放这些记录（顺序存储）还是随机存放各结点数据再用指针进行链接（链式存储）呢? 这就是存储结构的问题，我们都是从高级语言的层次来讨论这个问题的。
(完整版)数据结构课后习题答案
第1章绪论1 •简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。
答案：数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。
如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。
数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。
在有些情况下，数据元素也称为元素、结点、记录等。
数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。
数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。
例如，学生基本信息表中的学号、姓名、性别等都是数据项。
数据对象：是性质相同的数据元素的集合，是数据的一个子集。
例如：整数数据对象是集合N={0，士1，士2,…}，字母字符数据对象是集合C={ ‘ A', ‘ B…，‘ Z，‘ a'b '，…，‘ z ' }，学生基本信息表也可是一个数据对象。
数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。
逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。
因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
存储结构：数据对象在计算机中的存储表示，也称为物理结构。
抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。
具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。
2 •试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。
答案：例如有一张学生基本信息表，包括学生的学号、姓名、性别、籍贯、专业等。
每个学生基本信息记录对应一个数据元素，学生记录按顺序号排列，形成了学生基本信息记录的线性序列。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
习题11．解释以下概念：逻辑结构，存储结构，操作，数据结构，数据结构的表示，数据结构的实现，抽象数据类型，算法，算法的时间代价，算法的空间代价，大O 表示法。
2．理解以下关系：算法与数据结构的关系；数据结构与抽象数据类型的关系；算法和数据结构与问题求解的关系。
3. 写出下列程序段的平均情况下的时间代价O表示式。
(1) a=b+c;d=a+e(2) sum=0;for (i=0;i<3;i++)for (j=0;j<n;j++)sum++;(3) x=n;y=0;while (x>=(y+1)*(y+1))y++;(4) s=0;if(even(n))for (i=0;i<n;i++)sum++;elses=s+n;(5) x=66;n=200;while (n>0){if(x>lO0){ x=x-10;n=n-1;}elsex=x+1;}4．对于给定的n个元素，可以构造出的逻辑结构有，，，四种。
5.按增长率由小到大的顺序排列下列各函数：2100, (32)n, (23)n, (43)n, n n, n32, n!, n, log2n, n/log2n习题22.1已知L是无头结点的单链表，且p结点既不是第一个结点，也不是最后一个结点，试从下列提供的语句中选出合适的语句序列：(1)在p结点之后插入s结点：(2)在p结点之前插入s结点：(3)在单链表L首插入s结点：(4)在单链表L后插入s结点：提供的语句：①p->next＝s；②p->next＝p->next->next；③p->next=s->next；④s->next=p->next；⑤s->next＝L；⑥s->next=p；⑦s->next=NULL；⑧q＝p；⑨while(p->next!=q)p=p->next；⑩while(p->next!=NULL)p=p->next；⑾p=q；⑿p=L；⒀L＝s；⒁L＝p；2.2已知p结点是某双向链表的中间结点，试从下列提供的语句中选出合适的语句序列。
(1)在p结点之后插入s结点：(2)在p结点之前插入s结点：(3)删除p结点的直接后继结点：(4)删除p结点的直接前驱结点：提供的语句：①p->next＝p->next->next；②p->prior=p->prior->prior；③p->next=s；④p->prior=s；⑤s->next=p；⑥s->prior＝p；⑦s->next=p->next；⑧s->prior=p->prior；⑨p->prior->next=p->next；⑩p->prior->next＝p；⑾p->next->prior＝p；⑿p->next->prior＝s；⒀p->prior->next=s；⒁p->next->prior=p->prior；⒂q=p->next；⒃q=p->prior；⒄free(p)；⒅free(q)；2.3试编写一个计算头结点指针为L的单链表长度的算法。
2.4试编写一个将单循环链表逆置的算法。
2.5已知一顺序表A，其元素值非递减有序排列，编写一个算法，删除顺序表中多余的值相同的元素。
习题33.1 简述栈和线性表的区别。
简述栈和队列的相同点和不同点。
3.2 如果进栈的数据元素序列为1、2、3、4、5、6，能否得到4、3、5、6、1、2和1、3、5、4、2、6的出栈序列?并说明为什么得不到或如何得到。
3.3 利用两个栈模拟一个队列的入队、出队和判断队列空的运算。
3.4 写一算法，将一个顺序栈中的元素依次取出，并打印元素值。
3.5 写一算法，将一个非负十进制整数转换成二进制。
3.6 写一算法，将一个链式队列中的元素依次取出，并打印元素值。
3.7 设有编号为1、2、3、4的4辆车，顺序进入一个栈式结构的站台，试写出这4辆车开出站台的所有可能的顺序。
3.8 写一个算法，借助于栈将一个单链表逆置。
习题44.1 空串和空格串有什么区别?4.2 两个字符串相等的充要条件是什么?4.3 串的三种机内表示方法是什么?4.4 设S＝'I am a student'，T＝'good'，Q＝'worker'。
求：(1)StrLength(S)(2)SubString(&Sub，S，8，7)(3)SubString(&Sub，T，2，1)(4)Index(S，'a'，1)(5)Index(S，T，1)(6)Replace(&S，'Student'，Q)(7)Concat(&N，SubString(&V，S，6，2)，Concat(&P，T，SubString(&W,S,7,8)))4.5 设A＝'This'，F＝'a sample'，C＝'good'，D＝'ne'，B＝' '，G＝'is'。
求：(1)Coneat(&S，A，Concat(&Z，SubString(&Y，F，2，7)，Concat(&X，B，SubString(A，3，2))))(2)Concat(&U，SubString(&X，C，3，1)，D)(3) Replace(&F，SubString(&X，F，3，6)，C)(4)StrLength(S)(5)Index(V，G，1)(6)Index(U，G，1)(7) Concat(&V，S，Concat(&Z，B，Concat(&Y，F，Concat(&X，B，U))))4.6 利用C的库函数strlen、strcpy(或strcat)写一个算法voidStrDelete(char *S,int i,int m)，删除串S中从位置i开始连续的m个字符。
若i≥strlen(S)，则没有字符被删除；若i+m≥strlen(S)，则S中从位置i开始直至末尾的字符均被删去.。
4.7 采用顺序结构存储串，编写一个函数，求串s和串t的一个最长的公共子串。
提示: 需要采用三重循环来实现。
习题51.假设按行优先存储整数数组A[9][3][5][8]时，第一个元素的字节地址是100，每个整数占4个字节。
问下列元素的存储地址是什么?(1) a0000 (2) a1111 (3) a3125 (4) a82472.假设一个准对角矩阵按以下方式存储于一维数组B[4m]中：写出由一对下标(i,j) 求k的转换公式。
3.现有如下的稀疏矩阵A，要求画出三元组表示法。
习题610. 假设用于通讯的电文仅由8个字母组成，字母在电文中出现的频率分别为7，19，2，6，32，3，21，10。
试为这8个字母设计赫夫曼编码。
使用0～7的二进制表示形式是另一种编码方案。
对于上述实例，比较两种方案的优缺点。
11．一棵度为2的树与一棵二叉树有何区别?树与二叉树之间有何区别?12．对于如图所示的树，试给出：(1)双亲数组表示法示意图；(2)孩子链表表示法示意图；(3)孩子兄弟链表表示法示意图。
13．画出下图所示的森林经转换后所对应的二叉树，并指出在二叉链表中某结点所对应的森林中结点为叶子结点的条件。
14．将如图所示的二叉树转换成相应的森林。
15．在具有n(n>1)个结点的各棵树中，其中深度最小的那棵树的深度是多少?它共有多少叶子和非叶子结点?其中深度最大的那棵树的深度是多少?它共有多少叶子和非叶子结点?16．画出和下列已知序列对应的树T：树的先根访问序列为：GFKDAIEBCHJ；树的后根访问序列为：DIAEKFCJHBG。
17．画出和下列已知序列对应的森林F：森林的先序访问序列为：ABCDEFGHIJKL；森林的中序访问序列为：CBEFDGAJIKLH。
18．对以孩子－兄弟链表表示的树编写计算树的深度的算法。
习题71 对于右图所示的有向图，试给出：(1)每个顶点的入度和出度。
(2)邻接矩阵。
(3)邻接表。
(4)逆邻接表。
(5)强连通分量。
2 设无向图G如右图所示，试给出：(1)该图的邻接矩阵。
(2)该图的邻接表。
(3)该图的多重邻接表。
(4)从v0出发的“深度优先”遍历序列。
(5)从v0出发的“广度优先”遍历序列。
3请对下边的无向带权图，(1)写出它的邻接矩阵，并按普里姆算法求其最小生成树；(2)写出它的邻接表，并按克鲁斯卡尔算法求其最小生成树。
4 对下图所示的带权有向图G，试回答以下问题：(1)求出G中从结点v1出发按深度优先搜索遍历G所得到结点序列；(2)求出G中从结点v1出发按广度优先搜索遍历G所得的结点序列；5 对于下图所示的带权图(1)按照普里姆算法，从顶点v1出发生成最小生成树，按生成次序写出各条边；(2)按照克鲁斯卡尔算法，生成最小生成树，按生成次序写出各条边；(3)画出其最小生成树，并求出它的权值。
6 写出下图所示的AOV网的全部可能的拓扑有序序列。
7 对下图所示的带权有向图G，试回答以下问题：(1)写出其带权邻接矩阵arcs；(2)求出从顶点v1到其他各顶点之间的最短路径。