数据结构习题集[1]

习题1
一、选择题
1 计算机算法必须具备输入、输出、（）等5个特性。

A 可行性、可移植性和可扩展性
B 可行性、确定性和有穷性
C 确定性、有穷性和稳定性
D 易读性、安全性和稳定性
2 在数据结构中，从逻辑上可以把数据结构分为（）
A 动态结构和静态结构
B 紧凑结构和非紧凑结构
C 内容结构和外部结构
D 线性结构和非线性结构
3 下面程序段的时间复杂性的量级为（）
For (i=1;i<=n;i++)
For(j=1;j<=I;j++)
For(k=1;k<=j;k++)
x=x+1;
A O(1)
B O(n)
C O(n2)
D O(n3)
4 在数据结构中，与所使用的计算机无关的是数据的（）结构
A 逻辑
B 存储
C 逻辑和存储
D 物理
5 数据结构在计算机中的表示是指（）
A 数据的逻辑结构
B 数据结构
C 数据的存储结构
D 数据元素之间的关系
6 下面（）的时间复杂性最好，即执行时间最短。

A O(n)
B O(logn)
C O(nlogn)
D O(n2)
7 下面程序段的时间复杂性的量级为（）。

Int fun(int n){
I=1,s=1;
While(s<n)
s+=++I;
return I;
}
A O(n/2)
B O(logn)
C O(n)
D O(n1/2)
8 下面程序段的时间复杂性的量级为（）。

For(int i=0;i<m;i++)
For(int j=0;j<n;j++)
A[i][j]=i*j;
A O(m3)
B O(n2)
C O(m*n)
D O(m+n)
9 执行下面程序段时，S 语句的执行次数为（）。

For(int i=1;i<n-1;i++)
For(int j=i+1;j<=n;j++)
S;
A n(n-1)/2
B n2/2
C n(n-1)/2
D n
二、简答题
1 数据的逻辑结构有哪几种？常用的存储有哪几种？
2 举一个数据结构的例子，叙述其逻辑结构、存储结构和运算三方面的内容。

3 什么叫算法？它有哪些特性
4 有下列几种用二元组表示的数据结构，画出它们分别对应的逻辑结构图，并指出它们分别以属于何种结构。

（1）A=(K,R),其中
K={a,b,c,d,e,f,g,h}
R={r}
r={<a,b>,<b,c>,<c,d>,<d,e>,<e,f>,<f,g>,<g,h>}
(2) B=(K,R),其中
K＝{a,b,c,d,e,f,g,h}
R={r}
r={<d,b>,<d,g>,<d,a>,<b,c>,<g,e>,<g,h>,<e,f>}
(3) B=(K,R),其中
K={1,2,3,4,5,6}
R={r}
r={(1,2),(2,3),(2,4),(3,4),(3,5),(3,6),(4,5),(4,6)}
三、计算题
设n为整数，求下列各程序段的时间复杂度
（1）i=1;k=2;
While(i<n){
k=k+10*I;
i=i+1;
}
(2)i=1;j=0;
While(i+j<=n)
If(i>j)j=j+1;
Else i=i+1;
(3)x=91;y=100
While(y>0)
If(x>100){
x=x-10;
y=y-1;
}else x=x+1;
习题2
一、选择题
1 线性表是（）
A 一个有限序列，可以为空
B 一个有限序列，不能为空
C 一个无限序列，可以为空
D 一个无限序列，不能为空
2 在一个长度为n的顺序表中，向第iI个元素（1≤i≤n+1）位置插入一个新元素时，需要从后向前依次后移（）个元素。

A n-i
B n-i+1
C n-i-1
D i
3 在一个顺序表的表尾插入一个元素的时间复度的量级为（）。

A O(n)
B O(1)
C O(n2)
D O(log n)
4 表长为n的顺序存储的线性表，当在任意位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均个数为（），删除一个元素需要移动元素的平均个数为（）
A (n-1)/2
B n
C (n+1)/2
D n/2
5 设单链表中指针p指向结点a，若要删除p之后的结点（若存在），则需修改指针的操作为（）。

A p->next=p->next->next
B p=p->next
C p=p->next->next
D next=p
6 单链表的存储密度为（）。

A 大于1
B 等于5
C 小于1
D 不能确定
7 在一个单链表中，若要在p所指向的结点之后插入一个新结点，则需要相继修改（）个指针域的值。

A 1
B 2
C 3
D 4
8 在一个单链表中，若要在p所指向的结点之前插入一个新结点，则此算法的时间复杂度的量级为（）。

A O(n)
B O(n/2)
C O(1)
D O(n1/2)
9 在一个带头结点的双向循环链表中，若要在p所指向的结点之前插入一个新结点，则需要相继修改（）个指针域的值。

A 2
B 3
C 4
D 6
二、简答题
1 什么叫线性表？它有哪些特点？
2 在链表的设计中，为什么通常采用带头结点的链表结构？
3 对比顺序表与单链表，说明顺序表与单链表的主要优点和主要缺点。

4 试编写算法实现顺序表的逆置，即把顺序表A中的数据元素（a1,a2, …,a n）逆置为（a n,a n-1, …,a1）。

5 已知A和B为两个非递减的线性表，现要求实现如下操作：从A中删除在B中出现的元素。

试编写在顺序表中实现上述操作的算法。

6 试编写算法实现链表的就地逆置(不增加存储空间)，即把链表A中的数据元素（a1,a2, …,a n）逆置为（a n,a n-1, …,a1）。

7 假设有两个非递减的线性表A 和B，均采用链式存储结构，试编写算法将A和B 归并成一个按元素非递减的线性表C。

8 试编写算法求单循环链表的表长。

习题3
一、选择题
1在栈顶一端可进行的全部操作是（）。

A 插入
B 删除C插入和删除D进栈
2 栈的特点是（）。

A 先进先出
B 后进先出C后进后出D不进不出
3 顺序栈是空栈的条件是（）。

A top==0
B top==1
C top==-1
D top==m
4 假定利用数组A[N]顺序存储一个栈，top表示栈顶指针，已知栈未满，则x入栈时所执行的操作是（）。

A a[--top]=x;
B a[top--]=x
C a[++top]=x
D a[top++]=x
5 一个栈的入栈序列是a,b,c,d,e，则不可能的出栈序列是（）。

A edcda
B dceab
C decba
D abcde
6 经过下列栈的运算后EmptyStack(s)的值是（）。

InitStack(s);Push(s,a);Push(s,b);Pop(s,x);Pop(s,x) ;
A a
B b
C 1
D 0
7 若已知一个栈的入栈序列是1,2,3, …,n，其输出序列为p1,p2,p3,…,p n，若p1=n,则p i为（）。

A i
B n-i
C n-i+1
D 不确定
8 队列的特点是（）。

A 先进先出
B 后进先出C先进后出 D 不进不出
9 循环队列S为满的条件是（）。

A S->rear==S->front
B S->rear+1)%maxsiae==s->front
C S->rear==0
D s->front==0
10 经过下列运算后GetHead(Q)的值是（）。

InitQueue(Q); EnQueue(Q,a); EnQueue(Q,b); DeQueue(Q,x);
A a
B b
C 1
D 2
二、简答题
1 简述栈与队列的相同点与不同点。

2 在顺序队列中，什么叫真溢出？什么叫假溢出？为什么顺序队列常都采用循环队列结构？
3 设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（不设头指针），试编写相应的入队列、出队列算法。

4 设计一个输出如下形式数值的递归算法。

4 4 4 4
3 3 3
2 2
1
5 编写一个算法，利用栈的基本运算返回指定栈中的栈底元素。

习题4
一、选择题
1 串是一种特殊的线性表，其特殊性体现在（）
A 唯一可以顺序存储
B 数据元素是一个字符
C 可以链接存储
D 数据元素可以是多个字符
2 下面（）是C语言中“abcd321ABCD”的子串。

A abcd
B 321AB
C “abcAB”
D “21AB”
3 设有两个串p和q，求p和q首次出现的位置的运算称作( )
A 连接
B 模式匹配
C 求子串
D 求串长
4 设有一个字符串S=“windows”，求子串的数目是（）
A 25
B 26
C 27
D 28
二、简答题
1 空串与空格串有什么区别？字符串中的空格有什么意思？空串在串的处理中有什么作用？
2串是由字符组成的，长度为1的串和字符是否相同？为什么？
3简述串的静态顺序存储结构与动态顺序存储结构有什么区别，分别写出它们的结构体定义。

4字符串采用静态顺序存储结构。

编写一个算法删除S中地i个字符到第j个字符。

5编写一个算法判断s2是否是s1的子串。

习题5
一、选择题
1．二维数组A行下标i的范围从1到12，列下标j的范围从3到10，采用行序为主序存储，每个数据元素占用4个存储单元，该数组的首地址（即A[1][3]的地址）为1200，则A[6][5]的地址为（）。

A 1400
B 1404
C 1372
D 1368
2．二维数组M的元素是4个字符（每个字符占一个存储单元）组成的串，行下标i的范围从0到4，列下标j的范围从0到5，M按行存储时元素M[3][5]的起始地址与M按列存储时元素（）的起始地址相同。

A M[2][4]
B M[3][4]
C M[3][5]
D M [4][4]
3．数组A中，每个元素A的长度为3个字节，行下标i从1到5，列下标j从1到6，从首地址开始连续存放在存储器内，存放该数组至少需要的单元数是（）。

A 90
B 70
C 50
D 30
4．设有10阶矩阵A，其对角线以上的元素a ij均取值为-3，其他矩阵元素为正整数，现在将矩阵A压缩存放在一维树组F[m]中，则m为（）。

A 45
B 46
C 55
D 56
5．若广义表A满足head(A)=tail(A),则A为（）。

A （）
B （（））
C （（），（））
D （（），（），（））
6．递归函数f(n)=f(n-1)+n(n>1)的递归出口是（）
A f(1)=0
B f(1)=1
C f(0)=1
D f(n)=n
二、简答题
1．什么叫二维数组的行序优先存储？什么叫二维数组的列序优先存储？
2．什么样的矩阵叫特殊矩阵？特殊矩阵压缩存储的基本思想是什么？
3．什么样的矩阵叫稀疏矩阵？稀疏矩阵压缩存储的基本思想是什么？
三、计算题
设有二维数组A（6*8），每个元素占4个字节，A[0][0]的起始地址为1000，计算
（1）数组A共占多少个字节；
（2）数组的最后一个元素A[5][7]的起始地址；
（3）按行优先存放时，元素A[1][4]的起始地址；
（4）按列优先存放时，元素A[4[7]的起始地址；
四、设计题
1．对于二维数组A[m][n]，其中m<=80，n<=80，先读入m和n ，然后读该数组的全部元素，对如下三种情况分别编写相应函数：
（1）求数组A靠边元素之和；
（2）求从A[0][0]开始的互不相邻的各元素之和；
（3）当m=n时，分别求两条对角线上的元素之和，否则打印出m!=n的信息。

2．有数组A[4][4]，把1到16个整数分别按顺序放入A[0][0]，……，A[0][3]，A[1][0]，……，A[1][3]，A[2][0]，……，A[2][3]，A[3][0]，……，A[3][3]中，编写一个函数获得数据并求出两条对角线元素的乘积。

习题6
一、选择题
1、下述编码中哪一个不是前缀编码（）
A、｛00，01，10，11｝
B、｛01，0，1，10｝
C、｛0，10，110，111｝
D、｛1，01，000，111｝
2、一棵二叉树第五层的结点数最多为（）
A、16
B、15
C、8
D、32
3、利用3、8、12、6这4个值作叶子结点的权，生成一棵哈夫曼树，该树的带权路径长度为（）
A、55
B、29
C、58
D、38
4、在线索化二叉树中，t所指节点没有左子树的充要条件是（）
A、t->left=NULL
B、t->ltag=1
C、t->ltag=1且t->left=NULL
D、以上都不对
5、设高度为h的二叉数上只有度为0和度为2的结点，则此类二叉树中所包含的结点数至少为（）
A、2h
B、2h -1
C、2h +1
D、h+1
6、已知某二叉树的后序遍历序列是dabec，中序遍历序列是debac，它的前序遍历序列是（）
A、acbed
B、decab
C、deabc D 、cedba
7、按照二叉树的定义，具有三个节点的二叉树有（）种
A、3
B、4
C、5
D、6
8、任意一棵二叉树的叶结点在先序、中序和后序遍历序列中的相对次序（）
A、不发生改变
B、发生改变
C、不能确定
D、以上都不对
9、对一个满二叉树，它有m个树叶，n个结点，深度为h，则（）
A、n=h+m B 、h+m=2n C、m=h-1 D 、n=2h-1
二、设计题
1、已知一棵树的边的集合表示为{（L,N）,（G,K）,（G,1）,（G,M）,（B,E）,（B,F）,（D,G）,（D,H）,（D,I）,（D,J）,（A,B）,（A,C）,（A,D）}。

画出这棵树并回答下面问题：
（1）树的根节点是哪个，哪些是叶子结点，哪些是非终端结点。

（2）树的深度是多少，各个结点的层数是多少。

（3）对于G结点，它的双亲结点、祖先结点、孩子结点、子孙结点、兄弟和堂兄弟分别是哪些结点。

2、给定二叉树的先序序列和中序序列，能否重构出该二叉树？给定二叉树的先序序列和后序序列呢？若不能，给出反例。

3、一棵深度为h的满二叉树具有如下性质：第h层上的结点都是叶结点，其余各层上每个结点都有m棵
非空子树。

若按层次从上到下，每层从左到右的顺序从1开始对全部结点编号，试计算：（1）第k层结点数（1＜＝k＜＝h）。

（2）整棵树结点数
（3）编号为i的结点的双亲结点的编号
（4）编号为i的结点的第j个孩子结点（若有）的编号
4、若7个带权结点，其权值分别为3，7，8，2，6，10，14，试以它们为叶结点构造一棵哈夫曼树（请按照每个结点的左子树根结点的权小于等于右子树根结点的权的次序构造），度计算出带权路径长度WPL及该树的结点总数。

5、假设二叉数采用链式存储结构，编写一个算法释放该二叉树所占用的全部结点。

6、编写一个计算一棵二叉树T的高度算法。

7、二叉树采用二叉树链表的结构存储，设计一个算法求二叉树中指定结点的层数。

习题7
一、选择题
1、在一个具有n个顶点的无向图中，要连接全部顶点至少需要（）条边。

A、n
B、n＋1
C、n－1
D、n/2
2、对于一个具有n个顶点的无向图，若采用邻接矩阵表示，则该矩阵的大小是（）
A、n
B、(n-1)/2
C、n-1
D、n2
3、具有6个顶点的无向图至少应用（）条边才能确保是一个连通图。

A、5
B、6
C、7
D、8
4、n个顶点的强连通图的邻接矩阵中至少有（）个非零元素。

A、n-1
B、n
C、2n-2
D、2n
5、在一个具有n个顶点的有向完全图中，所含的边数为（）
A、n
B、n(n-1)
C、n(n-1)/2
D、n(n+1)/2
6、在一个具有n个顶点和e条边的无向图的邻接矩阵中，表示边存在的元素（又称为有效元素）的个数为（）。

A、n
B、ne
C、e
D、2e
7、在一个具有n个顶点和e条边的有向图的邻接表中，保存顶点单链接的表头指针向量大小至少为（）
A、n
B、2n
C、e
D、2e
8、在一个具有n个顶点和e条边的无向图的邻接表中，边结点的个数为（）。

A、n
B、ne
C、e
D、e
9、对于一个有向图，若一个顶点的度为k1，出度为k2，则对应逆邻接表中该顶点单链表中的边结点数为（）
A、k1
B、k2
C、k1-k2
D、k1+k2
10、采用邻接表存储的图的深度优先遍历算法类似于二叉树的（）
A、接层遍历
B、中序遍历
C、先序遍历
D、后序遍历
11、无向图G＝（V，A），其中V＝｛a,b,c,d,e｝, A={<a,b>,<a,c>,<d,c>,<d,e>,<b,e>,<c,e>}
对该图进行扑拓排序，下面序列中（）不是拓扑序列。

A、adcbe
B、dabce
C、abdce
D、abcde
12、G是一个非连通无向图，共有28条边，则该图至少有（）个顶点。

A、7
B、8
C、9
D、10
二、简答题
1、对于一个有向图，不用拓扑排序，如何判定图中是否存在环？
2、用邻接矩阵表示图时，矩阵元素的个数与顶点个数是否相关？与边数是否相关？
习题8
一、选择题
1、若查找每个记录的概率均等，则在具有n个记录的连续顺序文件中采用顺序查找法查找一个记录，其
平均查找长度ASL为（）
A、（n-1）/2
B、n/2
C、(n+1)/2
D、n
2、下面关于二分查找叙述正确的是（）
A、表必须有序，表可以顺序方式存储，也可以链表方式存储
B、表必须有序且表中数据必须是整型，实型或字符型
C、表必须有序，而且只能从小到大排序
D、表必须有序，且表只能以顺序方式存储
3、当在一个有序的顺序存储表上查找一个数据时，既可用折半查找，也可用顺序查找，但前者比后者的查找速度（）
A、必定快
B、不一定
C、在大部分情况下要快
D、取决于表递增还是递减
4、具有12个关键字的有序表，折半查找的平均查找长度为（）
A、3.1
B、4
C、2.5
D、5
5、当采用分块查找时，数据的组织方式为（）
A、数据分成若干块，每块内数据有序
B、数据分成若干块，每块内数据不必有序，但块间必须有序
C、数据分成若干块，每块内数据有序，每块内最大（或最小）的数据组成索引块
D、数据分成若干块，每块（除最后一块外）中数据个数需相同
6、既希望查找速度快又便于线性表动态变化的查找方法有（）
A、顺序查找
B、折半查找
C、索引顺序查找
D、哈希法查找
7、分别以下序列构造二叉排序树，与用其他三个序列所构造的结果不同的是（）
A、（100，80，90，60，120，110，130）
B、（100，120，110，130，80，60，90）
C、（100，60，80，90，120，110，130）
D、（100，80，60，90，120，130，110）
二、简答题
1、什么叫动态查找？什么叫静态查找？什么样的存储结构适宜于进行静态查找？什么样的存储结构适宜
于进行动态查找？
2、什么叫平均查找长度？写出平均查找长度的定义
三、设计题
1、已知一个个数为12的数据元素序列为｛Dec,Feb,Nov,Oct,June,Sept,Aug,Apr,May,July,Jan,Mar｝，
要求（注意字母的大小是指字母的ASCII码数值大小）：
（1）按各数据元素的顺序构造一棵二叉排序树
（2）设各数据元素的查找概率相等，给出该二叉排序树的平均查找长度。

2、设有数据元素序列｛11，23，35，47，51，60，75，88，90，102，113，126｝，用除留余数法构
造哈希表，要求：
（1）设计哈希表的长度取值为m;
（2）画出用开放定址法的线性探查法解决哈希冲突的哈希表结构；
（3）画出用链表法解决哈希冲突的哈希表结构。

习题9
一、选择题
1、设有1000个无序的元素，希望用最快的速度挑出其中前10个最大的元素，最好（）排序法。

A、起泡排序
B、选择排序
C、堆排序
D、希尔排序
2、在待排序的元素序列基本有序的前提下，效率最高的排序方法是（）
A、插入排序
B、选择排序
C、快速排序
D、希尔排序
3、一组记录排序码为（46，79，56，38，40，84），则利用堆排序的方法建立的初始堆为（）
A、79，46，56，38，40，80
B、84，79，56，38，40，46
C、84，79，56，46，40，38
D、84，56，79，40，46，38
4、排序方法中，从未排序序列中依次取出元素与已排序序列（初始时为空）中的元素进行比较，将其放入已排序序列的正确位置上的方法，称为（）
A、希尔排序
B、起泡排序
C、插入排序
D、选择排序
5、下述几种排序方法中，要求内存量最大的是（）
A、插入排序
B、选择排序
C、快速排序
D、归并排序
6、下列四种排序方法中，不稳定的方法是（）
A、直接插入排序
B、冒泡排序
C、归并排序
D、直接选择排序
二、设计题
1、对给定的j（1<=j<=n），要求在无序的记录区R［1…n］中找到按关键字自小到大排在第j个位置上的记录（即在无序集合中找到第j个最小元），试利用快速排序的划分思想编写算法实现上述的查找操作。

2、以单链表为存储结构，写一个直接选择排序算法。

3、改写快速排序算法，要求采用三者取中的方式选择划分的基准记录；若当前被排序的区间长度小于等于3时，无须划分而是直接采用直接插入方式对其排序。

基础篇参考答案
习题1参考答案
一、选择题
1. B
2. D
3. D
4. A
5. C
6. B
7. D
8. C
9. A
二、简答题
1. 答：数据的逻辑结构通常有四种，即集合、线性结构、树形结构和图状结构。

存储结构主要有顺序存储结构和链式存储结构。

2. 答：比如一分通讯录，记录了相关人员的电话号码，将其按姓名一人占一行构成表，这个表就是一个数据结构。

每一行是一个记录，对于整个表来说，只有一个开始结点和一个终端结点，其它结点也只有一个前驱和一个后继。

这几个关系就确定了表的逻辑结构。

3. 答：算法是对特定问题求解步骤的一种描述，是指令的有限序列，其中每一条指令表示一个或多个操作。

算法具有有穷性、确定性、可行性、输入和输出5个特性。

4.答：
(1) A对应的逻辑图形如下图左，它是一种线性结构。

(2) B 对应的逻辑图形如上图右所示，它是一种树型结构。

(3) C 对应的逻辑图形如下图所示，它是一种图型结构。

三、计算题
解： (1) O(n) ； (2) O(n) ； (3) O(n 1/2)。

习题2参考答案
一、选择题
1. A
2. B
3. B
4. D A
5. A
6. C
7. B
8. A
9. C 二、简答题
1. 答：线性表是具有n 个数据元素的一个有限序列。

线性表的特点是：数据元素之间是一对一的关系。

除第一个元素外，每个元素有且只有一个直接前驱；除最后一个元素外，每个元素有且只有一个直接后继。

2. 答：头指针是链表的一个标识，它用来指向带头结点的链表中的头结点。

头结点是在链表的第一个数据元素之前附加的一个结点，它的作用是使对第一个结点的操作和其它结点一致，表空与非空时处理一致，不需要特殊处理，简化了操作。

3. 答：顺序表的特点是逻辑位置相邻的数据元素其物理位置也相邻，因此可以进行随机存储， 是一种随机存储结构。

其插入和删除操作的时间复杂度均为O(n)。

链表中的数据元素使用一组任意的存储单元存储，不要求逻辑位置相邻的数据元素物理位置也相邻，而是采用附加的指针表示元素之间的逻辑关系。

链表的插入和删除结点均不需要移动其他结点，但是，其查找运算必须从头指针开始顺序查找，其时间复杂度为O(n)。

4.
答：算法如下
void Convert(SqList &L){ int i,j,temp; j=L.length-1; i=0; while(i<j){ temp=L.elem[i]; L.elem[i]=L.elem[j]; L.elem[j]=temp; i++; j--;
}
} 5. 答：算法如下
void Delete(SqList &La,SqList Lb){ int i,j,k;
i=0;j=0; 1
2
3
4
6
5
while(i<La.length&&j<Lb.length){
if(La.elem[i]<Lb.elem[j]) i++;
else if(La.elem[i]>Lb.elem[j]) j++;
else ListDelete_Sq(La, i+1, k);
}
}
6.答：算法如下
void InvertList(LinkList &L){
LinkList p,q,r;
p = L->next;
q = p->next;
p->next=NULL;
while(q!=NULL){
r=q->next;
q->next=p;
p=q;
q=r;
}
L->next=p;
}
7. 答：算法如下
void MergeOrder(LinkList La,LinkList Lb){
LinkList pa,pb,Lc,pc;
pa=La->next;
pb=Lb->next;
Lc=pc=La;
while (pa&&pb){
if(pa->data <=pb->data ){
pc->next=pa;
pc=pa;
pa=pa->next;
}else{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
if (!pa) pc->next=pb;
else pc->next=pa;
}
8. 答：算法如下
int Length(LinkList L){
int i=0;
LinkList p;
p=L->next;
while(p){
p=p->next;
i++;
}
return i;
}
习题3参考答案
一、选择题
1. C
2. B
3. A
4. D
5. B
6. C
7. C
8. A
9. B 10. B
二、简答题
1. 答：栈是限定在表的一端进行插入和删除操作的线性表。

队列是只允许在表的一端进行插入，而在另一端进行删除元素的线性表。

栈的操作是按照后进先出原则进行的，因此又称作后进先出的线性表。

队列的操作是按照先进先出原则进行的，因此又称作先进先出的线性表。

2. 答：当front 0，rear=M时，再有元素入队发生溢出，称之为“假溢出”，存储空间还有剩余。

为了改进这种状况，可以将顺序队列想象为一个首尾相接的环状空间，称之为循环队列。

3. 答：
(1) 相应入队列操作
Status EnQueue_L (LinkQueue &Q, ElemType e) {
p = (QLink) malloc (sizeof (QNode));
p->data = e; p->next=Q->next;
Q->next = p;
Q = p;
return OK;
}
(2) 相应出队列的操作
Status DeQueue_L (LinkQueue &Q, ElemType &e) {
if (Q->next == Q) return ERROR;
p = Q.next->next;
e = p->data;
Q->next->next = p->next;
free(p);
return OK;
}
4.答：算法如下
void Print(int n){
int i;
if (n==0)
return;
for (i=1;i<=n;i++)
printf("%3d",n);
printf("\n");
Print(n-1);
}
5.答：算法如下
ElemType Bottom(Stack S){
ElemType x,y;
Stack T;
InitStack(T);
while (!StackEmpty(S)){
pop(S,x);
push(T,x);
}
while (!StackEmpty(T)){
pop(T,y);
push(S,y);
}
return x;
}
习题4参考答案
一、选择题
1. B
2. D
3. B
4. D
二、简答题
1. 答：长度为零的串称为空串，记作""。

空格也是串的字符集合中的一个元素，由一个或多个空格组成的串称为空格串。

例如" "，其长度为串中空格的个数。

2. 答：虽然串是由字符组成的，但串和字符是两个不同的概念。

串是长度不确定的字符序列，而字符只是一个字符。

即使是长度为1的串也与字符不同。

例如，串"a"和字符'a'就是两个不同的概念，因为在存储时串的结尾通常加上串结束标志'\0'。

3. 答：在串的顺序存储结构是用一维数组存放串中的字符。

一种方法是用静态内存分配的方法定义的数组，数组元素的个数是在编译时确定的，在运行时是不可改变的，称之为静态顺序存储。

另一种方法是用动态内存分配的方法定义的数组，数组元素的个数是在程序运行时用户申请确定的，称之为动态顺序存储。

4. 答：Status StrDelete (String &S,int i,int j){
int len;
len=j-i+1;
if (i<1 || i>S[0]|| j>S[0]) // 非法情况的处理
return ERROR;
S[pos..S[0]-len]=S[pos+len..S[0]]; // 将S中从下标从pos+len开始的元素前移len位
S[0]=S[0]-len; // 串长的处理
return OK;
}
5. 答：Status SubString(String S1,String S2){
int i,j,k,flag=0;
i=1;
while(i<S1[0]&&!flag){
j=1;
if(S1[i]==S2[j]){
k=i+1;j++;
while(S1[k]==S2[j]){
k++;j++;
}
if (j==s2[0]) flag=1;
else i++;
}
else i++;
}
return flag;
}
习题5参考答案
一、选择题
1. D
2. B
3. A
4. D
5. B
6. B
二、简答题
1. 答：所谓行序优先存储，其基本思想为：从第1行的元素开始按顺序存储，第1行元素存储完成后，再按顺序存储第2行的元素，然后依次存储第3行，……直到最后一行的所有元素存储完毕为止。

而列序优先存储即为：依次按顺序存储第1列，第2列，……直到最后一列的所有元素存储完毕为止。

2. 答：我们把相同的元素或零元素在矩阵中的分布有一定的规律的称为特殊矩阵。

压缩存储的原则是：对多个值相同的元素只存储一次，对零元素甚至不分配存储空间。

3. 答：矩阵中非零元素的个数远远小于矩阵元素的总数，这样的矩阵称为稀疏矩阵。

稀疏存储的原则是只存储非零元。

三、计算题
(1) 228 (2) 1282 (3) 1072 (4) 1276
四、设计题
1．void proc1(matrix A) /*第(1)题解*/
{
int s=0,i,j;
for(i=0;i<m;i++) /*第一列*/
s=s+A[i][1];
for(i=0;i<m;i++) /*最后一列*/
s=s+A[i][n];
for(j=0;j<n;j++) /*第一行*/
s=s+A[1][j];
for(j=0;j<m;j++) /*最后一行*/
s=s+A[m][j];
s=s-A[0][0]-A[0][n-1]-A[m-1][0]-A[m-1][n-1]; /*减去4个角的重复元素值*/
printf("s=%d\n",s);
}
void proc2(matrix A) /*第(2)题解*/
{
int s=0,i,j;
i=0;
while(i<m)
{
j=0;
while(j<n)
{
s=s+A[i][j];
j=j+2; /*跳过一列*/
}
i=i+2; /*跳过一行*/
}
printf("s=%d\n",s);
}
void proc3(matrix A) /*第(2)题解*/
{
int i,s;
if(m!=n) printf("m!=n");
else
{
s=0;
for(i=0;i<m;i++)
s=s+A[i][i]; /*求第一列对角线之和*/
for(i=0;i<n;i++)
s=s+A[n-i-1][i]; /*累加第二条对角线之和*/
printf("s=%d\n",s);
}
}
2．void mmult(){
matrix A;
int i,s;
for(i=0;i<4;i++)
for(j=0;j<4;j++)
scanf("%d",A[i][j];
s=1;
for(i=0;i<4;i++)
s=s*A[i][i];
for(i=0;i<4;i++)
s=s*A[3-i][i];
printf("两条对角线元素之积：%d\n",s);
}
习题6参考答案
一、选择题
1. B
2. A
3. A
4. B
5. B
6. D
7. C
8. A
9. D
二、设计题
1．答案略。

2. 解：给定二叉树的先序序列和中序序列可以重构出该二叉树；给定二叉树的先序序列和后序序列则不能构造出该二叉树。

反例为：
先序序列ab ，后序序列ba 可对应两棵二叉树。

3.解： (1)mk-1 (2)(mh-1)/(m-1)
(3)i=1时,该结点为根,无双亲结点;否则其双亲结点的编号为(i+m-2)/m (4)编号为i 的结点的第j 个孩子结点(若有)的编号为i*m+(j-(m-1)) 4. 解： 5.解：
void Release(BiTree T){ if (T!=NULL){ Release(T->lchild); Release(T->rchild); free(T);
} }
6. 解：
int Depth(BiTree T){ if (!T) return 0; // 如果T 为空，则其深度为0
else {
// 若T 不空返回其子树中深度较大值加1
if ( Depth(T->lchild) >= Depth(T->rchild))
return Depth(T->lchild)+1; else return Depth(T->rchild)+1;
}
} 7.解：
void Level(BiTree b,BiTree p, int *h,int lh){ if (b==NULL) *h=0;
else if(p==b) *h=lh;
52
23 29
10
13
5 6
2
3 14
15
7 8
else { Level(p,b->lchild,h,lh+1); if(*h==-1)
Level(p,b->rchild,h,lh+1);
}
}
习题7参考答案
一、选择题
1. C
2. D
3. A
4. B
5. B
6. D
7. A
8. D
9. C 10. C 11. D 12. C 二、简答题
1. 对于无向图，如果在深度优先遍历中遇到回边，则必定存在环。

对于有向图，如果从有向图的某个顶点v 出发的遍历，在DFS(v)结束之前出现了一条从顶点u 指向v 的回边，则此有向图必定存在环。

因为u 在深度优先生成树上是v 的子树，即存在u 到v 的路径，现在又出现一条从u 指向v 的弧，则它们必然构成一条回路。

2. 用邻接矩阵表示图时，矩阵元素的个数与顶点个数无关；但和边数有关。

习题8参考答案
一、选择题
1. C
2. D
3. B
4. A
5. B
6. D
7. C 二、简答题
1. 答：静态查找是指只在数据元素集合中查找是否存在关键字等于某个给定关键字的数据元素。

动态查找除包括静态查找的要求外，还包括在查找过程中同时插入数据元素集合中不存在的数据元素，或者从数据元素集合中删除已存在的某个数据元素的要求。

2. 答：为了确定要查找的记录位置，与给定值进行比较的关键字个数的期望值称为查找算法在查找成功时的平均查找长度ASL(Average Search Length)。

对于含有n 个记录的表，平均查找长度的计算公式为：
∑==n
i i
i C P ASL 1
其中，P i 为查找第i 个元素的概率。

三、设计题 1．解： 2.解：
(1) m 的取值为13 (2)
Dec
Aug Apr
Feb
Nov June Oct
July Jan
May
Sept
Mar
习题9参考答案
一、选择题
1. B
2. D
3. B
4. C
5. D
6. C
二、设计题
1.解：
int QuickSort(SeqList R,int j,int low,int high){
//对R[low..high]快速排序
int pivotpos; //划分后的基准记录的位置
if(low<high){//仅当区间长度大于1时才须排序
pivotpos=Partition(R,low,high); //对R[low..high]做划分
if (pivotpos==j) return r[j];
else if (pivotpos>j) return(R,j,low,pivotpos-1);
else return quicksort(R,j,pivotpos+1,high);
}
} //QuickSort
2.解：
void selectsort(linklist head){
RecNode *p,*q,*s;
if(head->next)&&(head->next->next){
p=head->next;//p指向当前已排好序最大元素的前趋
while (p->next){
q=p->next;s=p;
while(q){
if (q->key<s->key) s=q;
q=q->next;
}//endwhile
交换s结点和p结点的数据;
p=p->next;
}//endwhile
}//endif
}//endsort
3.解：
void QuickSort(SeqList R,int low ,int high){
//对R[low..high]快速排序
int pivotpos;
if(high-low<=2){//若当前区内元素少于3个
//则进行直接插入排序
InsertSort(R,low,high);
}else{
pivotpos=midPartion(R,low,high);
QuickSort(R,low,pivotpos-1);。