数据结构c语言版 (3)
数据结构—C语言描述(第三版)课件：串
（4） StrCopy(S,T) 初始条件: 串S存在 操作结果:由串T复制得串S
返回主目录
（5） StrEmpty(S)
初始条件: 串S存在
操作结果:若串S为空串,则返回TRUE,否则返回FALSE
（6）StrCompare(S,T)
初始条件: 串S和T存在
操作结果:若S>T,则返回值>0;若S=T,则返回值=0;若 S<T, 则返回值<0
（7）StrLength(S)
初始条件: 串S存在
返回主目录
操作结果:返回串S的长度,即串S中的元素个数
（8）StrClear(S)
初始条件: 串S存在
操作结果:将S清为空串 （9）StrCat(S,T)
初始条件: 串S和T存在
操作结果:将串T的值连接在串S的后面
（10）SubString(Sub,S,pos,len)
s->len+=t.len;
flag=1;
}
else if (s->len<MAXLEN) /*连接后串长大于MAXLEN，但串s的长度小于MAXLEN，
{
即连接后串t的部分字符序列被舍弃*/
for (i=s->len;i<MAXLEN;i++)
s->ch[i]=t.ch[i-s->len];
s->len=MAXLEN;
flag=0;
}
else flag=0; /* 串s的长度等于MAXLEN ,串t不被连接*/
return(flag);
}
（9）求子串函数
SubString(SString *sub, SString s, int pos, int len) /*将串s中下标pos起len个字符复制到sub中*/ { int i; if (pos<0 || pos>s.len || len<1 || len>s.len-pos) { sub->len=0; return(0); } else { for (i=0; i<len; i++) sub->ch[i]=s.ch[i+pos]; sub->len=len; return(1);
数据结构——用C语言描述(第3版)教学课件第3章 栈和队列
if(S->top==-1) /*栈为空*/
return(FALSE);
else
{*x = S->elem[S->top];
return(TRUE);
}
返回主目录}[注意]：在实现GetTop操作时，也可将参数说明SeqStack *S 改为SeqStack S，也就是将传地址改为传值方式。传 值比传地址容易理解，但传地址比传值更节省时间、 空间。
返回主目录
算法:
void BracketMatch(char *str) {Stack S; int i; char ch; InitStack(&S); For(i=0; str[i]!='\0'; i++) {switch(str[i])
{case '(': case '[': case '{':
3.1.3 栈的应用举例
1. 括号匹配问题
思想：在检验算法中设置一个栈，若读入的是左括号， 则直接入栈，等待相匹配的同类右括号；若读入的是 右括号，且与当前栈顶的左括号同类型，则二者匹配， 将栈顶的左括号出栈，否则属于不合法的情况。另外， 如果输入序列已读尽，而栈中仍有等待匹配的左括号， 或者读入了一个右括号，而栈中已无等待匹配的左括 号，均属不合法的情况。当输入序列和栈同时变为空 时，说明所有括号完全匹配。
return(TRUE);
}
返回主目录
【思考题】
如果将可利用的空闲结点空间组织成链栈来管理，则申 请一个新结点（类似C语言中的malloc函数）相当于链 栈的什么操作？归还一个无用结点（类似C语言中的 free函数）相当于链栈的什么操作？试分别写出从链栈 中申请一个新结点和归还一个空闲结点的算法。
数据结构——用C语言描述(第3版)教学课件第5章 数组与广义表
5.1 数组的定义和运算 5.2 数组的顺序存储和实现 5.3 特殊矩阵的压缩存储
5.3.1 三角矩阵 5.3.2 带状矩阵 5.3.3 稀疏矩阵 5.4 广义表 5.5 总结与提高
5.1 数组的定义和运算
数组是一种数据类型。从逻辑结构上看，数组可以 看成是一般线性表的扩充。二维数组可以看成是线 性表的线性表。例如：
Am×n=
a12 a12 ┅
a1j
┅ a1n
a21 a22 ┅
a2j
┅ a2n
┇┇
ai1 ai2 ┅
aij
┇┇
┅ ain
am1 am2 ┅
amj
┅ amn
矩阵Am×n看成n个列向量的线性表,即j=(a1j,a2j, …,amj)
我们还可以将数组Am×n看成另外一个线性表: B=(1，,2,，… ，m)，其中i（1≤i ≤m）本身也是一个线性表， 称为行向量，即： I= （ai1，ai2， …，aij ，…，ain）。
Loc[j1,j2,j3]=Loc[c1,c2,c3]+ α1*(j1-c1)+ α2*(j2-c2)+ α3(j3-c3)
=Loc[c1,c2,c3]+ Σαi*(ji-ci) （1≤i≤3）
由公式可知Loc[j1,j2,j3]与j1,j2,j3呈线性关系。 对于ｎ维数组A(c1:d1,c2:d2，…,cn,dn)，我们只要把上式推 广，就可以容易地得到ｎ维数组中任意元素aj1j2…jn的存储 地址的计算公式。
疏矩阵。
0 12 9 0 0 0 0
0 0 3 0 0 15
0 0 0 00 0 0
12 0 0 0 18 0
M6×7= -3 0 0 0 0 14 0
数据结构(C语言版)_第3章 串与数组
char data; struct lnode *next;
}lstring;
3.3.3 串的存储结构——链式存储结构
当结点大小>1时，可以采用块链结构。
#define CHUNKSIZE 100
/*可由用户定义块的大小*/
typedef struct Chunk
第三章 串与数组
本章要点
➢字符串的基本概念与基本运算 ➢字符串的存储和基本运算的实现 ➢数组的概念和基本运算 ➢数组的存储结构 ➢特殊矩阵的压缩存储及运算 ➢广义表的概念及相关术语 ➢广义表的存储形式
3.1 “文学研究助手”案例导入
“文学研究助手”引例：请从下面的英文文章里，统计其中 good出现的次数和位置，并查找单词the所在的行号，该行中出 现的次数以及在该行中的相应位置。
3.4.1 数组的定义
数组是n个具有相同类型的数据元素构成的有限序列，数组 中的数据是按顺序存储在一块地址连续的存储单元中。
数组中的每一个数据通常称为数组元素，数组元素用下标 区分，其中下标的个数由数组的维数决定。
若线性表中的数据元素为非结构的简单元素，则称为一维 数组，又称为向量；若一维数组中的数据元素又是一维数组结 构，则称为二维数组；依次类推，若二维数组中的元素又是一 个一维数组结构，则称作三维数组。
3.3.4 串的基本操作的实现算法
第二种顺序存储方式下几种基本操作的算法
算法1：串连接操作 算法2：串比较操作 算法3：取子串操作 算法4：串插入操作 算法5：串删除操作 算法6：串置换函数 算法7：子串定位操作
3.3.5 串的应用
【例3-1】设计一个算法求串s中出现的第1个最长重复子串 及其位置。
B-树的基本操作_数据结构（C语言版）（第3版）_[共4页]
![B-树的基本操作_数据结构（C语言版）（第3版）_[共4页]](https://img.taocdn.com/s3/m/c289f4d290c69ec3d4bb750e.png)
217 动态索引结构在文件创建、初始装入记录时生成，在系统运行过程中插入或删除记录时，索引结构本身也可能发生改变，以保持较好的检索性能。
9.6.1 B-树的定义B-树是一种平衡的多路查找树，在文件系统中，已经成为索引文件的一种有效结构，并得到了广泛的应用。
在此先介绍这种树的结构及其基本运算。
一棵m 阶（m ≥3）B-树，或为空树，或为满足下列特性的m 叉树。
（1）树中每个结点至多有m 棵子树。
（2）若根结点不是叶子结点，则至少有两棵子树。
（3）所有的非终端结点中包含下列信息：(n ，p 0，k 1，p 1，k 2，p 2，…，k n ，p n )其中，k i （1≤i ≤n ）为关键字，且k i <k i +1（1≤i ≤n ）；p j （0≤j ≤n ）为指向子树根结点的指针，且p j （0≤j <n ）所指子树中所有结点的关键字均小于k j +1，p n 所指子树中所有结点的关键字均大于k n ，n （⎡m /2⎤ −1≤n ≤m −1）为关键字的个数（n +1为子树个数）。
（4）除根结点之外所有的非终端结点至少有⎡m /2⎤棵子树，也即每个非根结点至少应有⎡m /2⎤ −1个关键字。
（5）所有的叶子结点都出现在同一层上，并且不带信息（可以看作是外部结点或查找失败的结点，实际上这些结点不存在，指向这些结点的指针为空）。
例如，图9.16所示的是一棵3阶B-树，除根和叶子结点外，每个结点有⎡3/2⎤到3个子树，有1～2个关键字。
图9.16 一棵3阶的B-树9.6.2 B-树的基本操作下面介绍在B-树上进行查找、插入和删除等基本运算的算法。
1．基于B-树的查找运算在B-树中查找给定关键字的方法类似于二叉排序树上的查找，不同的是在每个结点上确定向下查找的路径不一定是二路的，而是n +1（n 为当前结点关键字的个数）路的。
假设查找一个给定关键字为k 的元素，首先在根结点的关键字序列k 1，k 2，…，k j 中查找k ，由于这个关键字序列是有序向量，因此既可采用顺序检索，又可采用二分检索法。
数据结构(c语言版)课后习题答案完整版
数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念，用来组织和存储数据，使之可以高效地访问和操作。
在C语言中，我们可以使用不同的数据结构来解决各种问题。
本文将提供完整版本的C语言数据结构的课后习题答案。
二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表，其中的元素在物理内存中连续地存储。
在C 语言中，我们可以通过定义结构体和使用指针来实现顺序表。
以下是顺序表的一些基本操作的答案：（1）初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```（2）插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```（3）删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```（4）查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素，返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答（1）逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```（2）顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。
数据结构(c语言版)第三版习题解答
void verge(seqlist *L)
{int t,i,j; i=0; j=L->length-1; while (i<j) { t=L->data[i]; L->data[i++]=L->data[j]; L->data[j--]=t; }
}
2.5已知一个顺序表中的各结点值是从小到大有序的，设计一个算法，插入一个值为x的结点，
3
第2章 线性表及其顺序存储
2.1 选择题 （1）表长为n的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，
插入一个元素所需移动元素的平均个数为（ E ），删除一个元素所需移动元素的平均个数 为（ A ）。
A．（n− 1）/2 B．n C．n+1 D．n− 1 E．n/2 F．(n+1)/2 G．(n− 2)/2 （2）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5和e6依次通过栈S， 一个元素出栈后即进入队列Q，若6个元素出队的序列为e2、e4、e3、e6、e5和e1，则栈S 的容量至少应该为（ C ）。 A．6 B．4 C．3 D．2 （3）设栈的输入序列为1、2、3… n，若输出序列的第一个元素为n，则第i个输出的元素为 （ B ）。
表1-1常用的渐进函数 函数 名称
1 常数 logn 对数
n 线性 nlogn n个logn
n2 平方 n3 立方 2n 指数 n! 阶乘 1.9 算法的空间复杂度指的是什么？如何表示？ 【答】：算法的空间复杂度是指算法在执行过程中占用的额外的辅助空间的个数。可以将它表 示为问题规模的函数，并通过大写O符号表示空间复杂度。 1.10 对于下面的程序段，分析带下划线的语句的执行次数，并给出它们的时间复杂度T(n)。 （1） i++; （2） for(i=0;i<n;i++) if (a[i]<x) x=a[i]; （3）for(i=0;i<n;i++) for(j=0;j<n;j++) printf(“%d”,i+j); （4）for (i=1;i<=n-1;i++) { k=i; for(j=i+1;j<=n;j++) if(a[j]>a[j+1]) k=j; t=a[k]; a[k]=a[i]; a[i]=t; } （5）for(i=0;i<n;i++) for(j=0;j<n;j++) {++x;s=s+x;} 【答】：（1）O（1）；（2）O（n）；（3）O（n2）；（4）O（n2）；（5）O（n2）
全套电子课件：数据结构(C语言版)(第三版)
例 计算f=1！+2！+3！+…+n！， 用C语言描述。
void factorsum（n） int n；{int i，j；int f，w； f=0； for （i=1，i〈=n；i++） {w=1； for （j=1，j〈=i；j++） w=w*j； f=f+w；} return；
1.2 数据结构的发展简史及其 在计算机科学中所处的地位
• 发展史： 1、 “数据结构”作为一门独立的课程在国外是从1968年才开始设
立的。 2、 1968年美国唐·欧·克努特教授开创了数据结构的最初体系，他所
著的《计算机程序设计技巧》第一卷《基本算法》是第一本较 系统地阐述数据的逻辑结构和存储结构及其操作的著作。
⑵ while语句
while （〈条件表达式〉） { 循环体语句； }
• while循环首先计算条件表达式的值，若条件表达式的值非零， 则执行循环体语句，然后再次计算条件表达式，重复执行，直 到条件表达式的值为假时退出循环，执行该循环之后的语句。
⑶ do-while语句
do { 循环体语句 } while（〈条件表达式〉）
• 地位： 1、“数据结构”在计算机科学中是一门综合性的专业基础课。
2、数据结构是介于数学、计算机硬件和计算机软件三者之间 的一门核心课程。
3、数据结构这一门课的内容不仅是一般程序设计（特别是非 数值性程序设计）的基础，而且是设计和实
1.3 什么是数据结构
• 解决非数值问题的算法叫做非数值算法，数据处理方面的算法都 属于非数值算法。例如各种排序算法、查找算法、插入算法、删 除算法、遍历算法等。
• 数值算法和非数值算法并没有严格的区别。
数据结构(c语言版)第三版习题解答
数据结构(c语言版)第三版习题解答数据结构（C语言版）第三版习题解答1. 栈(Stack)1.1 栈的基本操作栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作。
栈的基本操作有：（1）初始化栈（2）判断栈是否为空（3）将元素入栈（4）将栈顶元素出栈（5）获取栈顶元素但不出栈1.2 栈的实现栈可以使用数组或链表来实现。
以数组为例，声明一个栈结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储栈中的元素int top; // 栈顶指针} Stack;```1.3 栈的应用栈在计算机科学中有广泛的应用，例如计算表达式的值、实现函数调用等。
下面是一些常见的栈应用：（1）括号匹配：使用栈可以检查一个表达式中的括号是否匹配。
（2）中缀表达式转后缀表达式：栈可以帮助我们将中缀表达式转换为后缀表达式，便于计算。
（3）计算后缀表达式：使用栈可以方便地计算后缀表达式的值。
2. 队列(Queue)2.1 队列的基本操作队列是一种按照先进先出（FIFO）原则的线性表，常用的操作有：（1）初始化队列（2）判断队列是否为空（3）将元素入队（4）将队头元素出队（5）获取队头元素但不出队2.2 队列的实现队列的实现一般有循环数组和链表两种方式。
以循环数组为例，声明一个队列结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储队列中的元素int front; // 队头指针int rear; // 队尾指针} Queue;```2.3 队列的应用队列在计算机科学中也有广泛的应用，例如多线程任务调度、缓存管理等。
下面是一些常见的队列应用：（1）广度优先搜索：使用队列可以方便地实现广度优先搜索算法，用于解决图和树的遍历问题。
（2）生产者-消费者模型：队列可以用于实现生产者和消费者之间的数据传输，提高系统的并发性能。
数据结构(C语言版)第三四章习题答案解析
第3章栈和队列习题1．选择题（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（）种情况。
A．5，4，3，2，1 B．2，1，5，4，3 C．4，3，1，2，5 D．2，3，5，4，1（2）若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为（）。
A．i B．n-i C．n-i+1 D．不确定（3）数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（）。
A．r-f B．(n+f-r)%n C．n+r-f D．（n+r-f)%n （4）链式栈结点为：(data,link)，top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（）。
A．x=top->data;top=top->link； B．top=top->link;x=top->link；C．x=top;top=top->link； D．x=top->link；（5）设有一个递归算法如下int fact(int n) { //n大于等于0if(n<=0) return 1;else return n*fact(n-1); }则计算fact(n)需要调用该函数的次数为（）。
A． n+1 B． n-1 C． n D． n+2 （6）栈在（）中有所应用。
A．递归调用 B．函数调用 C．表达式求值 D．前三个选项都有（7）为解决计算机主机与打印机间速度不匹配问题，通常设一个打印数据缓冲区。
主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。
该缓冲区的逻辑结构应该是（）。
A．队列 B．栈 C．线性表 D．有序表（8）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5和e6依次进入栈S，一个元素出栈后即进入Q，若6个元素出队的序列是e2、e4、e3、e6、e5和e1，则栈S的容量至少应该是（）。
习 题_数据结构（C语言版）（第3版）_[共2页]
![习 题_数据结构（C语言版）（第3版）_[共2页]](https://img.taocdn.com/s3/m/ac273818a1c7aa00b42acb35.png)
260{ /*按最低位优先依次对各关键字进行分配和收集*/distribute(r,i); /*第i趟分配*/collect(r); /*第i趟收集*/}}算法10.15 静态链式基数排序算法从上面链式基数排序算法中可以看出，算法10.13中的分配过程和记录的个数有关，其时间复杂度为O(n)，算法10.14中的收集过程和各位排序码的取值范围中值的个数rd（十进制为10）有关，其时间复杂度为O(rd)，静态链式基数排序要进行b趟收集和b趟分配，故基数排序的时间复杂度为O(b(n + rd))。
静态链式基数排序除了需2rd（这里是2∗10）个队列指针的存储空间外，还增加了n个link 指针域的存储空间。
静态链式基数排序是一种稳定的排序方法。
10.1 选择题。
（1）下列序列中，（ ）是执行第一趟快速排序后得到的序列。
A．[da,ax,eb,de,bb]ff[ha,gc] B．[cd,eb,ax,da]ff[ha,gc,bb]C．[gc,ax,eb,cd,bb]ff[da,ha] C．[ax,bb,cd,da]ff[eb,gc,ha]（2）下列说法错误的是（ ）。
A．冒泡排序在数据有序的情况下具有最少的比较次数。
B．直接插入排序在数据有序的情况下具有最少的比较次数。
C．二路归并排序需要借助O（n）的存储空间。
D．基数排序适合于实型数据的排序。
（3）下面的序列中初始序列构成最小堆（小根堆）的是（ ）。
A．10、60、20、50、30、26、35、40B．70、40、36、30、20、16、28、10C．20、60、50、40、30、10、8、72D．10、30、20、50、40、26、35、60（4）在下列算法中，（ ）算法可能出现下列情况：在最后一趟开始之前，所有的元素都不在其最终的位置上。
A．堆排序B．插入排序C．冒泡排序D．快速排序（5）若需在O（n log n）的时间内完成对数组的排序，且要求排序算法是稳定的，则可选择的排序方法是（ ）。
数据结构(C语言版)(第3版)
推荐
《数据结构（C语言版第3版）》特点： （1）.结构合理、内容紧凑、知识连贯、逻辑性强，并且配有学习与实验指导书，便于学生学习和实践。 （2）.所有算法都用C语言函数实现，并在TurboC2.0系统下通过调试，无须修改就可被其他函数调用，避免 了使用伪算法给学生学习带来的不便。 （3）.例题经典且配有精选的大量习题，既可以使学生快速掌握所学的知识，又能培养学生的应用和创新能 力。 （4）.电子教案及程序源代码可在清华大学出版社网站下载。 层次分明，结构严谨，语言简炼，图文并茂。 全部算法都用C语言编写，并在TurboC下调试通过，算法描述简捷易懂。 适合作为计算机及相关专业的教材，也可作为自学或各种计算机培训班的教材。
数据结构（C语言版）（第3版）
2015年清华大学出版社出版的图书
01 内容简介
03 作者简介
目录
02 推荐 04 图书目录 Nhomakorabea《数据结构（C语言版）（第3版）》是2015年8月1日清华大学出版社出版的图书，作者是秦玉平、马靖善。
内容简介
数据结构是计算机及其相关专业的核心课程，是计算机程序设计的基础，也是程序员考试和许多高校研究生 入学考试的必考科目。全书共10章。第1章是数据结构的概述；第2～10章分别讨论了顺序表、链表、栈、队列、 串、数组、广义表、树、二叉树、图、查找、内部排序、外部排序和文件等基本类型的数据结构。本书中的算法 都已经过调试，不必修改就能在Turbo C 2.0系统下正常运行。本书可作为计算机及相关专业的教材，也可作为 自学或各种计算机培训班的教材。
作者简介
秦玉平教授，计算机专业博士，辽宁省教学名师，硕士生导师，多年从事计算机算法与程序设计类课程的教 学与研究。
马靖善教授，计算机专业硕士，多年从事计算机教学管理工作和算法与程序设计类课程的教学与研究。
数据结构(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语言描述(第3版)教学课件第6章 树与二叉树
6.2 二叉树 6.2.1 二叉树的定义与基本操作 6.2.2 二叉树的性质 6.2.3 二叉树的存储结构
6.2.1 二叉树的定义与基本操作 定义：我们把满足以下两个条件的树型结构叫做二 叉树（Binary Tree）： （1）每个结点的度都不大于2； （2）每个结点的孩子结点次序不能任意颠倒。
有序树：在树T中，如果各子树Ti之间是有先后次序的，则称为有序树。 森林：m（m≥0）棵互不相交的树的集合。将一棵非空树的根结点删去，树就变成一 个森林；反之，给森林增加一个统一的根结点，森林就变成一棵树。
同构：对两棵树，通过对结点适当地重命名，就可以使两棵树完全相等（结点对应相 等，对应结点的相关关系也像等），则称这两棵树同构。
二叉树的基本结构由根结点、左子树和右子树组成
如图示
LChild Data RChild
Data
LChild RChild
用L、D、R分别表示遍历左子树、访问根结点、遍 历右子树，那么对二叉树的遍历顺序就可以有：
(1) 访问根，遍历左子树，遍历右子树(记做DLR)。 (2) 访问根，遍历右子树，遍历左子树(记做DRL)。 (3) 遍历左子树，访问根，遍历右子树(记做LDR)。 (4) 遍历左子树，遍历右子树，访问根 (记做LRD)。 (5) 遍历右子树，访问根，遍历左子树 (记做RDL)。 (6) 遍历右子树，遍历左子树，访问根 (记做RLD)。
(8) NextSibling（Tree，x）： 树Tree存在，x是Tree中的某个结点。若x不 是其双亲的最后一个孩子结点，则返回x后面的下一个兄弟结点，否则 返回“空”。
基本操作:
(9) InsertChild（Tree，p，Child）： 树Tree存在，p指向Tree 中某个结点，非空树Child与Tree不相交。将Child插入Tree中， 做p所指向结点的子树。
数据结构实用教程(C语言版) 第3章 栈和队列
3.1.1 栈的概念
假设有一个栈S=（a1，a2，…，an），栈 中元素按a1，a2，…，an的次序进栈后， 进栈的第一个元素a1为栈底元素，出栈的第 一个元素an为栈顶元素，也就是出栈的操作 是按后进先出的原则进行的，其结构如图31所示。
图3-1栈结构示意图
返回到本节目录
3.1.2栈的基本操作
3.1.3顺序栈
由于栈是操作受限制的线性表，因此与线性表类似，栈也 有两种存储结构，即顺序存储结构和链式存储结构。 1. 顺序栈的定义 栈的顺序存储结构称为顺序栈。类似于顺序表的类型定义，顺 序栈是用一个预设的足够长度的一维数组和一个记录栈顶元素 位置的变量来实现。顺序栈中栈顶指针与栈中数据元素的关1.3顺序栈
3. 顺序栈的基本操作实现
（3）进栈操作 进栈操作的过程如图3-3所示。先判断栈S如图3-3（a） 是否为满，若不满再将记录栈顶的下标变量top加1如 图3-3（b），最后将进栈元素放进栈顶位置上如图33（c）所示，算法描述见算法3.3。
图3-3 进栈操作过程图
返回到本节目录
栈除了在栈顶进行进栈与出栈外，还有初始化、判空 等操作，常用的基本操作有： （1）初始化栈InitStack(S)。其作用是构造一个空 栈 S。 （2）判断栈空EmptyStack(S)。其作用是判断是 否是空栈，若栈S为空，则返回1；否则返回0。 （3）进栈Push(S,x)。其作用是当栈不为满时，将 数据元素x插入栈S中，使其为栈S的栈顶元素。 （4）出栈Pop(S,x)。其作用是当栈S不为空时，将 栈顶元素赋给x，并从栈S中删除当前栈顶元素。 （5）取栈顶元素GetTop(S,x)。其作用是当栈S不 为空时，将栈顶元素赋给x并返回，操作结果只是 读取栈顶元素，栈S不发生变化。 返回到本节目录
数据结构—C语言描述(第三版)课件：内部排序
一个大根堆和一个小根堆的示例见p242的图9.7所示。
98
77
35
14
48
35
62
55
14
35
62
55
98
35
48 (a) 一个大根堆
77 (b) 一个小根堆
堆排序的过程主要需要解决两个问题：(1) 按堆定义 建初堆（2）去掉最大元之后重建堆，得到次大元。
问题1:当堆顶元素改变时，如何重建堆?
首先将完全二叉树根结点中的记录移出，该记录称为待 调整记录。此时根结点相当于空结点。从空结点的左、右子 中选出一个关键字较小的记录，如果该记录的关键字小于待 调整记录的关键字，则将该记录上移至空结点中。此时，原 来那个关键字较小的子结点相当于空结点。重复上述移动过 程，直到空结点左、右子的关键字均不小于待调整记录的关 键字。此时，将待调整记录放入空结点即可。上述调整方法 相当于把待调整记录逐步向下“筛”的过程，所以一般称为 “筛选”法。
表插入排序算法
void SLinkListSort(RecordType1 r[],int length)
{
int n=length;
r[0].next=n; r[n].next=0;
for ( i=n-1 ; i>= 1; --i)
{ p= r[0].next； q=0;
while( p>0 && r[p].key< r[i].key ) /* 寻找插入位置 */
9.2.3 表插入排序
表插入排序是采用链表存储结构进行插入排序的方法。 表插入排序的基本思想是：先在待插入记录之前的有序子链 表中查找应插入位置，然后将待插入记录插入链表。
类型说明如下： typedef int KeyType; typedef struct {
数据结构c语言版试题大全(含答案)
数据元素之间的关系
7
下面说法错误的是_______。
（1）算法原地工作的含义是指不需要任何额外的辅助空间 （2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法。（3）所谓时间复杂度是指最坏情况下，估计算法执行时间的一个上界。（4）同一个算法，实现语句的级别越高，执行效率越低（此选项错误，因为执行效率与实现语句的级别不一定直接相关）
push和pop
37
在C语言中，使用____关键字可以为结构体成员创建一个别名。
typedef
38
二叉搜索树的特点是，对于任意节点，其左子树中的所有节点的值都____该节点的值，而其右子树中的所有节点的值都____该节点的值。
小于，大于
39
图的遍历算法主要有____和____两种。
深度优先搜索，广度优先搜索
15
数据采用链式存储结构时，要求______。
结点的最后一个数据域是指针类型
16
数据的运算______。
效率与采用何种存储结构有关
17
下列说法中，不正确的是______。
数据项可由若干个数据元素构成
18
不是算法的基本特性______。
长度有限
19
计算机中算法指的是解决某一问题的有限运算序列，它必须具备输入、输出、______。
数据的存储结构
4
在以下的叙述中，正确的是_____。
（根据实际题目提供的选项选择正确答案，例如：线性表的线性存储结构并不一定优于链表存储结构等）
5
在决定选取何种存储结构时，一般不考虑_______。
（根据实际题目提供的选项选择正确答案，例如：一般不考虑各结点的值如何、结束个数的多少等具体数据特性）
数据结构c语言版第三版习题解答
数据结构c语言版第三版习题解答数据结构是计算机科学中非常重要的一门学科，它研究如何在计算机中存储和组织数据，以便有效地进行检索和操作。
数据结构的知识对于编写高效的程序和解决复杂的问题至关重要。
在学习和理解数据结构的过程中，解决习题是一种非常有效的方法。
本文将为读者提供《数据结构C语言版（第三版）》习题的解答。
1. 第一章：绪论第一章主要介绍了数据结构的基本概念和内容，包括算法和数据结构的概念、抽象数据类型（ADT）以及算法的评价等。
习题解答中，我们可以通过分析和讨论的方式对这些概念进行加深理解。
2. 第二章：算法分析第二章主要介绍了算法的基本概念和分析方法，包括时间复杂度和空间复杂度的计算方法。
习题解答中，我们可以通过具体的算法实例来计算其时间和空间复杂度，加深对算法分析的理解。
3. 第三章：线性表第三章主要介绍了线性表的概念和实现，包括顺序表和链表两种实现方式。
习题解答中，我们可以通过编写代码实现线性表的基本操作，并分析其时间和空间复杂度。
4. 第四章：栈和队列第四章主要介绍了栈和队列的概念和实现，包括顺序栈、链栈、顺序队列和链队列四种实现方式。
习题解答中，我们可以通过编写代码实现栈和队列的基本操作，并分析其时间和空间复杂度。
5. 第五章：串第五章主要介绍了串的概念和实现，包括顺序串和链串两种实现方式。
习题解答中，我们可以通过编写代码实现串的基本操作，并分析其时间和空间复杂度。
6. 第六章：树第六章主要介绍了树的概念和实现，包括二叉树、哈夫曼树和赫夫曼编码等内容。
习题解答中，我们可以通过编写代码实现树的基本操作，并分析其时间和空间复杂度。
7. 第七章：图第七章主要介绍了图的基本概念和实现，包括图的表示方法和图的遍历算法等。
习题解答中，我们可以通过编写代码实现图的基本操作，并分析其时间和空间复杂度。
8. 第八章：查找第八章主要介绍了查找算法的基本概念和实现，包括顺序查找、二分查找、哈希查找等内容。