数据结构 耿国华 西北大学 5-1数组定义与数组的顺序存储
数据结构 耿国华 西北大学 1-5数据结构与C语言表示
viod swap2(int *a,int *b) { int c;
c=*a; *a=*b; *b=c; } viod main() { int x=100,y=800;
多个函数结果需带出时可选择如下方式： (1)全局变量方式：函数内给全局变量赋值，其值自
然带出。 (2)数组方式：同类的多个值，可放入一个数组，返
回数组指针或首地址即可。 (3)结构体方式：不同类的多个值，可放入一个结构
体，返回结构体指针或变量即可。 (注意:该结构体类型应全局有效)12
(4)指针方式：通过多个指针参数传地址。 返回
第 1 章 绪论
1.5 数据结构与C语言表示
面向对象和抽象数据类型
面向对象的概念
面向对象=对象+类+继承+通信
对象：是指在应用问题中出现的各种实体、事件和规格说
明等，它是由一组属性和在这组值上的一组服务构成的，
其中属性值确定了对象的状态。
类：把具有相同属性和服务的对象归到同一类,而把一个
类中的每一个对象称为该类的一个实例,它们具有相同的
ADT <ADT名>
{ 数据对象:<数据对象的定义> 结构关系:<结构关系的定义> 基本操作:<基本操作的定义>
}ADT <ADT名>
基本操作的定义格式为：
<操作名称> (参数表)
操作前提:<操作前提描述>
5
操作结果:<操作结果描述>
第5章 数据结构C语言描述(耿国华)
r
n m
k－1
图5.5 三维数组看成r个m×n的二维数组
j－1
第5章 数组和广义表 假定每个元素占一个存储单元，采用以行为主序的方法存 放，即行下标r变化最慢， 纵下标n变化最快。 首元素a111的地
址为Loc［1, 1, 1］，求任意元素aijk的地址。
显 然 ， ai11 的 地 址 为 Loc ［ i, 1, 1 ］ =Loc ［ 1, 1, 1 ］ +(i1)×m×n， 因为在该元素之前， 有ｉ-１个ｍ×ｎ的二维数组。 由ai11的地址和二维数组的地址计算公式，不难得到三维数组任 意元素aijk的地址：
第5章 数组和广义表 假设有一个3×4×2的三维数组A ，共有24个元素，其 逻辑结构如图5.4所示。
纵
a112 a122
a132
a142
24 34 2 2
列 行
a211 a311
a221 a321
a231 a331
a241 a341
图5.4 三维数组的逻辑结构图
a
a111 a121
a131
a141
矩阵；若矩阵中的所有元素均满足aij=aji ，则称此矩阵为对称 矩阵。
图5.6 下三角矩阵A
第5章 数组和广义表 对于下三角矩阵的压缩存储，我们只存储下三角的非零 元素，对于零元素则不存。我们按“行序为主序”进行存储，
得到的序列是a11, a21, a22, a31, a32, a33, …, an1, an2, …, ann。由于下
同样，对于上三角矩阵，也可以将其压缩存储到一个大小 为n(n+1)/2的一维数组C中。其中元素aij(i<j)在数组C中的存储位 置为： Loc［i, j］=Loc［1, 1］+j(j-1)/2+i-1
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案
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)
ve(6)=16, ve(7)=19, ve(8)=21, ve(9)=23 每个事件的最晚发生时间:： vl(9)=23, vl(8)=21, vl(7)=19, vl(6)=19, vl(5)=16, vl(4)=15, vl(3)=12, vl(2)=6, vl(1)=9, vl(0)=0 （2）每个活动的最早开始时间： e(0,1)=0, e(0,2)=0, e(1,3)=5, e(2,3)=6, e(2,4)=6, e(3,4)=12, e(3,5)=12, e(4,5)=15, e(3,6)=12, e(5,8)=16, e(4,7)=15, e(7,8)=19, e(6,9)=16, e(8,9)=21 每个活动的最迟开始时间： l(0,1)=4, l(0,2)=0, l(1,3)=9, l(2,3)=6, l(2,4)=12, l(3,4)=12, l(3,5)=12, l(4,5)=15, l(3,6ห้องสมุดไป่ตู้=15, l(5,8)=16, l(4,7)=15, l(7,8)=19, l(6,9)=19, l(8,9)=21 （3）关键路径如下图所示：
数据结构——C语言描述习题及答案 耿国华
第1章绪论习题一、问答题1.什么是数据结构？2.四类基本数据结构的名称与含义。
3.算法的定义与特性。
4.算法的时间复杂度。
5.数据类型的概念。
6.线性结构与非线性结构的差别。
7.面向对象程序设计语言的特点。
8.在面向对象程序设计中，类的作用是什么？9.参数传递的主要方式及特点。
10.抽象数据类型的概念。
二、判断题1.线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
2.算法就是程序。
3.在高级语言（如C、或 PASCAL）中，指针类型是原子类型。
三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时： 1 = (1+1)×1/2 = (1+12)/2i=2时： 1+2= (1+2)×2/2 = (2+22)/2i=3时： 1+2+3= (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n= (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2=[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能的小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n), x和n，输出为P n(x0).通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递。
数据结构课后习题答案(耿国华版
第1章绪论2 、(1)×(2)×(3) √3 、(1)A(2)C(3)C5、f or计(算i=下1n程;序中 1 得语句频度for(j=1;j<=i; j++)for(k=1;k<=j;k ++)x=x+1;【解答】 x=x+1 得语句频度为：T(n)=1+(1+2)+(1+2+3)+. …+(1+2+……+n)=n(n+1)(n+2)/66 、编写算法，求一元多项式p。
(x)=a。
+a,x+a₂X2+……、+a Xn得值p(x) 并确定算法中每一语句得执行次数与整个算法得时间复杂度，要求时间复杂度尽可能小，规定算法中不能使用求幂函数.注意：本题中得输入为a,(i=01,…n)、x 与n,输出为P。
(x)。
算法得输入与输出采用下列方法(1)通过参数表中得参数显式传递(2)通过全局变量隐式传递。
讨论两种方法得优缺点，并在算法中以您认为较好得一种实现输入输出.【解答】(1)通过参数表中得参数显式传递优点：当没有调用函数时，不占用内存，调用结束后形参被释放，实参维持，函数通用性强，移置性强。
缺点：形参须与实参对应，且返回值数量有限。
(2)通过全局变量隐式传递优点：减少实参预形参得个数，从而减少内存空间以及传递数据时得时间消耗缺点：函数通用性降低，移植性差算法如下：通过全局变量隐式传递参数PolyValue({ int,in;floatx,a[]p;pri n tf(hn=”);s c anf(“%f,”&n);printf(“x=”;)sca nf(“%f&x);f or(i=0;i<n; i++)s c anf(%f ,&a[i]; /*执行次数：n 次 */p=a[0];for (i=1;i<=n;i++){ p=p+a [i]*x; /*执行次数：n次*/x= x*x;}prin t f(%f” p);}算法得时间复杂度：T(n)=0(n)通过参数表中得参数显式传递f loat PolyVa lue(float a[ ], float x, i nt n)f 1 oat p, s;int;is p a X0];for(=1;i<= n;i++)/执行次数：n 次*/{s=s+a [i]* p;p=p*x;}re turn(p);算法得时间复杂度：T(n)=O(n)第2章线性表习题1、填空：(1)在顺序表中插入或者删除一个元素，需要平均挪移一半元素，具体挪移得元素个数与插入或者删除得位置有关。
《数据结构——C语言描述》习题及答案 耿国华
第1章绪论之邯郸勺丸创作习题一、问答题1. 什么是数据结构？2. 四类基本数据结构的名称与含义.3. 算法的定义与特性.4. 算法的时间庞杂度.5. 数据类型的概念.6. 线性结构与非线性结构的不同.7. 面向对象程序设计语言的特点.8. 在面向对象程序设计中,类的作用是什么？9. 参数传递的主要方法及特点.10. 抽象数据类型的概念.二、判断题1. 线性结构只能用顺序结构来存放,非线性结构只能用非顺序结构来存放.2. 算法就是程序.3. 在初级语言（如C、或 PASCAL）中,指针类型是原子类型.三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时：1 = (1+1)×1/2 = (1+12)/2i=2时：1+2 = (1+2)×2/2 = (2+22)/2i=3时：1+2+3 = (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n = (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2=[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法庞杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…anxn的值Pn(x0),并确定算法中的每一语句的执行次数和整个算法的时间庞杂度,要求时间庞杂度尽可能的小,规定算法中不克不及使用求幂函数.注意：本题中的输入ai(i=0,1,…,n), x和n,输出为Pn(x0).通常算法的输入和输出可采取下列两种方法之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递.试讨论这两种办法的优缺点,并在本题算法中以你认为较好的一种方法实现输入和输出.[提示]：float PolyValue(float a[ ], float x, int n) {……}核心语句：p=1; (x的零次幂)s=0;i从0到n循环s=s+a[i]*p;p=p*x;或：p=x; (x的一次幂)s=a[0];i从1到n循环s=s+a[i]*p;p=p*x;实习题设计实现抽象数据类型“有理数”.基本操纵包含有理数的加法、减法、乘法、除法,以及求有理数的份子、分母.第一章答案1.3计算下列程序中x=x+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;【解答】x=x+1的语句频度为：T(n)=1+(1+2)+（1+2+3）+……+（1+2+……+n）=n(n+1)(n+2)/61.4试编写算法,求p n(x)=a0+a1x+a2x2+…….+anxn的值pn(x0),并确定算法中每一语句的执行次数和整个算法的时间庞杂度,要求时间庞杂度尽可能小,规定算法中不克不及使用求幂函数.注意：本题中的输入为ai(i=0,1,…n)、x和n,输出为Pn(x0).算法的输入和输出采取下列办法（1）通过参数表中的参数显式传递（2）通过全局变量隐式传递.讨论两种办法的优缺点,并在算法中以你认为较好的一种实现输入输出.【解答】（1）通过参数表中的参数显式传递优点：当没有调用函数时,不占用内存,调用结束后形参被释放,实参维持,函数通用性强,移置性强.缺点：形参须与实参对应,且前往值数量有限.（2）通过全局变量隐式传递优点：减少实介入形参的个数,从而减少内存空间以及传递数据时的时间消耗缺点：函数通用性降低,移植性差算法如下：通过全局变量隐式传递参数PolyValue(){ int i,n;float x,a[],p;printf(“\nn=”);scanf(“%f”,&n);printf(“\nx=”);scanf(“%f”,&x);for(i=0;i<n;i++)scanf(“%f”,&a[i]); /*执行次数：n次 */p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x; /*执行次数：n次*/ x=x*x;}printf(“%f”,p);}算法的时间庞杂度：T(n)=O(n)通过参数表中的参数显式传递float PolyValue(float a[ ], float x, int n){float p,s;int i;p=x;s=a[0];for(i=1;i<=n;i++){s=s+a[i]*p; /*执行次数:n次*/p=p*x;}return(p);}算法的时间庞杂度：T(n)=O(n)第2章线性表习题2.1 描述以下三个概念的区别：头指针,头结点,首元素结点. 2.2 填空：（1）在顺序表中拔出或删除一个元素,需要平均移动＿＿一半＿＿元素,具体移动的元素个数与＿＿拔出或删除的位置＿＿有关.（2）在顺序表中,逻辑上相邻的元素,其物理位置＿＿＿＿＿＿相邻.在单链表中,逻辑上相邻的元素,其物理位置＿＿＿＿＿＿相邻.（3）在带头结点的非空单链表中,头结点的存储位置由＿＿＿＿＿＿指示,首元素结点的存储位置由＿＿＿＿＿＿指示,除首元素结点外,其它任一元素结点的存储位置由＿＿其直接前趋的next域＿＿指示.2.3 已知L是无表头结点的单链表,且P结点既不是首元素结点,也不是尾元素结点.按要求从下列语句中选择合适的语句序列.a. 在P结点后拔出S结点的语句序列是：＿（4）、（1）＿.b. 在P结点前拔出S结点的语句序列是：（7）、（11）、（8）、（4）、（1）.c. 在表首拔出S结点的语句序列是：（5）、（12）.d. 在表尾拔出S结点的语句序列是：（11）、（9）、（1）、（6）.供选择的语句有：（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;2.4 已知线性表L递增有序.试写一算法,将X拔出到L的适当位置上,以坚持线性表L的有序性.[提示]：void insert(SeqList *L; ElemType x)< 办法1 >（1）找出应拔出位置i,（2）移位,（3）……< 办法2 > 参P. 2292.5 写一算法,从顺序表中删除自第i个元素开始的k个元素.[提示]：注意检查i和k的合法性.（集体搬家,“新房”、“旧房”）< 办法1 > 以待移动元素下标m（“旧房号”）为中心,计算应移入位置（“新房号”）：for ( m= i－1+k; m<= L－>last; m++)L－>elem[ m－k ] = L－>elem[ m ];< 办法2 > 同时以待移动元素下标m和应移入位置j为中心：< 办法3 > 以应移入位置j为中心,计算待移动元素下标：2.6已知线性表中的元素（整数）以值递增有序排列,并以单链表作存储结构.试写一高效算法,删除表中所有大于mink且小于maxk的元素（若表中存在这样的元素）,阐发你的算法的时间庞杂度（注意：mink和maxk是给定的两个参变量,它们的值为任意的整数）.[提示]：注意检查mink和maxk的合法性：mink < maxk不要一个一个的删除（多次修改next域）.（1）找到第一个应删结点的前驱prepre=L; p=L－>next;while (p!=NULL && p－>data <= mink){ pre=p; p=p－>next; }（2）找到最后一个应删结点的后继s,边找边释放应删结点s=p;while (s!=NULL && s－>data < maxk){ t =s; s=s－>next; free(t); }（3）pre－>next = s;2.7试辨别以不合的存储结构实现线性表的就地逆置算法,即在原表的存储空间将线性表（a1, a2..., an）逆置为（an, an-1,..., a1）.（1）以一维数组作存储结构,设线性表存于a(1:arrsize)的前elenum个份量中.（2）以单链表作存储结构.[办法1]：在原头结点后重新头插一遍[办法2]：可设三个同步移动的指针p, q, r,将q的后继r改成p2.8 假设两个按元素值递增有序排列的线性表A和B,均以单链表作为存储结构,请编写算法,将A表和B表归并成一个按元素值递减有序的排列的线性表C,并要求利用原表（即A表和B表的）结点空间存放表C.[提示]：参P.28 例2-1< 办法1 >void merge(LinkList A; LinkList B; LinkList *C){ ……pa=A－>next; pb=B－>next;*C=A; (*C)－>next=NULL;while ( pa!=NULL && pb!=NULL ){if ( pa－>data <= pb－>data ){smaller=pa; pa=pa－>next;smaller－>next = (*C)－>next; /* 头插法 */(*C)－>next = smaller;}else{smaller=pb; pb=pb－>next;smaller－>next = (*C)－>next;(*C)－>next = smaller;}}while ( pa!=NULL){smaller=pa; pa=pa－>next;smaller－>next = (*C)－>next;(*C)－>next = smaller;}while ( pb!=NULL){smaller=pb; pb=pb－>next;smaller－>next = (*C)－>next;(*C)－>next = smaller;}< 办法2 >LinkList merge(LinkList A; LinkList B){ ……LinkList C；pa=A－>next; pb=B－>next;C=A; C－>next=NULL;…………return C;2.9 假设有一个循环链表的长度大于1,且表中既无头结点也无头指针.已知s为指向链表某个结点的指针,试编写算法在链表中删除指针s所指结点的前趋结点.[提示]：设指针p指向s结点的前趋的前趋,则p与s有何关系？2.10 已知有单链表暗示的线性表中含有三类字符的数据元素（如字母字符、数字字符和其它字符）,试编写算法来机关三个以循环链表暗示的线性表,使每个表中只含同一类的字符,且利用原表中的结点空间作为这三个表的结点空间,头结点可另辟空间.2.11 设线性表A=(a1, a2,…,am),B=(b1, b2,…,bn),试写一个按下列规则合并A、B为线性表C的算法,使得：C= (a1, b1,…,am, bm, bm+1, …,bn)当m≤n时；或者C= (a1, b1,…,an, bn, an+1, …,am) 当m>n时.线性表A、B、C均以单链表作为存储结构,且C表利用A表和B表中的结点空间组成.注意：单链表的长度值m和n均未显式存储.[提示]：void merge(LinkList A; LinkList B; LinkList *C)或：LinkList merge(LinkList A; LinkList B)2.12 将一个用循环链表暗示的稀疏多项式分化成两个多项式,使这两个多项式中各自仅含奇次项或偶次项,并要求利用原链表中的结点空间来组成这两个链表.[提示]：注明用头指针还是尾指针.2.13 建立一个带头结点的线性链表,用以存放输入的二进制数,链表中每个结点的data域存放一个二进制位.并在此链表上实现对二进制数加1的运算.[提示]：可将低位放在前面.2.14 设多项式P(x)采取课本中所述链接办法存储.写一算法,对给定的x值,求P(x)的值.[提示]：float PolyValue(Polylist p; float x) {……}实习题1．将若干城市的信息存入一个带头结点的单链表,结点中的城市信息包含城市名、城市的位置坐标.要求：（1）给定一个城市名,前往其位置坐标；（2）给定一个位置坐标P和一个距离D,前往所有与P的距离小于等于D的城市.2．约瑟夫环问题.约瑟夫问题的一种描述是：编号为1,2,…,n的n团体按顺时针标的目的围坐一圈,每人持有一个密码（正整数）.一开始任选一个整数作为报数上限值m,从第一团体开始顺时针自1开始顺序报数,报到m时停止报数.报m的人出列,将他的密码作为新的m值,从他在顺时针标的目的上的下一团体开始重新从1报数,如此下去,直至所有的人全部出列为止.试设计一个程序,求出出列顺序.利用单向循环链表作为存储结构模拟此过程,依照出列顺序打印出大家的编号.例如m的初值为20；n=7,7团体的密码依次是：3,1,7,2,4,8,4,出列的顺序为6,1,4,7,2,3,5.第二章答案实习题二：约瑟夫环问题约瑟夫问题的一种描述为：编号1,2,…,n的n团体按顺时针标的目的围坐一圈,每团体持有一个密码（正整数）.一开始任选一个报数上限值m,从第一团体开始顺时针自1开始顺序报数,报到m时停止报数.报m的人出列,将他的密码作为新的m值,从他在顺时针标的目的上的下一团体开始重新从1报数,如此下去,直至所有的人全部出列为止.试设计一个程序,求出出列顺序.利用单向循环链表作为存储结构模拟此过程,依照出列顺序打印出大家的编号.例如,m的初值为20；n=7,7团体的密码依次是：3,1,7,2,4,8,4,出列顺序为6,1,4,7,2,3,5.【解答】算法如下：typedef struct Node{int password;int num;struct Node *next;} Node,*Linklist;void Josephus(){Linklist L;Node *p,*r,*q;int m,n,C,j;L=(Node*)malloc(sizeof(Node)); /*初始化单向循环链表*/if(L==NULL) { printf("\n链表申请不到空间!");return;} L->next=NULL;r=L;printf("请输入数据n的值(n>0):");scanf("%d",&n);for(j=1;j<=n;j++)/*建立链表*/{p=(Node*)malloc(sizeof(Node));if(p!=NULL){printf("请输入第%d团体的密码:",j);scanf("%d",&C);p->password=C;p->num=j;r->next=p;r=p;}}r->next=L->next;printf("请输入第一个报数上限值m(m>0):");scanf("%d",&m);printf("*****************************************\n"); printf("出列的顺序为:\n");q=L;p=L->next;while(n!=1)/*计算出列的顺序*/{j=1;while(j<m)/*计算当前出列的人选p*/{q=p;/*q为当前结点p的前驱结点*/p=p->next;j++;}printf("%d->",p->num);m=p->password; /*获得新密码*/ n--;q->next=p->next; /*p出列*/r=p;p=p->next;free(r);}printf("%d\n",p->num);}2.7试辨别以不合的存储结构实现单线表的就地逆置算法,即在原表的存储空间将线性表（a1,a2,…,an）逆置为(an,an-1,…,a1).【解答】（1）用一维数组作为存储结构void invert(SeqList *L, int *num) {int j;ElemType tmp;for(j=0;j<=(*num-1)/2;j++){tmp=L[j];L[j]=L[*num-j-1];L[*num-j-1]=tmp;}}}（2）用单链表作为存储结构void invert(LinkList L){Node *p, *q, *r;if(L->next ==NULL) return; /*链表为空*/p=L->next;q=p->next;p->next=NULL; /* 摘下第一个结点,生成初始逆置表 */while(q!=NULL) /* 从第二个结点起依次头拔出当前逆置表 */{r=q->next;q->next=L->next;L->next=q;q=r;}}2.11将线性表A=(a1,a2,……am), B=(b1,b2,……bn)合并成线性表C, C=(a1,b1,……am,bm,bm+1,…….bn)当m<=n时,或C=(a1,b1, ……an,bn,an+1,……am)当m>n时,线性表A、B、C以单链表作为存储结构,且C表利用A表和B表中的结点空间组成.注意：单链表的长度值m和n均未显式存储.【解答】算法如下：LinkList merge(LinkList A, LinkList B, LinkList C){Node *pa, *qa, *pb, *qb, *p;pa=A->next; /*pa 暗示A的当前结点*/pb=B->next;p=A; / *利用p来指向新连接的表的表尾,初始值指向表A 的头结点*/while(pa!=NULL && pb!=NULL) /*利用尾插法建立连接之后的链表*/{qa=pa->next;qb=qb->next;p->next=pa; /*交替选择表A和表B中的结点连接到新链表中；*/p=pa;p->next=pb;p=pb;pa=qa;pb=qb;}if(pa!=NULL) p->next=pa; /*A的长度大于B 的长度*/if(pb!=NULL) p->next=pb; /*B的长度大于A 的长度*/C=A;return(C);}第3章限定性线性表—栈和队列习题1. 按图3.1(b)所示铁道（两侧铁道均为单向行驶道）进行车厢调度,回答：⑴如进站的车厢序列为123,则可能得到的出站车厢序列是什么？123、213、132、231、321（312）⑵如进站的车厢序列为123456,能否得到435612和135426的出站序列,并说明原因.（即写出以“S”暗示进栈、以“X”暗示出栈的栈操纵序列）.SXSS XSSX XXSX 或 S1X1S2S3X3S4S5X5X4X2S6X62. 设队列中有A、B、C、D、E这5个元素,其中队首元素为A.如果对这个队列重复执行下列4步操纵：（1）输出队首元素；（2）把队首元素值拔出到队尾；（3）删除队首元素；（4）再次删除队首元素.直到队列成为空队列为止,则是否可能得到输出序列：（1）A、C、E、C、C （2） A、C、E（3） A、C、E、C、C、C （4） A、C、E、C[提示]：A、B、C、D、E （输出队首元素A）A、B、C、D、E、A （把队首元素A拔出到队尾）B、C、D、E、A （删除队首元素A）C、D、E、A （再次删除队首元素B）C、D、E、A （输出队首元素C）C、D、E、A、C （把队首元素C拔出到队尾）D、E、A、C （删除队首元素C）E、A、C （再次删除队首元素D）3. 给出栈的两种存储结构形式名称,在这两种栈的存储结构中如何判别栈空与栈满？4. 依照四则运算加、减、乘、除和幂运算（↑）优先关系的常规,画出对下列算术表达式求值时操纵数栈和运算符栈的变更过程：A－B＊Ｃ／Ｄ＋Ｅ↑Ｆ5. 试写一个算法,判断依次读入的一个以@为结束符的字母序列,是否为形如‘序列1& 序列2’模式的字符序列.其中序列1和序列2中都不含字符’&’,且序列2是序列1的逆序列.例如,‘a+b&b+a’是属该模式的字符序列,而‘１+３&３－１’则不是.[提示]：（1）边读边入栈,直到&（2）边读边出栈边比较,直到……6. 假设表达式由单字母变量和双目四则运算算符组成.试写一个算法,将一个通常书写形式（中缀）且书写正确的表达式转换为逆波兰式（后缀）.[提示]：例：中缀表达式：a+b后缀表达式: ab+中缀表达式：a+b×c后缀表达式: abc×+中缀表达式：a+b×c-d后缀表达式: abc×+d-中缀表达式：a+b×c-d/e后缀表达式: abc×+de/-中缀表达式：a+b×(c-d)-e/f后缀表达式: abcd-×+ef/-•后缀表达式的计算过程：（简便）顺序扫描表达式,（1）如果是操纵数,直接入栈；（2）如果是操纵符op,则连续退栈两次,得操纵数X, Y,计算X op Y,并将结果入栈.•如何将中缀表达式转换为后缀表达式？顺序扫描中缀表达式,（1）如果是操纵数,直接输出；（2）如果是操纵符op2,则与栈顶操纵符op1比较：如果op2 > op1,则op2入栈；如果op2 = op1,则脱括号；如果op2 < op1,则输出op1；7. 假设以带头结点的循环链表暗示队列,并且只设一个指针指向队尾元素结点（注意不设头指针）,试编写相应的队列初始化、入队列和出队列的算法.[提示]：参P.56 P.70 先画图.typedef LinkListCLQueue;int InitQueue(CLQueue * Q)int EnterQueue(CLQueue Q, QueueElementType x)int DeleteQueue(CLQueue Q, QueueElementType *x)8. 要求循环队列不损失一个空间全部都能得到利用, 设置一个标记域tag , 以tag为0或1来区分头尾指针相同时的队列状态的空与满,请编写与此结构相应的入队与出队算法.[提示]：初始状态：front==0, rear==0, tag==0队空条件：front==rear, tag==0队满条件：front==rear, tag==1其它状态：front !=rear, tag==0（或1、2）入队操纵：……（入队）if (front==rear) tag=1；（或直接tag=1）出队操纵：……（出队）tag=0；[问题]：如何明确区分队空、队满、非空非满三种情况？9. 简述以下算法的功效（其中栈和队列的元素类型均为int）：（1）void proc_1(Stack S){ iint i, n, A[255];n=0;{n++;Pop(&S, &A[n]);}for(i=1; i<=n; i++)Push(&S, A[i]);}将栈S逆序.（2）void proc_2(Stack S, int e) {Stack T; int d;InitStack(&T);while(!EmptyStack(S)){Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){Pop(&T, &d);Push( &S, d);}}删除栈S中所有等于e的元素.（3）void proc_3(Queue *Q){Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}{Pop(&S, &d);EnterQueue(Q,d)}}将队列Q逆序.实习题1．回文判断.称正读与反读都相同的字符序列为“回文”序列.试写一个算法,判断依次读入的一个以@为结束符的字母序列,是否为形如‘序列1&序列2’模式的字符序列.其中序列1和序列2中都不含字符‘&’,且序列2是序列1的逆序列.例如,‘a+b&b+a’是属该模式的字符序列,而‘１+３&３－１’则不是.2．停车场办理.设停车场是一个可停放n辆车的狭长通道,且只有一个大门可供汽车进出.在停车场内,汽车按到达的先后次序,由北向南依次排列（假设大门在最南端）.若车场内已停满n辆车,则后来的汽车需在门外的便道上等候,当有车开走时,便道上的第一辆车即可开入.当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门后,其它车辆再按原次序前往车场.每辆车离开停车场时,应按其停留时间的长短交费（在便道上停留的时间不收费）.试编写程序,模拟上述办理过程.要求以顺序栈模拟停车场,以链队列模拟便道.从终端读入汽车到达或离去的数据,每组数据包含三项：①是“到达”还是“离去”；②汽车牌照号码；③“到达”或“离去”的时刻.与每组输入信息相应的输出信息为：如果是到达的车辆,则输出其在停车场中或便道上的位置；如果是离去的车辆,则输出其在停车场中停留的时间和应交的用度.（提示：需另设一个栈,临时停放为让路而从车场退出的车.）3．商品货架办理.,栈底商品的生产日期最近.上货时,需要倒货架,以包管生产日期较近的商品在较下的位置.用队列和栈作为周转,实现上述办理过程.第三章答案3.1按3.1(b)所示铁道（两侧铁道均为单向行驶道）进行车厢调度,回答：（1）如进站的车厢序列为123,则可能得到的出站车厢序列是什么？（2）如进站的车厢序列为123456,能否得到435612和135426的出站序列,并说明原因（即写出以“S”暗示进栈、“X”暗示出栈的栈序列操纵）.【解答】（1）可能得到的出站车厢序列是：123、132、213、231、321.（2）不克不及得到435612的出站序列.因为有S(1)S(2)S(3)S(4)X(4)X(3)S(5)X(5)S(6)S(6),此时依照“后进先出”的原则,出栈的顺序必须为X(2)X(1).能得到135426的出站序列.因为有S(1)X(1)S(2)S(3)X(3)S(4)S(5)X(5)X(4)X(2)X(1).3.3给出栈的两种存储结构形式名称,在这两种栈的存储结构中如何判别栈空与栈满？【解答】（1）顺序栈（top用来存放栈顶元素的下标）判断栈S空：如果S->top==-1暗示栈空.判断栈S满：如果S->top==Stack_Size-1暗示栈满.（2）链栈（top为栈顶指针,指向当前栈顶元素前面的头结点）判断栈空：如果top->next==NULL暗示栈空.判断栈满：当系统没有可用空间时,申请不到空间存放要进栈的元素,此时栈满.3.4 照四则运算加、减、乘、除和幂运算的优先常规,画出对下列表达式求值时操纵数栈和运算符栈的变更过程：A-B*C/D+E↑F 【解答】3.5写一个算法,判断依次读入的一个以@为结束符的字母序列,是否形如‘序列1&序列2’的字符序列.序列1和序列2中都不含‘&’,且序列2是序列1 的逆序列.例如,’a+b&b+a’是属于该模式的字符序列,而’1+3&3-1’则不是.【解答】算法如下：int IsHuiWen(){Stack *S;Char ch,temp;InitStack(&S);Printf(“\n请输入字符序列：”);Ch=getchar();While( ch!=&) /*序列1入栈*/{Push(&S,ch);ch=getchar();}do /*判断序列2是否是序列1的逆序列*/{ch=getchar();Pop(&S,&temp);if(ch!= temp) /*序列2不是序列1的逆序列*/{return(FALSE); printf(“\nNO”);}} while(ch!=@ && !IsEmpty(&S))if(ch = = @ && IsEmpty(&S)){ return(TRUE); printf(“\nYES”);} /*序列2是序列1的逆序列*/else{return(FALSE); printf(“\nNO”);} }/*IsHuiWen()*/3.8 要求循环队列不损失一个空间全部都能得到利用,设置一个标记tag,以tag为0或1来区分头尾指针相同时的队列状态的空与满,请编写与此相应的入队与出队算法.【解答】入队算法：int EnterQueue(SeqQueue *Q, QueueElementType x){ /*将元素x入队*/if(Q->front==Q->front && tag==1) /*队满*/return(FALSE);if(Q->front==Q->front && tag==0) /*x入队前队空,x入队后重新设置标记*/tag=1;Q->elememt[Q->rear]=x;Q->rear=(Q->rear+1)%MAXSIZE; /*设置队尾指针*/Return(TRUE);}出队算法：int DeleteQueue( SeqQueue *Q , QueueElementType *x) { /*删除队头元素,用x前往其值*/if(Q->front==Q->rear && tag==0) /*队空*/return(FALSE);*x=Q->element[Q->front];Q->front=(Q->front+1)%MAXSIZE; /*重新设置队头指针*/ if(Q->front==Q->rear) tag=0; /*队头元素出队后队列为空,重新设置标记域*/Return(TUUE);}编写求解Hanoi问题的算法,并给出三个盘子挪动转移时的递归调用过程.【解答】算法：void hanoi (int n ,char x, char y, char z){ /*将塔座X上按直径由小到大且至上而下编号为1到n的n个圆盘按规则搬到塔座Z上,Y可用做帮助塔座*/if(n = =1)move(x,1,z);else{ Hanoi(n-1,x,z,y);move(x, n, z);Hanoi(n-1, y,x,z);}}Hanoi(3,A,B,C)的递归调用过程：Hanoi(2,A,C,B):Hanoi(1,A,B,C) move(A->C) 1号搬到CMove(A->B) 2号搬到BHanoi(1,C,A,B) move(C->B) 1号搬到BMove(A->C) 3号搬到CHanoi(2,B,A,C)Hanoi(1,B,C,A) move(B->A) 1号搬到AMove(B->C) 2号搬到CHanoi(1,A,B,C) move(A->C) 1号搬到C第4章串习题1. 设s=’I AM A STUDENT’, t=’GOOD’, q=’WORKER’.给出下列操纵的结果：StrLength(s); SubString(sub1,s,1,7); SubString(sub2,s,7,1);StrIndex(s,’A’,4); StrWordStr(s,’STUDENT’,q);StrCat(StrCat(sub1,t), StrCat(sub2,q));[参考答案]StrLength(s)=14; sub1= ’I AM A_’; sub2= ’_’; StrIndex(s,’A’,4)=6;StrWordStr(s,’STUDENT’,q)= ’I AM A WORKER’;StrCat(StrCat(sub1,t), StrCat(sub2,q))= ’I AM A GOOD WORKER’;2. 编写算法,实现串的基本操纵StrWordStr(S,T,V).3. 假设以块链结构暗示串,块的大小为1,且附设头结点.试编写算法,实现串的下列基本操纵：StrAsign(S,chars)；StrCopy(S,T)；StrCompare(S,T)；StrLength(S)；StrCat(S,T)；SubString(Sub,S,pos,len). [说明]：用单链表实现.4. 叙述以下每对术语的区别：空串和空格串；串变量和串常量；主串和子串；串变量的名字和串变量的值.5. 已知：S=”(xyz)*”,T=”(x+z)*y”.试利用联接、求子串和置换等操纵,将S转换为T.6. S和T是用结点大小为1的单链表存储的两个串,设计一个算法将串S中首次与T匹配的子串逆置.7. S是用结点大小为4的单链表存储的串,辨别编写算法在第k 个字符后拔出串T,及从第k个字符删除len个字符.以下算法用定长顺序串：8. 写下列算法：（1）将顺序串r中所有值为ch1的字符换成ch2的字符.（2）将顺序串r中所有字符依照相反的次序仍存放在r中.（3）从顺序串r中删除其值等于ch的所有字符.（4）从顺序串r1中第index 个字符起求出首次与串r2相同的子串的起始位置.（5）从顺序串r中删除所有与串r1相同的子串.9. 写一个函数将顺序串s1中的第i个字符到第j个字符之间的字符用s2串替换.[提示]：（1）用静态顺序串（2）先移位,后复制10. 写算法,实现顺序串的基本操纵StrCompare(s,t).11. 写算法,实现顺序串的基本操纵StrWordStr(&s,t,v).[提示]：（1）被替换子串定位（相当于第9题中i）（2）被替换子串后面的字符左移或右移（为替换子串准备房间）（3）替换子串入住（复制）（4）重复上述,直到……第四章答案4.1 设s=’I AM A STUDENT’,t=’GOOD’, q=’WORKER’.给出下列操纵的结果：【解答】StrLength(s)=14;SubString(sub1,s,1,7) sub1=’IAM A ’;SubString(sub2,s,7,1) sub2=’ ’;StrIndex(s,4,’A’)=6;S trWordStr(s,’STUDENT’,q); s=’I AMA WORKER’;StrCat(StrCat(sub1,t),StrCat(sub2,q))sub1=’I AM A GOOD WORKER’.4.2编写算法,实现串的基本操纵StrWordStr(S,T,V).【解答】算法如下：int strWordStr(SString S,SString T, SString V){/*用串V替换S中的所有子串T */int pos,i;pos=strIndex(S,1,T); /*求S中子串T第一次出现的位置*/if(pos = = 0) return(0);while(pos!=0) /*用串V替换S中的所有子串T */{switch(T.len-V.len){case 0: /*串T的长度等于串V的长度*/for(i=0;i<=V.len;i++) /*用V替换T*/S->ch[pos+i]=V.ch[i];case >0: /*串T的长度大于串V的长度*/for(i=pos+t.ien;i<S->len;i--)/*将S中子串T后的所有字符S->ch[i-t.len+v.len]=S->ch[i]; 前移T.len-V.len个位置*/for(i=0;i<=V.len;i++)/*用V替换T*/S->ch[pos+i]=V.ch[i];S->len=S->len-T.len+V.len;case <0: /*串T的长度小于串V的长度*/if(S->len-T.len+V.len)<= MAXLEN /*拔出后串长小于MAXLEN*/{ /*将S中子串T后的所有字符后移V.len-T.len个位置*/for(i=S->len-T.len+V.len;i>=pos+T.len;i--)S->ch[i]=S->ch[i-T.len+V.len];for(i=0;i<=V.len;i++) /*用V替换T*/S->ch[pos+i]=V.ch[i];S->len=S->len-T.len+V.len; }else{ /*替换后串长>MAXLEN,但串V可以全部替换*/if(pos+V.len<=MAXLEN){ for(i=MAXLEN-1;i>=pos+T.len; i--)S->ch[i]=s->ch[i-T.len+V.len]for(i=0;i<=V.len;i++) /*用V替换T*/S->ch[pos+i]=V.ch[i];S->len=MAXLEN;}else /*串V的部分字符要舍弃*/{ for(i=0;i<MAXLEN-pos;i++)S->ch[i+pos]=V.ch[i];S->len=MAXLEN;}}/*switch()*/pos=StrIndex(S,pos+V.len,T); /*求S中下一个子串T的位置*/}/*while()*/return(1);}/*StrWordStr()*/附加题：用链式结构实现定位函数.【解答】typedef struct Node{ char data;struct Node *next;}Node,*Lstring;int strIndex(Lstring S, int pos, Lstring T)/*从串S的pos序号起,串T第一次出现的位置 */{Node *p, *q, *Ppos;int i=0,,j=0;if(T->next= =NULL || S->next = =NULL) return(0);p=S->next;q=T->next;while(p!=NULL && j<pos) /*p指向串S中第pos个字符*/{p=p->next; j++;}if(j!=pos) return(0);while(p!=NULL && q!=NULL){Ppos=p; /*Ppos指向当前匹配的起始字符*/if(p->data = = q->data){p=p->next; q=q->next;}else /*从Ppos指向字符的下一个字符起从新匹配*/{p=Ppos->next;q=T->head->next;i++;}}if(q= =NULL) return(pos+i); /*匹配成功*/else return(0); /*失败*/}第五章数组和广义表习题1. 假设有6行8列的二维数组A,每个元素占用6个字节,存储器按字节编址.已知A的基地址为1000,计算：（1）数组A共占用多少字节；（288）（2）数组A的最后一个元素的地址；（1282）（3）按行存储时,元素A36的地址；（1126）（4）按列存储时,元素A36的地址；（1192）[注意]：本章自定义数组的下标从1开始.2．设有三对角矩阵（aij）n×n ,将其三条对角线上的元素逐行地存于数组B(1:3n-2)中,使得B[k]= aij,求：（1）用i,j暗示k的下标变换公式；（2）用k暗示i,j的下标变换公式.i = k/3 + 1, j = k%3 + i - 1 = k%3 + k/3或：i = k/3 + 1, j = k - 2×( k/3 )3. 假设稀疏矩阵A和B均以三元组表作为存储结构.试写出矩阵相加的算法,另设三元组表C存放结果矩阵.[提示]：参考P.28例、P.47例.4．在稀疏矩阵的快速转置算法 5.2中,将计算position[col]的办法稍加修改,使算法只占用一个帮助向量空间.[提示]：（1）position[ k ] 中为第k列非零元素个数,k = 1, 2, …, n（2）position[ 0 ] = 1; （第1列中第一个非零元素的正确位置）（3）position[ k ] = position[ k – 1 ] + position[ k ] , k = 1, 2, …, n（4）position[ k ] = position[ k – 1 ] , k = n, n– 1 , … ,15．写一个在十字链表中删除非零元素aij 的算法.[提示]：“删除”两次,释放一次.6．画出下面广义表的两种存储结构图示：((((a), b)), ((( ), d), (e, f)))7（（（（（8位,O(n). 9．假设按低下标优先（以最左的下标为主序）存储整数数组A （1:8, 1:2, 1:4, 1:7）时,第一个元素的字节地址是100,每个整数占4个字节,问元素A(4, 2, 3, 5)的存储地址是什么？10. 高低标优先（以最右的下标为主序）存储整数数组A （1:8, 1:2, 1:4, 1:7）时,顺序列出数组A 的所有元素.11．试编写一个以三元组形式输出用十字链表暗示的稀疏矩阵中非零元素及其下标的算法.实习题1． 若矩阵Am×n 中的某个元素aij 是第i 行中的最小值,同时又是第j 列中的最大值,则称此元素为该矩阵中的一个马鞍点.假设以二维数组存储矩阵,试编写算法求出矩阵中的所有马鞍点.第五章答案5.2三对角矩阵An×n,将其三条对角线上的元素逐行的存于数组B[1..3n-2]中,使得B[k]=aij,求：（1）用i,j 暗示k 的下标变第一种存储结构（自底向上看）。
数据结构c语言版耿国华课后习题答案
数据结构c语言版耿国华课后习题答案数据结构C语言版耿国华课后习题答案数据结构是计算机科学中非常重要的一个领域，它研究如何组织和存储数据，以便能够高效地进行检索和操作。
C语言作为一种高效的编程语言，被广泛应用于数据结构的实现和操作中。
耿国华编写的《数据结构C语言版》是一本经典的教材，其中包含了大量的习题，帮助学生巩固所学的知识。
在这本教材中，耿国华提供了大量的习题，涵盖了数据结构的各个方面，包括数组、链表、栈、队列、树等。
这些习题不仅考察了学生对数据结构的理解，还帮助他们提高了编程能力。
而课后习题的答案则是帮助学生检验自己的学习成果，确保他们能够正确地理解和应用所学的知识。
在这篇文章中，我们将介绍一些数据结构C语言版耿国华课后习题的答案，以帮助读者更好地理解和掌握数据结构的知识。
1. 数组题目：编写一个程序，实现对一个整型数组的冒泡排序。
答案：```cvoid bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```2. 链表题目：编写一个程序，实现对一个单链表的反转。
答案：```cstruct ListNode* reverseList(struct ListNode* head) { struct ListNode* prev = NULL;struct ListNode* curr = head;while (curr != NULL) {struct ListNode* nextTemp = curr->next;curr->next = prev;prev = curr;curr = nextTemp;}return prev;}```3. 栈题目：编写一个程序，实现对一个整型数组的栈操作（包括入栈、出栈和获取栈顶元素）。
西北大学计算机专硕研究生入学考试历年真题
西北大学2015年招收攻读硕士学位研究生试题(回忆版)科目名称：数据结构科目代码：851适用专业：计算机技术、软件工程共2页答案请答在答题纸上，答在本试题上的答案一律无效。
一、简答[每小题6分，共30分]1、简述四类基本的数据逻辑关系，并用图表示。
2、简述数组、广义表属于线性表原因。
3、算法的定义及特性。
4、什么是平衡二叉排序树？平衡因子的取值范围是什么？5、简述稳定排序含义，给出两种稳定排序方法以及两种不稳定排序方法名称并证明。
二、分析与方法选择[每小题10分，共30分]1、折半查找法对待查找的列表哪两个要求？答：必须采用顺序存储结构；必须按关键字大小有序排列。
2、分析快速排序的性能（最好情况、最坏情况）。
3、关于二叉树结点度数的计算。
（牢记二叉树的5条性质，会计算二叉树及K 叉树相关的计算。
）三、构造结果[每小题8分，共40分]1、已知一棵二叉树的前序序列及后序序列，给出其对应的二叉树。
备注：西大历年试卷都是给出前序序列、中序序列或者中序序列、后序序列，写出对应的二叉树，这种题型很好做，且结果给出的二叉树唯一。
但是2015年试题给出的是已知前序序列、后序序列，求对应的二叉树，这题我们平时几乎都没做过，但是其实也不难，往往给出前序序列、后序序列，构造的二叉树不是唯一的，但是这次考题设置的巧妙，最后给出的结果二叉树应该是唯一的。
这道题具体我也不记得了，反正有点难，我也花了很长时间最后才做出来的。
2、图的两种存储结构及表示、深度优先搜索遍历、广度优先搜索遍历、最小生成树的生成。
3、依次输入（26，30，15，10，28，19，18，22），构造二叉排序树，并计算等概率情况下的查找成功的平均查找长度。
4、画出10个元素的折半判定树，并计算等概率情况下查找成功的平均查找长度。
5、最小生成树生成的两种算法：普里姆算法、克鲁斯卡尔算法。
四、编写算法 [每小题10分，共20分]1、以单链表作存储结构实现线性表的就地逆置算法，即在原表的存储空间将线性表（n a a a ,,,21 ）逆置为（11,,,a a a n n ）。
《数据结构——C语言描述》习题及答案 耿国华精编版
第1章绪论习题一、问答题1. 什么是数据结构？2. 四类基本数据结构的名称与含义。
3. 算法的定义与特性。
4. 算法的时间复杂度。
5. 数据类型的概念。
6. 线性结构与非线性结构的差别。
7. 面向对象程序设计语言的特点。
8. 在面向对象程序设计中，类的作用是什么？9. 参数传递的主要方式及特点。
10. 抽象数据类型的概念。
二、判断题1. 线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
2. 算法就是程序。
3. 在高级语言（如C、或PASCAL）中，指针类型是原子类型。
三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时：1 = (1+1)×1/2 = (1+12)/2i=2时：1+2 = (1+2)×2/2 = (2+22)/2i=3时：1+2+3 = (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n = (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2=[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能的小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n), x和n，输出为P n(x0).通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递。
《数据结构——C语言描述》习题及答案 耿国华 2
第1章绪论习题一、问答题1. 什么是数据结构？2. 四类基本数据结构的名称与含义。
3. 算法的定义与特性。
4. 算法的时间复杂度。
5. 数据类型的概念。
6. 线性结构与非线性结构的差别。
7. 面向对象程序设计语言的特点。
8. 在面向对象程序设计中，类的作用是什么？9. 参数传递的主要方式及特点。
10. 抽象数据类型的概念。
二、判断题1. 线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
2. 算法就是程序。
3. 在高级语言（如C、或PASCAL）中，指针类型是原子类型。
三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时：1 = (1+1)×1/2 = (1+12)/2i=2时：1+2 = (1+2)×2/2 = (2+22)/2i=3时：1+2+3 = (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n = (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2 =[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能的小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n), x和n，输出为P n(x0).通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递。
数据结构 耿国华 西北大学 4-1串的基本概念和顺序串的存储与运算
起长度为 len 的子串。
例如： SubString (sub1, commander , 4,s3u)b1= man
SubString (sub2, commander , 4, 7)
sub2= ?
S = chater 5
3/26/2020
第4章 串 4.1 串的定义 基本操作：（4）StrCopy (S, T)
StrCopy (S, T) 初始条件：串S存在。 操作结果：由串T复制得串S
6
3/26/2020
第4章 串 4.1 串的定义 基本操作：（5）StrEmpty (S)
StrEmpty (S) 初始条件：串S存在。 操作结果：若串S为空串，则返回TRUE，否则返回
StrLength(S) 初始条件：串S已存在。 操作结果：返回串S的长度，即串S中的元素个数
9
3/26/2020
第4章 串 4.1 串的定义 基本操作：（8）StrClear (S)
StrClear (S) 初始条件：串S已存在。 操作结果：将S清为空串
10
3/26/2020
第4章 串 4.1 串的定义 基本操作： （9）StrCat(S,T)
StrReplace (S, T, V) 初始条件：串S, T和 V 均已存在，且 T 是非空串。 操作结果：用V替换主串S中出现的所有与（模式
串）T相等的不重叠的子串。
例如： S = abcaabcaaabca , T = bca , V = x S = axaxaax 14
3/26/2020
第4章 串 4.1 串的定义 基本操作：（13）StrDestroy (S)
数据结构课后习题答案(耿国华版
第1章绪论2、（1）×(２)×(3)√3、（１）A(2）C（3)C５、计算下列程序中x=x+1得语句频度fｏr(i=1;i＜=n；ｉ＋+）for（j=1;ｊ〈=i；ｊ++）ｆoｒ（k＝1；k〈=j;ｋ＋+)x=x＋1;【解答】x=ｘ+1得语句频度为：T（n）=1+（1＋2）+(1+2+3）＋……+(1+2＋……+n）=n（n+1）(n＋2)/66、编写算法，求一元多项式p n（x)=ａ０+a1x+a2x2+……、+a n x n得值p n(x0),并确定算法中每一语句得执行次数与整个算法得时间复杂度,要求时间复杂度尽可能小，规定算法中不能使用求幂函数.注意:本题中得输入为a i(i=0，１,…n)、x与n,输出为Ｐn（x0）。
算法得输入与输出采用下列方法（1）通过参数表中得参数显式传递（2）通过全局变量隐式传递。
讨论两种方法得优缺点,并在算法中以您认为较好得一种实现输入输出.【解答】（1）通过参数表中得参数显式传递优点：当没有调用函数时，不占用内存，调用结束后形参被释放,实参维持，函数通用性强,移置性强。
缺点：形参须与实参对应，且返回值数量有限。
(２）通过全局变量隐式传递优点:减少实参与形参得个数，从而减少内存空间以及传递数据时得时间消耗缺点:函数通用性降低,移植性差算法如下:通过全局变量隐式传递参数ＰolyValue(）{int i，ｎ；float ｘ,a[],ｐ;prｉｎtf(“＼nn=”);ｓｃanf（“%f”，&n）;prｉntf（“\nx＝”)；scaｎf(“%f”,＆x）；ｆor（i＝0;i<ｎ；i++)ｓｃａnf（“％ｆ"，＆a［i]）; /＊执行次数：n次*/p=a[0］;foｒ（ｉ=1；i<=n;ｉ++）{ ｐ=p+a［i]*x; ／＊执行次数:n次*/x=ｘ*x；｝ｐriｎｔｆ(“％f”，p）;｝算法得时间复杂度：Ｔ（n)=O（ｎ）通过参数表中得参数显式传递ｆｌoａt PolyVａｌuｅ（float a[]，fｌoat x,ｉｎt n）{ｆｌｏaｔp，s;int i；p=x；s=a[0]；fｏr(i＝1;ｉ<＝ｎ;i＋＋)｛s=ｓ+a［i]＊p；/*执行次数：n次*/p=p*x;｝rｅturn（p）；}算法得时间复杂度：T(n）=Ｏ（n）第2章线性表习题１、填空：(1）在顺序表中插入或删除一个元素,需要平均移动一半元素，具体移动得元素个数与插入或删除得位置有关。
《数据结构——C语言描述》习题及答案 耿国华 2
第1章绪论习题一、问答题1. 什么是数据结构？2. 四类基本数据结构的名称与含义。
3. 算法的定义与特性。
4. 算法的时间复杂度。
5. 数据类型的概念。
6. 线性结构与非线性结构的差别。
7. 面向对象程序设计语言的特点。
8. 在面向对象程序设计中，类的作用是什么？9. 参数传递的主要方式及特点。
10. 抽象数据类型的概念。
二、判断题1. 线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
2. 算法就是程序。
3. 在高级语言（如C、或PASCAL）中，指针类型是原子类型。
三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时：1 = (1+1)×1/2 = (1+12)/2i=2时：1+2 = (1+2)×2/2 = (2+22)/2i=3时：1+2+3 = (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n = (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2 =[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能的小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n), x和n，输出为P n(x0).通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递。
数据结构部分课后习题答案(耿国华)
第一章绪论一、问答题1.什么是数据结构？2.叙述四类基本数据结构的名称与含义。
3.叙述算法的定义与特性。
4.叙述算法的时间复杂度。
5.叙述数据类型的概念。
6.叙述线性结构与非线性结构的差别。
7.叙述面向对象程序设计语言的特点。
8.在面向对象程序设计中，类的作用是什么？9.叙述参数传递的主要方式及特点。
10.叙述抽象数据类型的概念。
二、判断题（在各题后填写“√”或“×”）1.线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
（）2.算法就是程序。
（）3.在高级语言（如C或PASCAL）中，指针类型是原子类型。
（）三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;【解答】i=1时：1 = (1+1)×1/2 = (1+12)/2i=2时：1+2 = (1+2)×2/2 = (2+22)/2i=3时：1+2+3 = (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n = (1+n)×n/2 = (n+n2)/2x=x+1的语句频度为：f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2=[ (1+n)×n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法，求一元多项式P n(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n),x和n，输出为P n(x0)。
耿国华数据结构附录样卷答案
附录A 样卷一一.判断题：(10分)正确在括号内打错谋打X()1•在单链表中，头结点是必不可少的。
()2.如果一个二叉树中没有度为1的结点，则必为满二叉树。
()3.循环链表的结点结构与单链表的结点结构完全相同，只是结点间的连接方式不同。
()4•顺序存储结构只能用来存放线性结构；链式存储结构只能用来存放非线性结构。
()5.在一个大根堆中，最小元素不一定在最厉。
()6.在一个有向图屮，所有顶点的入度之和等于所有顶点的出度之和。
()7.在采用线性探测法处理冲突的散列表屮，所有同义词在表屮相邻。
()&内部排序是指排序过程在内存中进行的排序。
()9.拓扑排序是指结点的值是有序排列。
()10. A0E网所表示的工程至少所需的时间等于从源点到汇点的最长路径的长度。
一•、选择题(30分，每题1・5分)1.有一个含头结点的单链表，头指针为head,则判断其是否为空的条件为:A.head=NILB. head*. next=NILC. head*. next=headD. headONIL 或A.head~NULL B. Head->next~NULL C. head->nex t==head D.Head!=NULL2.非空的循环单•链表head的尾指针p满足一0A.p) next二NILB. p=NILC. p\ next=head D・ p=head或A.p->next=NULL B. p==NULL C. P->next=head D.p=head3.链表不具有的特点是oA.可随机访问任一个元素B、插入删除不需要移动元素C.不必事先估计存储空间D.所需空间与线性表的长度成正比4.若某链表中最常用的操作是在最后一个结点之后插入一个结点和删除最后一个结点，则釆用_______ 存储方式最节省运算时间。
A、单链表B、双链表C、单循环链表D.带头结点的双循环链表5.若线性表最帘用的操作是存取第i个元索及其前驱的值，则采用 _____ 存储方式节省时间。
耿国华数据结构各章知识点纲要
第1章绪论1.基本概念：数据、数据元素、数据项、抽象数据类型2.数据的逻辑结构：集合结构、线性结构、树型结构、图形结构3.数据的存储结构：顺序存储、链式存储4.数据相关的运算集合（随具体应用而不同）5.算法：定义、算法的分析6.本章重点和难点（1）抽象数据类型（2）算法的时间复杂度的分析第2章线性表1.线性表的概念2.顺序表的概念、类型构造、基本运算3.链表的概念、类型构造、基本运算4.顺序表与链表各自的特点、适用场合5.一元多项式的表示和处理6.本章重点难点（1）顺序表的插入、删除等基本运算（2）单链表的插入、删除等基本运算（3）循环链表、双向链表的基本运算（4）链式存储表示的一元多项式的运算第3章栈和队列1.栈：（1）栈的定义、特点（2）顺序栈及基本运算的实现、两栈共享技术（3）链栈及基本运算的实现（注意指针的方向）2.队列：（1）队列的定义、特点（2）循环队列及基本运算的实现（3）链队列及基本运算的实现3.本章重点难点：（1）栈的应用（基于栈的表达式括号匹配检验、二叉树的先序/中序遍历等）（2）队列的应用（基于队列的二叉树的层序遍历、图的广度优先遍历等）第4章字符串1.串：（1）逻辑结构：定义、特点、串长、子串等（2）存储结构：定长顺序串、堆串、块链串（了解）2.本章重点难点：（1）简单模式匹配算法（2）KMP算法第5章数组和广义表1.数组：（1）数组的定义与运算、数组的顺序存储（以行序为主序存储、以列序为主序存储）（2）特殊矩阵的压缩存储：对称矩阵、三角矩阵、带状矩阵（3）稀疏矩阵的压缩存储：三元组顺序表、十字链表2.广义表（1）广义表的逻辑结构：定义、表头、表尾、长度、深度（2）广义表的存储结构：头尾链表存储、扩展线性表存储3.本章重点难点：（1）以行序（或列序）为主序存储时，数组元素地址的计算（2）稀疏矩阵的压缩存储（3）广义表的存储结构第6章树和二叉树1.树的逻辑结构：树的定义及相关术语2.二叉树的逻辑结构：二叉树的定义、特点、二叉树的5个性质、完全二叉树、满二叉树3.二叉树的存储结构：（1）顺序存储（适合满二叉树和完全二叉树）（2）链式存储：二叉链表、三叉链表4.二叉树的运算：遍历及其它运算5.树、二叉树和森林：（1）树的存储结构：双亲表示法、孩子表示法、孩子兄弟表示法（2）树和二叉树的转换、森林和二叉树的转换6.哈夫曼树：哈夫曼树的定义、特点、构造过程、哈夫曼编码7.本章重点难点：（1）二叉树的性质（2）二叉树的算法设计：基于栈的先序、中序非递归遍历，基于队列的层序遍历等（3）树的存储结构（4）哈夫曼树及哈夫曼编码第7章图1.图的逻辑结构：图的定义、图的相关术语2.图的存储结构：（1）数组表示法（又称邻接矩阵表示法）（2）邻接表（3）有向图的十字链表（4）无向图的邻接多重表3.图的运算：（1）深度优先遍历DFS、广度优先遍历BFS（算法代码设计）（2）连通图的最小代价生成树算法：Prim算法、Kruskal算法（3）拓扑排序、关键路径（4）最短路径算法：Dijkstra算法、Floyd算法4.本章重点难点：（1）图的存储结构（2）图的遍历算法设计（3）图的其它运算的逻辑过程第8章查找1.基于线性表的查找2.基于树表的查找：二叉排序树、平衡二叉树、m阶B-树3.哈希查找（1）哈希函数（重点掌握除留余数法）（2）解决冲突的方法（重点掌握线性探测再散列、链地址法）4.本章重点难点：（1）折半查找过程及分析（2）平衡二叉树的生成过程（3）哈希查找第9章内部排序1.希尔排序的过程、算法代码的阅读与设计2.快速排序的过程、算法代码的阅读与设计3.堆排序的过程、算法代码的阅读与设计。
《数据结构——C语言描述》习题及答案解析耿国华
第1章绪论习题一、问答题1.什么是数据结构？2.四类基本数据结构的名称与含义。
3.算法的定义与特性。
4.算法的时间复杂度。
5.数据类型的概念。
6.线性结构与非线性结构的差别。
7.面向对象程序设计语言的特点。
8.在面向对象程序设计中，类的作用是什么？9.参数传递的主要方式及特点。
10.抽象数据类型的概念。
二、判断题1.线性结构只能用顺序结构来存放，非线性结构只能用非顺序结构来存放。
2.算法就是程序。
3.在高级语言（如C、或 PASCAL）中，指针类型是原子类型。
三、计算下列程序段中X=X+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++)x=x+1;[提示]：i=1时： 1 = (1+1)×1/2 = (1+12)/2i=2时： 1+2= (1+2)×2/2 = (2+22)/2i=3时： 1+2+3= (1+3)×3/2 = (3+32)/2…i=n时：1+2+3+……+n= (1+n)×n/2 = (n+n2)/2f(n) = [ (1+2+3+……+n) + (12 + 22 + 32 + …… + n2 ) ] / 2=[ (1+n)n/2 + n(n+1)(2n+1)/6 ] / 2=n(n+1)(n+2)/6=n3/6+n2/2+n/3区分语句频度和算法复杂度：O(f(n)) = O(n3)四、试编写算法求一元多项式Pn(x)=a0+a1x+a2x2+a3x3+…a n x n的值P n(x0)，并确定算法中的每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能的小，规定算法中不能使用求幂函数。
注意：本题中的输入a i(i=0,1,…,n), x和n，输出为P n(x0).通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递；（2）通过全局变量隐式传递。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
抽象数据类型定义
ADT Array{
数据对象：D={aj1j2…jn|n>0,称为数组的维数，ji是数组的 第i维下标，1≤ji≤bi,bi为数组第i维的长度， aj1j2…jn∈ElementSet}
数据关系：R={R1,R2,…,Rn} Ri={<aj1…ji…jn, aj1…ji+1…jn >| 1≤jk≤bk, 1≤k≤n, 且k≠i, 1≤ji≤bi-1, aj1…ji…jn, aj1…ji+1…jn ∈D,
1）不考虑插入和删除操作； 2）数组是多维的结构，而存
储空间是一个一维的结构。
5
第 5 章 数组和广义表
5.1 数组的定义和运算
运算 获得特定位置的元素值； 修改特定位置的元素值。
主要操作是数据元素的定位，即给定元素 的下标，得到该元素在计算机中的存放位置。
其本质是地址计算问题。
有两种顺序映象的方式:
10
第 5 章 数组和广义表
5.2 数组的顺序存储和实现
三维数组A r × m×n中任一元素ai,j,k 的存储位置
LOC(i,j,k)=LOC(1,1,1) + ((i-1)×m×n ＋(j-1)×n+(k-1))×L
j1,j2,j3代替数组下标i,j,k，并且j1,j2,j3的下限分别为c1,c2,c3， 上限为d1,d2,d3,每个元素占size个存储单元。则a j1,j2,j3的存储 位置
a11 a12 .... a1n a21 a22 .... a2n .... .... .... .... am1 am2 .... amn
可以看成是
n
m×n
也可以看成是m个行向量
可看成是一种特殊的线性表，其特殊在
3
于表中的数据元素本身也是一个线性表。
第 5 章 数组和广义表
5.1 数组的定义和运算
a1,1 a2,1 a1,2 a2,2 a1,3 a2,3
L
二维数组Am×n中任一元素ai,j 的存储位置 LOC(i,j)=LOC(1,1) + (m×(j-1)＋(i-1))× L
称为基地址或基址。
9
第 5 章 数组和广义表 5.2 数组的顺序存储和实现 三维数组A r × m×n中任一元素ai,j,k 的存储位置
第 5 章 数组和广义表
5.1 数组的定义和运算 5.2 数组的顺序存储和实现 5.3 特殊矩阵的压缩存储 5.4 广义表
1
第 5 章数组和广义表 5.1 数组的定义和运算 数组的定义 数组的预算
2
第 5 章数组和广义表
5.1 数组的定义和运算 定义 数组是一组有固定个数的元素的集合。
Am×n =
LOC(j1,j2,j3)=LOC(c1,c2,c3) + ((j1-c1)×(d2-c2+1)× (d3-c3+1) ＋(j2-c2)× (d3-c3+1) +(j3-c3))×size
11
第 5 章 数组和广义表 5.2 数组的顺序存储和实现 推广到一般情况，可得到 n 维数 组数据元素存储位置的映象关系：
以行序为主序； 返回
以列序为主序。
ห้องสมุดไป่ตู้
6
第 5 章 数组和广义表 5.2 数组的顺序存储和实现
7
第 5 章 数组和广义表
5.2 数组的顺序存储和实现
以行序为主序（如BASIC、COBOL、Pascal语 例言如）：
a1,1 a1,2 a1,3 a2,1 a2,2 a2,3
a1,1 a1,2 a1,3 a2,1 a2,2 a2,3
n
∑ Loc(A[j1][j2]…[jn]=Loc(A[c1][c2]…[cn])+ αi×(ji-ci), 1≤i≤n i=1 n 其中： αi=size×k∏=i+(1dk-ck+1),1≤i≤n)
12
L
二维数组Am×n中任一元素ai,j 的存储位置 LOC(i,j)=LOC(1,1) + (n×(i-1)＋(j-1))× L
称为基地址或基址。
8
第 5 章 数组和广义表
5.2 数组的顺序存储和实现
以列序为主序（如FORTRAN语言） 例如：
a1,1 a1,2 a1,3 a2,1 a2,2 a2,3
基本操作： i=1,…,n }
1.InitArray(A,n,bond1,…,bondn) 2.Destroy(A)
3.GetValue(A,e,index1,…,indexn)
4
4.SetValue(A,e,index1,…,indexn)
}ADT Array
第 5 章 数组和广义表 5.1 数组的定义和运算 类型特点: