下载文档原格式
第一章答案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+…….+a n x n的值p n(x0),并确定算法中每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能小，规定算法中不能使用求幂函数。
注意：本题中的输入为a i(i=0,1,…n)、x和n,输出为P n(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.7试分别以不同的存储结构实现单线表的就地逆置算法，即在原表的存储空间将线性表（a1,a2,…,a n）逆置为(a n,a n-1,…,a1)。
数据结构c语言版耿国华课后习题答案数据结构是计算机科学中非常重要的一门课程，它涉及到了计算机程序设计中的数据组织、存储和操作等方面。
而耿国华教授的《数据结构c语言版》是这门课程中的经典教材之一，它通过讲解各种数据结构的原理和实现方法，帮助学生更好地理解和掌握这门课程的知识。
本文将针对《数据结构c语言版》中的一些典型习题进行解答，帮助读者更好地理解和掌握这些知识点。
1. 线性表线性表是数据结构中最基本的一种数据结构，它包含了顺序表和链表两种实现方式。
在习题中，我们需要实现线性表的基本操作，如插入、删除、查找等。
通过编写代码，我们可以更好地理解这些操作的实现原理和思路。
2. 栈和队列栈和队列是线性表的特殊形式，它们分别具有“先进后出”和“先进先出”的特点。
在习题中，我们需要实现栈和队列的基本操作，如入栈、出栈、入队、出队等。
通过编写代码，我们可以更好地理解这些操作的实现方法和应用场景。
3. 树和二叉树树是一种非线性的数据结构，它具有层次关系。
二叉树是树的一种特殊形式，它每个节点最多只有两个子节点。
在习题中，我们需要实现树和二叉树的基本操作，如创建、插入、删除、遍历等。
通过编写代码，我们可以更好地理解这些操作的实现原理和应用场景。
4. 图图是一种非线性的数据结构，它由节点和边组成。
在习题中，我们需要实现图的基本操作，如创建、插入、删除、遍历等。
通过编写代码，我们可以更好地理解这些操作的实现方法和应用场景。
5. 查找和排序查找和排序是数据结构中非常重要的一部分，它们在实际应用中具有广泛的应用。
在习题中，我们需要实现各种查找和排序算法，如顺序查找、二分查找、冒泡排序、快速排序等。
通过编写代码，我们可以更好地理解这些算法的实现原理和性能特点。
通过以上习题的解答，我们可以更好地理解和掌握《数据结构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. 栈题目：编写一个程序，实现对一个整型数组的栈操作（包括入栈、出栈和获取栈顶元素）。
第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个字符（结点大小为1）。
借助于前面的结点大小为1定义链串类型LKString。
【问题分析】该算法类同顺序串的简单模式匹配，实现匹配过程序需考虑链表的特征（从头比较的技术，指针保留的技术）。
[算法思想]：从主串s 的第1个字符和模式串t 的第一个字符开始比较，如果相等，就继续比较后续字符，如果不等，则从主串s 的下一个字符开始重新和模式串t 比较。
一直到模式串t 中的每一个字符依次和主串s 中的对应字符相等，则匹配成功，返回主串的当前起始位置指针。
如果主串中没有和模式串相同的子串，则称匹配不成功，返回空指针NULL。
[算法描述]：Link *StrIndex(LKString *s, LKString *t)/* 求模式串t 在主串s 中第一次出现的位置指针 */{Link *sp, *tp, *start;if (t->len == 0) return s->head->next; /* 空串是任意串的子串 */start = s->head->next; /* 记录主串的起始比较位置 */sp = start; /* 主串从start 开始 */tp = t->head->next; /* 模式串从第一个结点开始 */while(sp != NULL && tp != NULL){if (sp->ch == tp->ch) /* 若当前对应字符相同，则继续比较 */例题第四章 串课外作业{sp = sp->next;tp = tp->next;}else/* 发现失配字符，则返回到主串当前起始位置的下一个结点继续比较*/ {start = start->next; /* 更新主串的起始位置 */sp = start;tp = t->head->next; /* 模式串从第一个结点重新开始 * /}}if ( tp == NULL) return start;/* 匹配成功，返回主串当前起始位置指针 */else return NULL; /* 匹配不成功，返回空指针 */}【链串的模式匹配算法】。
第一章答案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+…….+a n x n的值p n(x0),并确定算法中每一语句的执行次数和整个算法的时间复杂度，要求时间复杂度尽可能小，规定算法中不能使用求幂函数。
注意：本题中的输入为a i(i=0,1,…n)、x和n,输出为P n(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.7试分别以不同的存储结构实现单线表的就地逆置算法，即在原表的存储空间将线性表（a1,a2,…,a n）逆置为(a n,a n-1,…,a1)。
第1章绪论1．4 试编写算法，求一元多项式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)。
通常算法的输入和输出可采用下列两种方式之一：（1）通过参数表中的参数显式传递。
（2）通过全局变量隐式传递。
试讨论这两种方法的优缺点，并在本题算法中以你认为较好的一种方式实现输入和输出。
void polyvalue(){int n,p,i,x,xp,sum;float a[];float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 to a%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue第二章线性表2．4设线性表存于a(1:arrsize)的前elenum个分量中且递增有序。
试写一算法，将X插入到线性表的适当位置上，以保持线性表的有序性。
Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) return ERROR;va.length++;for(i=va.length-1;va.elem[i]>x&&i>=0;i--)va.elem[i+1]=va.elem[i];va.elem[i+1]=x;return OK;}//Insert_SqList2．6已知线性表中的元素（整数）以值递增有序排列，并以单链表作存储结构。
第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）经由过程全局变量隐式传递.试评论辩论这两种办法的优缺陷,并在本题算法中以你以为较好的一种方法实现输入和输出.[提醒]：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;练习题设计实现抽象数据类型“有理数”.根本操纵包含有理数的加法.减法.乘法.除法,以及求有理数的分子.分母.第一章答案盘算下列程序中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+…….+a n x n的值p n(x0),并肯定算法中每一语句的履行次数和全部算法的时光庞杂度,请求时光庞杂度尽可能小,划定算法中不克不及应用求幂函数.留意：本题中的输入为a i(i=0,1,…n).x和n,输出为P n(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为中间,盘算待移动元素下标：已知线性表中的元素（整数）以值递增有序分列,并以单链表作存储构造.试写一高效算法,删除表中所有大于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;试分离以不合的存储构造实现线性表的当场逆置算法,即在原表的存储空间将线性表（a1, a2..., a n）逆置为（a n, a n-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,…,a m),B=(b1, b2,…,b n),试写一个按下列规矩归并A.B为线性表C的算法,使得：C= (a1, b1,…,a m, b m, b m+1,…,b n)当m≤n时;或者 C= (a1, b1,…,a n, b n, a n+1,…,a m) 当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);}试分离以不合的存储构造实现单线表的当场逆置算法,即在原表的存储空间将线性表（a1,a2,…,a n）逆置为(a n,a n-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;}}将线性表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;while(!EmptyStack(S)){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);}while(!EmptyStack(S)){Pop(&S, &d);EnterQueue(Q,d)}}将队列Q逆序.练习题1．回文断定.称正读与反读都雷同的字符序列为“回文”序列.试写一个算法,断定依次读入的一个以@为停滞符的字母序列,是否为形如‘序列1&序列2’模式的字符序列.个中序列1和序列2中都不含字符‘&’,且序列2是序列1的逆序列.例如,‘a+b&b+a’是属该模式的字符序列,而‘１+３&３－１’则不是.2．泊车场治理.设泊车场是一个可停放n辆车的狭长通道,且只有一个大门可供汽车进出.在泊车场内,汽车按到达的先后次序,由北向南依次分列（假设大门在最南端）.若车场内已停满n辆车,则后来的汽车需在门外的便道上等候,当有车开走时,便道上的第一辆车即可开入.当泊车场内某辆车要分开时,在它之落后入的车辆必须先退出车场为它让路,待该辆车开出大门后,其它车辆再按原次序返回车场.每辆车分开泊车场时,应按其逗留时光的长短交费（在便道上逗留的时光不收费）.试编写程序,模仿上述治理进程.请求以次序栈模仿泊车场,以链队列模仿便道.从终端读入汽车到达或离去的数据,每组数据包含三项：①是“到达”照样“离去”;②汽车派司号码;③“到达”或“离去”的时刻.与每组输入信息响应的输出信息为：假如是到达的车辆,则输出其在泊车场中或便道上的地位;假如是离去的车辆,则输出其在泊车场中逗留的时光和应交的费用.（提醒：需另设一个栈,临时停放为让路而从车场退出的车.）3．商品货架治理.,栈底商品的临盆日期比来.上货时,.用队列和栈作为周转,按,答复：（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).给出栈的两种存储构造情势名称,在这两种栈的存储构造中若何判别栈空与栈满？【解答】（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();。
第一章习题答案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、栈有顺序栈和链栈两种存储结构。
第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章绪论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.堆排序的过程、算法代码的阅读与设计。
