数据结构复习试题

复习试题

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

习题

11111
一、单选题
1、 栈和队列的共同特点是( A )。
A、只允许在端点处插入和删除元素 B、都是先进后出 C、都是先进先出 D、没有共同点
2、 用无头结点链接方式存储的队列，在进行插入运算时( D ).
A. 仅修改头指针 B、 头、尾指针都要修改 C. 仅修改尾指针 D、头、尾指针可能都要修改
3、 以下数据结构中哪一个是非线性结构？( D )
A、 队列 　　 B、 栈 C、 线性表 　　 D、 二叉树
4、 设有一个二维数组A[m][n]，假设A[0][0]存放位置在644(10)，A[2][2]存放位置在676(10)
每个元素占一个空间，问A[3]3存放在什么位置？脚注(10)表示用10进制表示。（ C ）
A、688 B、678 C、692 D、696
5、树最适合用来表示( C )。
A.有序数据元素 B.无序数据元素C.元素之间具有分支层次关系的数据 D.元素之间无联系的数据
6、 二叉树的第K层的结点数最多为( D ).
A、2k-1 B、2K+1 C、2K-1 +1 　　　 D、 2k-1
7、若有18个元素的有序表存放在一维数组A[19]中，第一个元素放A[1]中，现进行二分查找，则查找A［3］的比较序列的下标依次为( D )
A、 1，2，3 B、 9，5，2，3 C、 9，5，3 D、9，4，2，3
8、 对于线性表（7，34，55，25，64，46，20，10）进行散列存储时，若选用H（K）=K %9
作为散列函数，则散列地址为1的元素有（ D ）个，
A、1 B、2 C、3 D、4
10、设有6个结点的无向图，该图至少应有( A )条边才能确保是一个连通图。
A、5 B、6 C、7 D、8
二、填空题

1. 通常从四个方面评价算法的质量：（正确性）、（可读性）、（健壮性）和（效率与低存储量）。
2. 一个算法的时间复杂度为(n3+n2log2n+14n)/n2，其数量级表示为（ O(n) ）。
3. 假定一棵树的广义表表示为A（C，D（E，F，G），H（I，J）），则树中所含的结点数为（ 9 ）个，树的深度为（ 3 ），树的度为（ 3 ）。
4. 后缀算式9 2 3 + - 10 2 / -的值为（-1）。中缀算式（3+4X）-2Y/3对应的后缀算式为（3 4 X * + 2 Y * 3 / -）。
5. 若用链表存储一棵二叉树时，每个结点除数据域外，还有指向左孩子和右孩子的两个指针。在这种存储结构中，n个结点的二叉树共有（2n ）个指针域，其中有（n-1）个指针域是存放了地址，有（ n+1）个指针是空指针。
6. 对于一个具有n个顶点和e条边的有向图和无向图，在其对应的邻接表中，所含边结点分别有（e）个和（2e）个。
7. AOV网是一种（有向无回路）的图。
8. 在一个具有n个顶点的无向完全图中，包含有（ n(n-1)/2）条边，在一个具有n个顶点的有向完全图中，包含有（ n(n-1)）条边。
9. 假定一个线性表为(12,23,74,55,63,40)，若按Key % 4条件进行划分，使得同一余数的元素成为一个子表，则得到的四个子表分别为 （12，40）、（74）、（23,55，63）和（ ）。
10. 在堆排序的过程中，对任一分支结点进行筛选运算的时间复杂度为（ O(log2n)），整个堆排序过程的时间复杂度为（ O(nlog2n)）。
11. 在快速排序、堆排序、归并排序中，（归并）排序是稳定的。
    三、计算题
12. 在如下数组A中链接存储了一个线性表，表头指针为A[0].next，试写出该线性表。
    A 0 1 2 3 4 5 6 7
    data 60 50 78 90 34 40
    next 3 5 7 2 0 4 1
    参考答案：线性表为：（78，50，40，60，34，90）
    2、请画出下图的邻接矩阵和邻接表

参考答案：
邻接矩阵：
邻接表：

3、已知一个图的顶点集V和边集E分别为：V={1,2,3,4,5,6,7};
E={(1,2)3,(1,3)5,(1,4)8,(2,5)10,(2,3)6,(3,4)15,(3,5)12,(3,6)9,(4,6)4,(4,7)20,(5,6)18,(6,7)25};用克鲁斯卡尔算法得到最小生成树，试写出在最小生成树中依次得到的各条边。
参考答案：用克鲁斯卡尔算法得到的最小生成树为：
(1,2)3, (4,6)4, (1,3)5, (1,4)8, (2,5)10, (4,7)20
5、 画出向小根堆中加入数据4, 2, 5, 8, 3时，每加入一个数据后堆的变化。
参考答案：

四、阅读算法
1、LinkList mynote(LinkList L)
{//L是不带头结点的单链表的头指针
if(L&&L->next){
q=L；L=L－>next；p=L；
S1： while(p－>next) p=p－>next；
S2： p－>next=q；q－>next=NULL；
}
return L；
}
请回答下列问题：
（1）说明语句S1的功能。 （2）说明语句组S2的功能。
（3）设链表表示的线性表为（a1,a2, …,an）,写出算法执行后的返回值所表示的线性表。
参考答案：
（1）查询链表的尾结点
（2）将第一个结点链接到链表的尾部，作为新的尾结点
（3）返回的线性表为（a2,a3,…,an,a1）。

2、void ABC(BTNode * BT)
{
if BT {
ABC (BT->left);
ABC (BT->right);
cout<data<<’ ';
}
}
该算法的功能是：
参考答案：递归地后序遍历链式存储的二叉树
五、算法填空
二叉搜索树的查找——递归算法:
BOOL Find(BTreeNode* BST,ElemType& item)
{ if (BSTNULL)
return false; //查找失败
else {
if (itemBST->data){
item=BST->data;//查找成功
return ¬¬¬¬¬¬¬¬¬（ true ）;}
else if(itemdata)
return Find( BST->left ,item);
else return Find( BST->right ,item);
}//if
}
六、编写算法
统计出单链表HL中结点的值等于给定值X的结点数。
int CountX(LNode* HL,ElemType x)
参考答案：
int CountX(LNode* HL,ElemType x)
{ int i=0; LNode* p=HL;//i为计数器
while(p!=NULL)
{ if (P->data==x) i++;
p=p->next;
}//while, 出循环时i中的值即为x结点个数
return i;
}//CountX

2222
一、选择题
1．下面关于线性表的叙述错误的是（ D ）。
A、 线性表采用顺序存储必须占用一片连续的存储空间
B、 线性表采用链式存储不必占用一片连续的存储空间
C、 线性表采用链式存储便于插入和删除操作的实现
D、 线性表采用顺序存储便于插入和删除操作的实现
2．设哈夫曼树中的叶子结点总数为m，若用二叉链表作为存储结构，则该哈夫曼树中总共有（ B ）个空指针域。
A、 2m-1 B、 2m C、 2m+1 D、 4m
3．设顺序循环队列Q[0：M-1]的头指针和尾指针分别为F和R，头指针F总是指向队头元素的前一位置，尾指针R总是指向队尾元素的当前位置，则该循环队列中的元素个数为（ C ）。
A、 R-F B、 F-R C、(R-F+M)％M D、(F-R+M)％M
4．设某棵二叉树的中序遍历序列为ABCD，前序遍历序列为CABD，则后序遍历该二叉树得到序列为（A）。
A、 BADC B、 BCDA C、 CDAB D、CBDA
5．设某完全无向图中有n个顶点，则该完全无向图中有（ A ）条边。
A、 n(n-1)/2 B、 n(n-1) C、 n2 D、 n2-1
6．设某棵二叉树中有2000个结点，则该二叉树的最小高度为（ C ）。
A、 9 B、 10 C、 11 D、 12
7．设某有向图中有n个顶点，则该有向图对应的邻接表中有（B ）个表头结点。
A、 n-1 B、 n C、n+1 D、2n-1
8．设一组初始记录关键字序列(5，2，6，3，8)，以第一个记录关键字5为基准进行一趟快速排序的结果为（C）。
A、 2，3，5，8，6 B、 3，2，5，8，6
C、 3，2，5，6，8 D、 2，3，6，5，8
二、填空题

1. 为了能有效地应用HASH查找技术，必须解决的两个问题是（构造一个好的HASH函数）和（确定解决冲突的方法）。
2. 下面程序段的功能实现数据x进栈，要求在括号处填上正确的语句。
   typedef struct {int s[100]; int top;} sqstack;
   void push(sqstack &stack,int x)
   {
   if (stack.top==m-1) printf(“overflow”);
   else {（ stack.s[stack.top]=x ）;（ stack.top++） ;}
   }
3. 中序遍历二叉排序树所得到的序列是（有序）序列（填有序或无序）。
4. 快速排序的最坏时间复杂度为（ O(n2)），平均时间复杂度为（ O(nlog2n)）。
5. 设某棵二叉树中度数为0的结点数为N0，度数为1的结点数为N1，则该二叉树中度数为2的结点数为（ N0-1）；若采用二叉链表作为该二叉树的存储结构，则该二叉树中共有（2N0+N1）个空指针域。
6. 设某无向图中顶点数和边数分别为n和e，所有顶点的度数之和为d，则e=（ d/2）。
7. 设一组初始记录关键字序列为(55，63，44，38，75，80，31，56)，则利用筛选法建立的初始堆为 (31，38，44，56，75，80，55，63)。
   8． 已知一有向图的邻接表存储结构如下：从顶点1出发，DFS遍历的输出序列是
   (1，3，4，5，2)，BFS遍历的输出序列是(1，3，2，4，5) 。

三、应用题
1． 设一组初始记录关键字序列为(45，80，48，40，22，78)，则分别给出第4趟简单选择排序和第4趟直接插入排序后的结果。
参考答案：(22，40，45，48，80，78)，(40，45，48，80，22，78)
2． 设指针变量p指向双向链表中结点A，指针变量q指向被插入结点B，要求给出在结点A的后面插入结点B的操作序列（设双向链表中结点的两个指针域分别为llink和rlink）。
参考答案：q->llink=p; q->rlink=p->rlink; p->rlink->llink=q; p->rlink=q;
3． 设一组有序的记录关键字序列为(13，18，24，35，47，50，62，83，90)，查找方法用
二分查找，要求计算出查找关键字62时的比较次数并计算出查找成功时的平均查找长度。
参考答案：2, ASL=（11+22+34+42）=25/9

4． 设有无向图G，要求给出用普里姆算法构造最小生成树所走过的边的集合。

参考答案：E={(1，3)，(1，2)，(3，5)，(5，6)，(6，4)}
5． 设有一组初始记录关键字为(45，80，48，40，22，78)，要求构造一棵二叉排序树并给
出构造过程。
参考答案：

四、算法设计题
1． 设有一组初始记录关键字序列（K1，K2，…，Kn），要求设计一个算法能够在O(n)的时间
复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于Ki，右半部分的每个关键字均大于等于Ki。
参考答案：
void quickpass(int r[], int s, int t)
{
int i=s, j=t, x=r[s];
while(i<j){
while (i<j && r[j]>x) j=j-1; if (i<j) {r[i]=r[j];i=i+1;}
while (i<j && r[i]<x) i=i+1; if (i<j) {r[j]=r[i];j=j-1;}
}
r[i]=x;
}
2. 设有两个集合A和集合B，要求设计生成集合C=A∩B的算法，其中集合A、B和C用
链式存储结构表示。
参考答案：
typedef struct node {int data; struct node *next;}lklist;
void intersection(lklist *ha,lklist *hb,lklist *&hc)
{
lklist *p,*q,*t;
for(p=ha,hc=0;p!=0;p=p->next)
{ for(q=hb;q!=0;q=q->next) if (q->data==p->data) break;
if(q!=0){ t=(lklist *)malloc(sizeof(lklist)); t->data=p->data;t->next=hc; hc=t;}
}
}

33333
一、选择题
1．下面程序的时间复杂为（ B ）
for（i=1，s=0； i<=n； i++） {t=1；for(j=1；j<=i；j++) t=t*j；s=s+t；}
A、 O(n) B、 O(n2) C、 O(n3) D、 O(n4)
3．设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（ A ）。
A、q=p->next；p->data=q->data；p->next=q->next；free(q)；
B、q=p->next；q->data=p->data；p->next=q->next；free(q)；
C、q=p->next；p->next=q->next；free(q)；
D、q=p->next；p->data=q->data；free(q)；
4．设有n个待排序的记录关键字，则在堆排序中需要（ A ）个辅助记录单元。
A、 1 B、 n C、 nlog2n D、 n2
5．设一组初始关键字记录关键字为(20，15，14，18，21，36，40，10)，则以20为基准记录的一趟快速排序结束后的结果为( A )。
A、 10，15，14，18，20，36，40，21
B、 10，15，14，18，20，40，36，21
C、 10，15，14，20，18，40，36，2l
D、 15，10，14，18，20，36，40，21
6．设二叉排序树中有n个结点，则在二叉排序树的平均平均查找长度为（B ）。
A、 O(1) B、 O(log2n) C、O(n) D、 O(n2)
7．设无向图G中有n个顶点e条边，则其对应的邻接表中的表头结点和表结点的个数分别为（ D ）。
A、 n，e B、 e，n C、 2n，e D、 n，2e
8. 设某强连通图中有n个顶点，则该强连通图中至少有（ C ）条边。
A、 n(n-1) B、 n+1 C、 n D、 n(n+1)
9．设有5000个待排序的记录关键字，如果需要用最快的方法选出其中最小的10个记录关键字，则用下列（ B ）方法可以达到此目的。
A、 快速排序 B、 堆排序 C、 归并排序 D、 插入排序
10.下列四种排序中（D ）的空间复杂度最大。
A、 插入排序 B、 冒泡排序 C、 堆排序 D、 归并排序
二、填空题

1. 数据的物理结构主要包括（顺序存储结构）和（链式存储结构）两种情况。

2. 设一棵完全二叉树中有500个结点，则该二叉树的深度为（9）；若用二叉链表作为该完全二叉树的存储结构，则共有（501）个空指针域。

3. 设输入序列为1、2、3，则经过栈的作用后可以得到（5）种不同的输出序列。

4. 设有向图G用邻接矩阵A[n][n]作为存储结构，则该邻接矩阵中第i行上所有元素之和等于顶点i的（出度），第i列上所有元素之和等于顶点i的（入度）。

5. 设哈夫曼树中共有n个结点，则该哈夫曼树中有（0）个度数为1的结点。

6. 设有向图G中有n个顶点e条有向边，所有的顶点入度数之和为d，则e和d的关系为（e=d）。

7. （中序）遍历二叉排序树中的结点可以得到一个递增的关键字序列（填先序、中序或后序）。

8. 设查找表中有100个元素，如果用二分法查找方法查找数据元素X，则最多需要比较（7）次就可以断定数据元素X是否在查找表中。

9. 不论是顺序存储结构的栈还是链式存储结构的栈，其入栈和出栈操作的时间复杂度均为（ O(1)）。

10. 设有n个结点的完全二叉树，如果按照从自上到下、从左到右从1开始顺序编号，则第i个结点的双亲结点编号为（ i/2），右孩子结点的编号为（2i+1）。

11. 设一组初始记录关键字为(72，73，71，23，94，16，5)，则以记录关键字72为基准的一趟快速排序结果为（ (5，16，71，23，72，94，73) ）。

12. 设有向图G中有向边的集合E={<1，2>，<2，3>，<1，4>，<4，2>，<4，3>}，则该图的一种拓扑序列为（ (1，4，3，2) ）。

13. 下列算法实现在顺序散列表中查找值为x的关键字，请在下划线处填上正确的语句。
    struct record{int key; int others;};
    int hashsqsearch(struct record hashtable[ ],int k)
    {
    int i,j; j=i=k % p;
    while (hashtable[j].key!=k&&hashtable[j].flag!=0){j=( （j+1） ) %m;
    if (ij) return(-1);}
    if ( （ hashtable[j].keyk） ) return(j); else return(-1);
    }

14. 下列算法实现在二叉排序树上查找关键值k，请在下划线处填上正确的语句。
    typedef struct node{int key; struct node *lchild; struct node *rchild;}bitree;
    bitree *bstsearch(bitree *t, int k)
    {
    if (t0 ) return(0);else while (t!=0)
    if (t->keyk) （ return(t) ） ; else if (t->key>k) t=t->lchild;
    else （ t=t->rchild ）;
    }

三、计算题
1.已知二叉树的前序遍历序列是AEFBGCDHIKJ，中序遍历序列是EFAGBCHKIJD，画出此二叉树，并画出它的后序线索二叉树。
参考答案：

2．已知待散列的线性表为（36，15，40，63，22），散列用的一维地址空间为[0…6]，假定选用的散列函数是H（K）= K mod 7，若发生冲突采用线性探查法处理，试：
（1）计算出每一个元素的散列地址并在下图中填写出散列表：
` 0 1 2 3 4 5 6

（2）求出在查找每一个元素概率相等情况下的平均查找长度。
参考答案：
H(36)=36 mod 7=1; H１(22)=(1+1) mod 7=2; ….冲突
H(15)=15 mod 7=1;….冲突 H2(22)=(2+1) mod 7=3;
H１(15)=(1+1) mod 7=2;
H(40)=40 mod 7=5;
H(63)=63 mod 7=0;
H(22)=22 mod 7=1; ….冲突
（1） 0 1 2 3 4 5 6
63 36 15 22 40
（2）ASL=
3．已知序列（10，18，4，3，6，12，1，9，18，8）请用快速排序写出每一趟排序的结果。
参考答案：
(8,9,4,3,6,1),10,(12,18,18)
(1,6,4,3),8,(9),10,12,(18,18)
1,(3,4,6),8,9,10,12,18,(18)
1,3,(4,6),8,9,10,12,18,18
1,3, 4,6,8,9,10,12,18,18
四、算法设计题
1． 设计在单链表中删除值相同的多余结点的算法。
参考答案：
typedef int datatype;
typedef struct node {datatype data; struct node *next;}lklist;
void delredundant(lklist *&head)
{
lklist *p,*q,*s;
for(p=head;p!=0;p=p->next)
{
for(q=p->next,s=q;q!=0; )
if (q->datap->data) {s->next=q->next; free(q);q=s->next;}
else {s=q,q=q->next;}
}
}
2． 设计一个求结点x在二叉树中的双亲结点算法。
参考答案：
typedef struct node {datatype data; struct node *lchild,*rchild;} bitree;
bitree *q[20]; int r=0,f=0,flag=0;
void preorder(bitree *bt, char x)
{
if (bt!=0 && flag0)
if (bt->datax) { flag=1; return;}
else {r=(r+1)% 20; q[r]=bt; preorder(bt->lchild,x); preorder(bt->rchild,x); }
}
void parent(bitree *bt,char x)
{
int i;
preorder(bt,x);
for(i=f+1; i<=r; i++) if (q[i]->lchild->datax || q[i]->rchild->data) break;
if (flag==0) printf(“not found x\n”);
else if (i<=r) printf(“%c”,bt->data); else printf(“not parent”);
}

44444
一、选择题
1．设一维数组中有n个数组元素，则读取第i个数组元素的平均时间复杂度为（ C ）。
A、 O(n) B、 O(nlog2n) C、 O(1) D、 O(n2)
2．设一棵二叉树的深度为k，则该二叉树中最多有（ D ）个结点。
A、 2k-1 B、 2k C、 2k-1 D、 2k-1
3．设某无向图中有n个顶点e条边，则该无向图中所有顶点的入度之和为（ D ）。
A、 n B、 e C、 2n D、 2e
4．在二叉排序树中插入一个结点的时间复杂度为（ B ）。
A、 O(1) B、 O(n) C、 O(log2n) D、 O(n2)
5．设某有向图的邻接表中有n个表头结点和m个表结点，则该图中有（ C ）条有向边。
A、 n B、 n-1 C、 m D、 m-1
6．设一组初始记录关键字序列为(345，253，674，924，627)，则用基数排序需要进行（ A ）趟的分配和回收才能使得初始关键字序列变成有序序列。
A、 3 B、 4 C、 5 D、 8
7．设用链表作为栈的存储结构则退栈操作（ B ）。
A、 必须判别栈是否为满 B、 必须判别栈是否为空
C、判别栈元素的类型 D、 对栈不作任何判别
8．下列四种排序中（ A ）的空间复杂度最大。
A、 快速排序 B、 冒泡排序 C、 希尔排序 D、 堆
9．设某二叉树中度数为0的结点数为N0，度数为1的结点数为Nl，度数为2的结点数为N2，则下列等式成立的是（ C ）。
A、 N0=N1+1 B、 N0=Nl+N2 C、 N0=N2+1 D、 N0=2N1+l
10.设有序顺序表中有n个数据元素，则利用二分查找法查找数据元素X的最多比较次数不超过（ A ）。
A、 log2n+1 B、 log2n-1 C、 log2n D、 log2(n+1)
二、填空题
1． 设有n个无序的记录关键字，则直接插入排序的时间复杂度为（ O(n2)），快速排序的平均时间复杂度为（O(nlog2n)）。
2． 设指针变量p指向双向循环链表中的结点X，则删除结点X需要执行的语句序列为（ p>llink->rlink=p->rlink; p->rlink->llink=p->rlink ）（设结点中的两个指针域分别为llink和rlink）。
3． 根据初始关键字序列(19，22，01，38，10)建立的二叉排序树的高度为（3）。
4． 深度为k的完全二叉树中最少有（2k-1）个结点。
5． 设初始记录关键字序列为(K1，K2，…，Kn)，则用筛选法思想建堆必须从第（ n/2）个元素开始进行筛选。
6． 设哈夫曼树中共有99个结点，则该树中有（50）个叶子结点；若采用二叉链表作为存储结构，则该树中有（51）个空指针域。
7． 设有一个顺序循环队列中有M个存储单元，则该循环队列中最多能够存储（ m-1）个队列元素；当前实际存储（(R-F+M)%M ）个队列元素（设头指针F指向当前队头元素的前一个位置，尾指针指向当前队尾元素的位置）。
8． 设顺序线性表中有n个数据元素，则第i个位置上插入一个数据元素需要移动表中（ n+1-i ）个数据元素；删除第i个位置上的数据元素需要移动表中（ n-i ）个元素。
9． 设一组初始记录关键字序列为(20，18，22，16，30，19)，则以20为中轴的一趟快速排序结果为（ (19，18，16，20，30，22) ）。
10． 设一组初始记录关键字序列为(20，18，22，16，30，19)，则根据这些初始关键字序列建成的初始堆为（(16，18，19，20，32，22)）。
11． 设某无向图G中有n个顶点，用邻接矩阵A作为该图的存储结构，则顶点i和顶点j互为邻接点的条件是（ A[i][j]=1）。
12． 设无向图对应的邻接矩阵为A，则A中第i上非0元素的个数（等于）第i列上非0元素的个数（填等于，大于或小于）。
13． 设前序遍历某二叉树的序列为ABCD，中序遍历该二叉树的序列为BADC，则后序遍历该二叉树的序列为（ BDCA ）。
14． 设散列函数H(k)=k mod p，解决冲突的方法为链地址法。要求在下列算法划线处填上正确的语句完成在散列表hashtalbe中查找关键字值等于k的结点，成功时返回指向关键字的指针，不成功时返回标志0。
typedef struct node {int key; struct node *next;} lklist;
void createlkhash(lklist *hashtable[ ])
{
int i,k; lklist *s;
for(i=0;i<m;i++)（ hashtable[i]=0 ）;
for(i=0;i<n;i++)
{
s=(lklist *)malloc(sizeof(lklist)); s->key=a[i];
k=a[i] % p; s->next=hashtable[k];（ hashtable[k]=s ）;
}
}
三、计算题

3、设散列表的地址范围是[ 0…9 ]，散列函数为H（key）= （key 2 +2）MOD 9,并采用链表处理冲突，请画出元素7、4、5、3、6、2、8、9依次插入散列表的存储结构。
参考答案：
H(4)=H(5)=0,H(3)=H(6)=H(9)=2,H(8)=3,H(2)=H(7)=6

四、算法设计题
1． 设单链表中有仅三类字符的数据元素(大写字母、数字和其它字符)，要求利用原单链表
中结点空间设计出三个单链表的算法，使每个单链表只包含同类字符。
参考答案：
typedef char datatype;
typedef struct node {datatype data; struct node *next;}lklist;
void split(lklist *head,lklist *&ha,lklist *&hb,lklist *&hc)
{
lklist *p; ha=0,hb=0,hc=0;
for(p=head;p!=0;p=head)
{
head=p->next; p->next=0;
if (p->data>=‘A’ && p->data<=‘Z’) {p->next=ha; ha=p;}
else if (p->data>=‘0’ && p->data<=‘9’) {p->next=hb; hb=p;} else {p->next=hc; hc=p;}
}
}
2. 设计在链式存储结构上交换二叉树中所有结点左右子树的算法。
参考答案：
typedef struct node {int data; struct node *lchild,*rchild;} bitree;
void swapbitree(bitree *bt)
{
bitree *p;
if(bt0) return;
swapbitree(bt->lchild); swapbitree(bt->rchild);
p=bt->lchild; bt->lchild=bt->rchild; bt->rchild=p;
}
3. 在链式存储结构上建立一棵二叉排序树。
参考答案：
#define n 10
typedef struct node{int key; struct node *lchild,*rchild;}bitree;
void bstinsert(bitree *&bt,int key)
{
if (bt0){bt=(bitree *)malloc(sizeof(bitree)); bt->key=key;bt->lchild=bt->rchild=0;}
else if (bt->key>key) bstinsert(bt->lchild,key); else bstinsert(bt->rchild,key);
}
void createbsttree(bitree *&bt)
{
int i;
for(i=1;i<=n;i++) bstinsert(bt,random(100));
}

55555
一、选择题
1．数据的最小单位是（ A ）。
A、 数据项 B、 数据类型 C、 数据元素 D、 数据变量
2．设一组初始记录关键字序列为(50，40，95，20，15，70，60，45)，则以增量d=4的一趟希尔排序结束后前4条记录关键字为（ B ）。
A、 40，50，20，95 B、 15，40，60，20
C、 15，20，40，45 D、 45，40，15，20
3．设一组初始记录关键字序列为(25，50，15，35，80，85，20，40，36，70)，其中含有5个长度为2的有序子表，则用归并排序的方法对该记录关键字序列进行一趟归并后的结果为（ A ）。
A、 15，25，35，50，20，40，80，85，36，70
B、15，25，35，50，80，20，85，40，70，36
C、15，25，35，50，80，85，20，36，40，70
D、15，25，35，50，80，20，36，40，70，85
4． 设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为（ D ）。
A、 O(log2n) B、 O(1) C、 O(n2) D、 O(n)
6．设一棵m叉树中度数为0的结点数为N0，度数为1的结点数为Nl，……，度数为m的结点数为Nm，则N0=（ B ）。
A、 Nl+N2+……+Nm B、 l+N2+2N3+3N4+……+(m-1)Nm
C、 N2+2N3+3N4+……+(m-1)Nm D、 2Nl+3N2+……+(m+1)Nm
7．设有序表中有1000个元素，则用二分查找查找元素X最多需要比较（ B ）次。
A、 25 B、 10 C、 7 D、 1
8．设连通图G中的边集E={(a，b)，(a，e)，(a，c)，(b，e)，(e，d)，(d，f)，(f，c)}，则从顶点a出发可以得到一种深度优先遍历的顶点序列为（ B ）。
A、 abedfc B、 acfebd C、 aebdfc D、 aedfcb
9．设输入序列是1、2、3、……、n，经过栈的作用后输出序列的第一个元素是n，则输出序列中第i个输出元素是（ C ）。
A、 n-i B、 n-1-i C、 n+1-i D、不能确定
10 设一组初始记录关键字序列为(45，80，55，40，42，85)，则以第一个记录关键字45为基准而得到一趟快速排序的结果是（ C ）。
A、 40，42，45，55，80，83 B、 42，40，45，80，85，88
C、 42，40，45，55，80，85 D、 42，40，45，85，55，80
二、填空题

1. 设有一个顺序共享栈S[0：n-1]，其中第一个栈项指针top1的初值为-1，第二个栈顶指针top2的初值为n，则判断共享栈满的条件是（ top1+1=top2）。
2. 在图的邻接表中用顺序存储结构存储表头结点的优点是(可以随机访问到任一个顶点的简单链表)。
3. 设有一个n阶的下三角矩阵A，如果按照行的顺序将下三角矩阵中的元素（包括对角线上元素）存放在n(n+1)个连续的存储单元中，则A[i][j]与A[0][0]之间有(i(i+1)/2+j-1)个数据元素。
4. 栈的插入和删除只能在栈的栈顶进行，后进栈的元素必定先出栈，所以又把栈称为( FILO )表；队列的插入和删除运算分别在队列的两端进行，先进队列的元素必定先出队列，所以又把队列称为( FIFO )表。
5. 设一棵完全二叉树的顺序存储结构中存储数据元素为ABCDEF，则该二叉树的前序遍历序列为( ABDECF )，中序遍历序列为( DBEAFC )，后序遍历序列为( DEBFCA)。
6. 设一棵完全二叉树有128个结点，则该完全二叉树的深度为(8)，有(64)个叶子结点。
7. 设有向图G的存储结构用邻接矩阵A来表示，则A中第i行中所有非零元素个数之和等于顶点i的(出度)，第i列中所有非零元素个数之和等于顶点i的(入度)。
8. 设一组初始记录关键字序列(k1，k2，……，kn)是堆，则对i=1，2，…，n/2而言满足的条件为( ki<=k2i && ki<=k2i+1)。
9. 下面程序段的功能是实现冒泡排序算法，请在下划线处填上正确的语句。
   void bubble(int r[n])
   {
   for(i=1;i<=n-1; i++)
   {
   for(exchange=0,j=0; j< ( n-i ) ;j++)
   if (r[j]>r[j+1]){temp=r[j+1]; ( r[j+1]=r[j] );r[j]=temp;exchange=1;}
   if (exchange==0) return；
   }}
10. 下面程序段的功能是实现二分查找算法，请在下划线处填上正确的语句。
    struct record{int key; int others;};
    int bisearch(struct record r[ ], int k)
    {
    int low=0,mid,high=n-1;
    while(low<=high)
    {
    ( mid=(low+high)/2 );
    if(r[mid].key==k) return(mid+1);
    else if( (r[mid].key>k) ) high=mid-1;
    else low=mid+1;}
    return(0);}
    三、应用题
11. 设某棵二叉树的中序遍历序列为DBEAC，前序遍历序列为ABDEC，要求给出该二叉树的的后序遍历序列。
    参考答案：DEBCA
12. 设无向图G（如右图所示），给出该图的最小生成树上边的集合并计算最小生成树各边上的权值之和。
    参考答案：E={(1,5),(5,2),(5,3),(3,4)},W=10
13. 设一组初始记录关键字序列为(15，17，18，22，35，51，60)，要求计算出成功查找时的平均查找长度。
    参考答案：ASL=(11+22+3*4)/7=17/7
14. 设散列表的长度为8，散列函数H(k)=k mod 7，初始记录关键字序列为(25，31，8，27，13，68)，要求分别计算出用线性探测法和链地址法作为解决冲突方法的平均查找长度。
    参考答案：ASL1=7/6，ASL2=4/3
    四、算法设计题
    1． 设计判断两个二叉树是否相同的算法。
    参考答案：
    typedef struct node {datatype data; struct node *lchild,*rchild;} bitree;
    int judgebitree(bitree *bt1,bitree *bt2)
    {
    if (bt1 = = 0 && bt2 == 0) return(1);
    else if (bt1 == 0 || bt2==0 ||bt1->data!=bt2->data) return(0);
    else return(judgebitree(bt1->lchild,bt2->lchild)*judgebitree(bt1->rchild,bt2->rchild));
    }

2． 设计两个有序单链表的合并排序算法。
参考答案：
void mergelklist(lklist *ha,lklist *hb,lklist *&hc)
{
lklist *s=hc=0;
while(ha!=0 && hb!=0)
if(ha->datadata){if(s== 0) hc=s=ha; else {s->next=ha; s=ha;};ha=ha->next;}
else {if(s== 0) hc=s=hb; else {s->next=hb; s=hb;};hb=hb->next;}
if(ha==0) s->next=hb; else s->next=ha;
}

66666
一、选择题
1． 设一组权值集合W={2，3，4，5，6}，则由该权值集合构造的哈夫曼树中带权路径长度
之和为（ D ）。
A、20 B、 30 C、40 D、 45
2．执行一趟快速排序能够得到的序列是（ A ）。
A、 [41，12，34，45，27] 55 [72，63]
B、 [45，34，12，41] 55 [72，63，27]
C、 [63，12，34，45，27] 55 [41，72]
D、[12，27，45，41] 55 [34，63，72]
3．设一条单链表的头指针变量为head且该链表没有头结点，则其判空条件是（ A ）。
A、 head== 0 B、 head->next== 0
C、 head->next==head D、 head!=0
4．时间复杂度不受数据初始状态影响而恒为O(nlog2n)的是（ A ）。
A、 堆排序 B、 冒泡排序 C、 希尔排序 D、 快速排序
5．设二叉树的先序遍历序列和后序遍历序列正好相反，则该二叉树满足的条件是（ D ）。
A、 空或只有一个结点 B、 高度等于其结点数
C、 任一结点无左孩子 D、 任一结点无右孩子
6．一趟排序结束后不一定能够选出一个元素放在其最终位置上的是（ D ）。
A、 堆排序 B、 冒泡排序 C、 快速排序 D、 希尔排序
7．设某棵三叉树中有40个结点，则该三叉树的最小高度为（ B ）。
A、 3 B、 4 C、 5 D、 6
8．顺序查找不论在顺序线性表中还是在链式线性表中的时间复杂度为（A ）。
A、 O(n) B、 O(n2) C、 O(n1/2) D、 O(1og2n)
9．二路归并排序的时间复杂度为（C ）。
A、 O(n) B、 O(n2) C、O(nlog2n) D、 O(1og2n)
10. 深度为k的完全二叉树中最少有（B ）个结点。
A、 2k-1-1 B、 2k-1 C、 2k-1+1 D、 2k-1
11.设指针变量front表示链式队列的队头指针，指针变量rear表示链式队列的队尾指针，指针变量s指向将要入队列的结点X，则入队列的操作序列为（ C ）。
A、 front->next=s；front=s； B、 s->next=rear；rear=s；
C、 rear->next=s；rear=s； D、 s->next=front；front=s；
12.设某无向图中有n个顶点e条边，则建立该图邻接表的时间复杂度为（ A ）。
A、 O(n+e) B、 O(n2) C、 O(ne) D、 O(n3)
13.设某哈夫曼树中有199个结点，则该哈夫曼树中有（B ）个叶子结点。
A、 99 B、 100 C、 101 D、 102
14.设二叉排序树上有n个结点，则在二叉排序树上查找结点的平均时间复杂度为（ D ）。
A、 O(n) B、 O(n2) C、 O(nlog2n) D、 O(1og2n)
15.设用邻接矩阵A表示有向图G的存储结构，则有向图G中顶点i的入度为（ B ）。
A、 第i行非0元素的个数之和 B、 第i列非0元素的个数之和
C、 第i行0元素的个数之和 D、 第i列0元素的个数之和

二、判断题
1．调用一次深度优先遍历可以访问到图中的所有顶点。（错 ）
2．分块查找的平均查找长度不仅与索引表的长度有关，而且与块的长度有关。（对）
3．冒泡排序在初始关键字序列为逆序的情况下执行的交换次数最多。（对）
4．满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。（对）
5．设一棵二叉树的先序序列和后序序列，则能够唯一确定出该二叉树的形状。（错 ）
6．层次遍历初始堆可以得到一个有序的序列。（错）
7．设一棵树T可以转化成二叉树BT，则二叉树BT中一定没有右子树。（对）
8．线性表的顺序存储结构比链式存储结构更好。（错）
9．中序遍历二叉排序树可以得到一个有序的序列。（对）
10.快速排序是排序算法中平均性能最好的一种排序。（对）
三、填空题
1．for(i=1，t=1，s=0；i<=n；i++) {t=t*i；s=s+t；}的时间复杂度为（ O(n)）。
2．设指针变量p指向单链表中结点A，指针变量s指向被插入的新结点X，则进行插入操作的语句序列为（ s->next=p->next; p->next=s ）（设结点的指针域为next）。
3．设有向图G的二元组形式表示为G =（D，R），D={1，2，3，4，5}，R={r}，r={<1,2>，<2,4>，<4,5>，<1,3>，❤️,2>，❤️,5>}，（ps：爱心是< 3）则给出该图的一种拓扑排序序列（(1，3，2，4，5)）。
4．设无向图G中有n个顶点，则该无向图中每个顶点的度数最多是（ n-1）。
5．设二叉树中度数为0的结点数为50，度数为1的结点数为30，则该二叉树中总共有（129）个结点数。
6．设F和R分别表示顺序循环队列的头指针和尾指针，则判断该循环队列为空的条件为（ F== R ）。
7．设二叉树中结点的两个指针域分别为lchild和rchild，则判断指针变量p所指向的结点为叶子结点的条件是（ p->lchild== 0&&p->rchild== 0）。
8．简单选择排序和直接插入排序算法的平均时间复杂度为（ O(n2)）。
9．快速排序算法的空间复杂度平均情况下为（ O(nlog2n)），最坏的情况下为（ O(n)）。
10.散列表中解决冲突的两种方法是（开放定址法）和（链地址法）。
四、算法设计题
１． 设计在顺序有序表中实现二分查找的算法。
参考答案：
struct record {int key; int others;};
int bisearch(struct record r[ ], int k)
{
int low=0,mid,high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(r[mid].key==k) return(mid+1); else if(r[mid].key>k) high=mid-1; else low=mid+1;
}
return(0);
}
２． 设计判断二叉树是否为二叉排序树的算法。
参考答案：
int minnum=-32768,flag=1;
typedef struct node{int key; struct node *lchild,*rchild;}bitree;
void inorder(bitree *bt)
{
if(bt!=0){inorder(bt->lchild);if(minnum>bt->key)flag=0;minnum=bt->key;inorder(bt->rchild);}
}

77777
一、选择题
1．设某无向图有n个顶点，则该无向图的邻接表中有（ B ）个表头结点。
A、 2n B、 n C、 n/2 D、 n(n-1)
2．设无向图G中有n个顶点，则该无向图的最小生成树上有（ B ）条边。
A、 n B、 n-1 C、2n D、 2n-1
3．设一组初始记录关键字序列为(60，80，55，40，42，85)，则以第一个关键字45为基准而得到的一趟快速排序结果是（ C ）。
A、 40，42，60，55，80，85 B、 42，45，55，60，85，80
C、 42，40，55，60，80，85 D、 42，40，60，85，55，80
4．（ B ）二叉排序树可以得到一个从小到大的有序序列。
A、 先序遍历 B、 中序遍历 C、 后序遍历 D、 层次遍历
5．设按照从上到下、从左到右的顺序从1开始对完全二叉树进行顺序编号，则编号为i结点的左孩子结点的编号为（ B ）。
A、 2i+1 B、 2i C、 i/2 D、 2i-1
6．程序段s=i=0；do {i=i+1； s=s+i；}while(i<=n)；的时间复杂度为（ A ）。
A、 O(n) B、 O(nlog2n) C、 O(n2) D、 O(n3/2)
7．设带有头结点的单向循环链表的头指针变量为head，则其判空条件是（ C ）。
A、 head== 0 B、 head->next== 0
C、 head->next==head D、 head!=0
8．设某棵二叉树的高度为10，则该二叉树上叶子结点最多有（C ）。
A、 20 B、 256 C、 512 D、 1024
9．设一组初始记录关键字序列为(13，18，24，35，47，50，62，83，90，115，134),则利用二分法查找关键字90需要比较的关键字个数为（ B ）。
A、 1 B、 2 C、 3 D、 4
10.设指针变量top指向当前链式栈的栈顶，则删除栈顶元素的操作序列为（ D ）。
A、 top=top+1; B、 top=top-1;
C、 top->next=top; D、 top=top->next;
二、判断题
1．不论是入队列操作还是入栈操作，在顺序存储结构上都需要考虑“溢出”情况。（对）
2．当向二叉排序树中插入一个结点，则该结点一定成为叶子结点。（对 ）
3．设某堆中有n个结点，则在该堆中插入一个新结点的时间复杂度为O(log2n)。（对 ）
4．完全二叉树中的叶子结点只可能在最后两层中出现。（对）
5．哈夫曼树中没有度数为1的结点。（对）
6．对连通图进行深度优先遍历可以访问到该图中的所有顶点。（对）
7．先序遍历一棵二叉排序树得到的结点序列不一定是有序的序列。（对）
8．由树转化成二叉树，该二叉树的右子树不一定为空。（错）
9．线性表中的所有元素都有一个前驱元素和后继元素。（错）
10.带权无向图的最小生成树是唯一的。（错 ）

三、填空题

1. 设指针变量p指向双向链表中的结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为（s->left=p ）=p；s->right=p->right；（p->right ）=s； p->right->left=s；（设结点中的两个指针域分别为left和right）。
2. 设完全有向图中有n个顶点，则该完全有向图中共有（n(n-1)）条有向条；设完全无向图中有n个顶点，则该完全无向图中共有（ n(n-1)/2）条无向边。
3. 设关键字序列为(Kl，K2，…，Kn)，则用筛选法建初始堆必须从第（ n/2）个元素开始进行筛选。
4. 解决散列表冲突的两种方法是（开放定址法）和（链地址法）。
5. 设一棵三叉树中有50个度数为0的结点，21个度数为2的结点，则该二叉树中度数为3的结点数有（14）个。
6. 高度为h的完全二叉树中最少有（2h-1）个结点，最多有（2h-1）个结点。
7. 设有一组初始关键字序列为(24，35，12，27，18，26)，则第3趟直接插入排序结束后的结果的是 (12，24，35，27，18，26)。
8. 设有一组初始关键字序列为(24，35，12，27，18，26)，则第3趟简单选择排序结束后的结果的是 (12，18，24，27，35，26)。
9. 设一棵二叉树的前序序列为ABC，则有（5）种不同的二叉树可以得到这种序列。
10. 下面程序段的功能是实现一趟快速排序，请在下划线处填上正确的语句。
    struct record {int key;datatype others;};
    void quickpass(struct record r[], int s, int t, int &i)
    {
    int j=t; struct record x=r[s]; i=s;
    while(i<j)
    {
    while (i<j && r[j].key>x.key) j=j-1; if (i<j) {r[i]=r[j];i=i+1;}
    while (（i<j && r[i].key<x.key）) i=i+1; if (i<j) {r[j]=r[i];j=j-1;}
    }
    （ r[i]=x ）;
    }
    四、算法设计题
11. 设计在链式结构上实现简单选择排序算法。
    参考答案：
    void simpleselectsorlklist(lklist *&head)
    {
    lklist *p,*q,*s; int min,t;
    if(head==0 ||head->next ==0) return;
    for(q=head; q!=0;q=q->next)
    {
    min=q->data; s=q;
    for(p=q->next; p!=0;p=p->next) if(min>p->data){min=p->data; s=p;}
    if(s!=q){t=s->data; s->data=q->data; q->data=t;}
    }
    }
12. 设计求结点在二叉排序树中层次的算法。
    参考答案：
    int lev=0;
    typedef struct node{int key; struct node *lchild,*rchild;}bitree;
    void level(bitree *bt,int x)
    {
    if (bt!=0)
    {lev++; if (bt->key==x) return; else if (bt->key>x) level(bt->lchild,x); else level(bt->rchild,x);}
    }

88888
一、选择题

1. 字符串的长度是指（ C ）。
   A、串中不同字符的个数 B、 串中不同字母的个数
   C、 串中所含字符的个数 D、 串中不同数字的个数
2. 建立一个长度为n的有序单链表的时间复杂度为（ C ）
   A、 O(n) B、 O(1) C、 O(n2) D、 O(log2n)
3. 两个字符串相等的充要条件是（ C ）。
   A、 两个字符串的长度相等 B、两个字符串中对应位置上的字符相等
   C、 同时具备(A)和(B)两个条件 D、 以上答案都不对
4. 设某散列表的长度为100，散列函数H(k)=k % P，则P通常情况下最好选择（ B ）。
   A、 99 B、 97 C、 91 D、 93
5. 在二叉排序树中插入一个关键字值的平均时间复杂度为（ B ）。
   A、 O(n) B、 O(1og2n) C、 O(nlog2n) D、 O(n2)
6. 设一个顺序有序表A[1:14]中有14个元素，则采用二分法查找元素A[4]的过程中比较元素的顺序为( C )。
   A、 A[1]，A[2]，A[3]，A[4] B、 A[1]，A[14]，A[7]，A[4]
   C、A[7]，A[3]，A[5]，A[4] D、 A[7]，A[5] ，A[3]，A[4]
7. 设一棵完全二叉树中有65个结点，则该完全二叉树的深度为（ B ）。
   A、 8 B、 7 C、 6 D、 5
8. 设一棵三叉树中有2个度数为1的结点，2个度数为2的结点，2个度数为3的结点，则该三叉链权中有（ C ）个度数为0的结点。
   A、 5 B、 6 C、 7 D、 8
9. 设无向图G中的边的集合E={(a，b)，(a，e)，(a，c)，(b，e)，(e，d)，(d，f)，(f，c)}，则从顶点a出发进行深度优先遍历可以得到的一种顶点序列为（ A ）。
   A、 aedfcb B、 acfebd C、 aebcfd D、 aedfbc
10. 队列是一种（ A ）的线性表。
    A、 先进先出 B、 先进后出 C、 只能插入 D、 只能删除
    二、判断题
11. 如果两个关键字的值不等但哈希函数值相等，则称这两个关键字为同义词。（对）
12. 设初始记录关键字基本有序，则快速排序算法的时间复杂度为O(nlog2n)。（错）
13. 分块查找的基本思想是首先在索引表中进行查找，以便确定给定的关键字可能存在的块号，然后再在相应的块内进行顺序查找。（对）
14. 二维数组和多维数组均不是特殊的线性结构。（错）
15. 向二叉排序树中插入一个结点需要比较的次数可能大于该二叉树的高度。（错）
16. 如果某个有向图的邻接表中第i条单链表为空，则第i个顶点的出度为零。（对 ）
17. 非空的双向循环链表中任何结点的前驱指针均不为空。（对）
18. 不论线性表采用顺序存储结构还是链式存储结构，删除值为X的结点的时间复杂度均为O(n)。（对 ）
19. 图的深度优先遍历算法中需要设置一个标志数组，以便区分图中的每个顶点是否被访问过。（对）
    三、填空题
    1． 设一组初始记录关键字序列为(49，38，65，97，76，13，27，50)，则以d=4为增量的一趟希尔排序结束后的结果为 (49，13，27，50，76，38，65，97)。
    2． 下面程序段的功能是实现在二叉排序树中插入一个新结点，请在下划线处填上正确的内容。
    typedef struct node{int data;struct node *lchild;struct node *rchild;}bitree;
    void bstinsert(bitree *&t,int k)
    {
    if (t==0 ){ （ t=(bitree *)malloc(sizeof(bitree)) ）;
    t->data=k;t->lchild=t->rchild=0;}
    else if (t->data>k) bstinsert(t->lchild,k);else（ bstinsert(t->rchild,k) ）;
    }
    3． 设指针变量p指向单链表中结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X需要执行的语句序列：s->next=p->next; （ p->next=s ）;。
    4． 设指针变量head指向双向链表中的头结点，指针变量p指向双向链表中的第一个结点，则指针变量p和指针变量head之间的关系是p=（head->rlink）和head=（p->llink ）（设结点中的两个指针域分别为llink和rlink）。
    5． 设某棵二叉树的中序遍历序列为ABCD，后序遍历序列为BADC，则其前序遍历序列为（ CABD ）。
    6． 完全二叉树中第5层上最少有（1）个结点，最多有（16）个结点。
    7． 设有向图中不存在有向边<Vi,Vj>，则其对应的邻接矩阵A中的数组元素A[i][j]的值等于（0）。
    8． 设一组初始记录关键字序列为(49，38，65，97，76，13，27，50)，则第4趟直接选择排序结束后的结果为(13，27，38，50，76，49，65，97)。
    9． 设连通图G中有n个顶点e条边，则对应的最小生成树上有（n-1）条边。
    10．设有一组初始记录关键字序列为(50，16，23，68，94，70，73)，则将它们调整成初始堆只需把16与（50）相互交换即可。
    四、算法设计题
20. 设计一个在链式存储结构上统计二叉树中结点个数的算法。
    参考答案：
    void countnode(bitree *bt,int &count)
    {
    if(bt!=0)
    {count++; countnode(bt->lchild,count); countnode(bt->rchild,count);}
    }

99999
一、选择题
1．下列程序段的时间复杂度为（ A ）。
for(i=0； i<m； i++) for(j=0； j<t； j++) c[i][j]=0；
for(i=0； i<m； i++) for(j=0； j<t； j++) for(k=0； k<n； k++) c[i][j]=c[i][j]+a[i][k]b[k][j]；
A、 O(mnt) B、 O(m+n+t) C、 O(m+nt) D、O(m*t+n)
2．设顺序线性表中有n个数据元素，则删除表中第i个元素需要移动（ A ）个元素。
A、 n-i B、 n+l -i C、 n-1-i D、 i
3．利用直接插入排序法的思想建立一个有序线性表的时间复杂度为（ C ）。
A、 O(n) B、 O(nlog2n) C、O(n2) D、 O(1og2n)
5．设指针变量p指向双向链表中结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为（ D ）。
A、 p->right=s； s->left=p； p->right->left=s； s->right=p->right；
B、 s->left=p；s->right=p->right；p->right=s； p->right->left=s；
C、 p->right=s； p->right->left=s； s->left=p； s->right=p->right；
D、 s->left=p；s->right=p->right；p->right->left=s； p->right=s；
6．下列各种排序算法中平均时间复杂度为O(n2)是（ D ）。
A、 快速排序 B、 堆排序 C、 归并排序 D、 冒泡排序
7．设输入序列1、2、3、…、n经过栈作用后，输出序列中的第一个元素是n，则输出序列中的第i个输出元素是（C ）。
A、n-i B、 n-1-i C、 n+l -i D、 不能确定
8．设散列表中有m个存储单元，散列函数H(key)= key % p，则p最好选择（ B ）。
A、 小于等于m的最大奇数 B、 小于等于m的最大素数
C、 小于等于m的最大偶数 D、 小于等于m的最大合数
9．设在一棵度数为3的树中，度数为3的结点数有2个，度数为2的结点数有1个，度数为1的结点数有2个，那么度数为0的结点数有（ C ）个。
A、 4 B、 5 C、 6 D、 7
10.设完全无向图中有n个顶点，则该完全无向图中有（ A ）条边。
A、 n(n-1)/2 B、 n(n-1) C、 n(n+1)/2 D、 (n-1)/2
11.设顺序表的长度为n，则顺序查找的平均比较次数为（ C ）。
A、 n B、 n/2 C、 (n+1)/2 D、 (n-1)/2
12.设有序表中的元素为(13，18，24，35，47，50，62)，则在其中利用二分法查找值为24的元素需要经过（ C ）次比较。
A、 1 B、 2 C、 3 D、 4
13.设顺序线性表的长度为30，分成5块，每块6个元素，如果采用分块查找，则其平均查找长度为（ D ）。
A、 6 B、 11 C、 5 D、 6.5
14.设有向无环图G中的有向边集合E={<1，2>，<2，3>，❤️，4>，<1，4>}，则下列属于该有向图G的一种拓扑排序序列的是（ A ）。
A、 1，2，3，4 B、 2，3，4，1 C、 1，4，2，3 D、1，2，4，3
15.设有一组初始记录关键字序列为(34，76，45，18，26，54，92)，则由这组记录关键字生成的二叉排序树的深度为（ A ）。
A、 4 B、 5 C、 6 D、 7
二、填空题
1． 设指针p指向单链表中结点A，指针s指向被插入的结点X，则在结点A的前面插入结点X时的操作序列为：

1. s->next=（ p->next ）；2) p->next=s；3) t=p->data；
2. p->data=（ s->data ）；5) s->data=t；
   2． 设某棵完全二叉树中有100个结点，则该二叉树中有（50）个叶子结点。
   3． 设某顺序循环队列中有m个元素，且规定队头指针F指向队头元素的前一个位置，队尾指针R指向队尾元素的当前位置，则该循环队列中最多存储（m-1）队列元素。
   4． 对一组初始关键字序列（40，50，95，20，15，70，60，45，10）进行冒泡排序，则第一趟需要进行相邻记录的比较的次数为（6），在整个排序过程中最多需要进行（8）趟排序才可以完成。
   5． 在堆排序和快速排序中，如果从平均情况下排序的速度最快的角度来考虑应最好选择（快速）排序，如果从节省存储空间的角度来考虑则最好选择（堆）排序。
   6． 设一棵二叉树的中序遍历序列为BDCA，后序遍历序列为DBAC，则这棵二叉树的前序序列为（ CBDA ）。
   7． 设用于通信的电文仅由8个字母组成，字母在电文中出现的频率分别为7、19、2、6、32、3、21、10，根据这些频率作为权值构造哈夫曼树，则这棵哈夫曼树的高度为（6）。
   8． 设一组记录关键字序列为(80，70，33，65，24，56，48)，则用筛选法建成的初始堆为_(24，65，33，80，70，56，48)__ _。
   9． 设无向图G（如右图所示），则其最小生成树上所有边的权值之和为（8）。

10．设一组初始记录关键字序列为(20，12，42，31，18，14，28)，则根据这些记录关键字构造的二叉排序树的平均查找长度是（19/7）。

三、判断题
1． 有向图的邻接表和逆邻接表中表结点的个数不一定相等。(错)
2． 对链表进行插入和删除操作时不必移动链表中结点。(对)
3． 子串“ABC”在主串“AABCABCD”中的位置为2。(对)
4． 若一个叶子结点是某二叉树的中序遍历序列的最后一个结点，则它必是该二叉树的先序遍历序列中的最后一个结点。(对)
5． 希尔排序算法的时间复杂度为O(n2)。(错)
6． 用邻接矩阵作为图的存储结构时，则其所占用的存储空间与图中顶点数无关而与图中边数有关。(错)
7． 中序遍历一棵二叉排序树可以得到一个有序的序列。(对)
8． 入栈操作和入队列操作在链式存储结构上实现时不需要考虑栈溢出的情况。(对)
9． 顺序表查找指的是在顺序存储结构上进行查找。（错）
10． 堆是完全二叉树，完全二叉树不一定是堆。（对）

五、算法设计题
1． 设计计算二叉树中所有结点值之和的算法。
参考答案：
void sum(bitree *bt,int &s)
{
if(bt!=0) {s=s+bt->data; sum(bt->lchild,s); sum(bt->rchild,s);}
}
2． 设计将所有奇数移到所有偶数之前的算法。
参考答案：
void quickpass(int r[], int s, int t)
{
int i=s,j=t,x=r[s];
while(i<j)
{
while (i<j && r[j]%2== 0) j=j-1; if (i<j) {r[i]=r[j];i=i+1;}
while (i<j && r[i]%2== 1) i=i+1; if (i<j) {r[j]=r[i];j=j-1;}
}
r[i]=x;
}
3． 设计判断单链表中元素是否是递增的算法。
参考答案：
int isriselk(lklist *head)
{
if(head==0||head->next ==0) return(1);else
for(q=head,p=head->next; p!=0; q=p,p=p->next)if(q->data>p->data) return(0);
return(1);
}

1010101010
一、选择题
1．下列程序段的时间复杂度为（ A ）。
i=0，s=0； while (s<n) {s=s+i；i++；}
A、 O(n1/2) B、 O(n1/3) C、 O(n) D、 O(n2)
2．设某链表中最常用的操作是在链表的尾部插入或删除元素，则选用下列（D ）存储方式最节省运算时间。
A、单向链表B、 单向循环链表 C、 双向链表 D、 双向循环链表
3．设指针q指向单链表中结点A，指针p指向单链表中结点A的后继结点B，指针s指向被插入的结点X，则在结点A和结点B插入结点X的操作序列为（ B ）。
A、 s->next=p->next；p->next=-s； B、 q->next=s； s->next=p；
C、 p->next=s->next；s->next=p； D、 p->next=s；s->next=q；
4．设输入序列为1、2、3、4、5、6，则通过栈的作用后可以得到的输出序列为（ B ）。
A、 5，3，4，6，1，2 B、 3，2，5，6，4，1
C、 3，1，2，5，4，6 D、 1，5，4，6，2，3
5．设有一个10阶的下三角矩阵A（包括对角线），按照从上到下、从左到右的顺序存储到连续的55个存储单元中，每个数组元素占1个字节的存储空间，则A[5][4]地址与A[0][0]的地址之差为（ B ）。
A、 10 B、 19 C、 28 D、 55
6．设一棵m叉树中有N1个度数为1的结点，N2个度数为2的结点，……，Nm个度数为m的结点，则该树中共有（ D ）个叶子结点。
A、 B、 C、 D、
7. 二叉排序树中左子树上所有结点的值均（ A ）根结点的值。
A、 < B、 > C、 = D、!=
8. 设一组权值集合W=(15，3，14，2，6，9，16，17)，要求根据这些权值集合构造一棵哈夫曼树，则这棵哈夫曼树的带权路径长度为（ D ）。
A、 129 B、 219 C、 189 D、 229
9. 设有n个关键字具有相同的Hash函数值，则用线性探测法把这n个关键字映射到HASH表中需要做（ D ）次线性探测。
A、 n2 B、 n(n+1) C、 n(n+1)/2 D、 n(n-1)/2
10.设某棵二叉树中只有度数为0和度数为2的结点且度数为0的结点数为n，则这棵二叉中共有（ C ）个结点。
A、 2n B、 n+l C、 2n-1 D、 2n+l
11.设一组初始记录关键字的长度为8，则最多经过（ B ）趟插入排序可以得到有序序列。
A、 6 B、 7 C、 8 D、 9
12.设一组初始记录关键字序列为(Q，H，C，Y，P，A，M，S，R，D，F，X)，则按字母升序的第一趟冒泡排序结束后的结果是（ D ）。
A、 F，H，C，D，P，A，M，Q，R，S，Y，X
B、 P，A，C，S，Q，D，F，X，R，H，M，Y
C、 A，D，C，R，F，Q，M，S，Y，P，H，X
D、 H，C，Q，P，A，M，S，R，D，F，X，Y
二、填空题

1. 设需要对5个不同的记录关键字进行排序，则至少需要比较（4）次，至多需要比较（10）次。
2. 快速排序算法的平均时间复杂度为（ O(nlog2n)），直接插入排序算法的平均时间复杂度为（ O(n2)）。
3. 设二叉排序树的高度为h，则在该树中查找关键字key最多需要比较（n）次。
4. 设在长度为20的有序表中进行二分查找，则比较一次查找成功的结点数有（1）个，比较两次查找成功有结点数有（2）个。
5. 设一棵m叉树脂的结点数为n，用多重链表表示其存储结构，则该树中有（ n(m-1)+1）个空指针域。
6. 设指针变量p指向单链表中结点A，则删除结点A的语句序列为：
   q=p->next；p->data=q->data；p->next=（ q->next ）；feee(q)；
7. 数据结构从逻辑上划分为三种基本类型：（线性结构）、（树型结构）和（图型结构）。
8. 设无向图G中有n个顶点e条边，则用邻接矩阵作为图的存储结构进行深度优先或广度优先遍历时的时间复杂度为（O(n2)）；用邻接表作为图的存储结构进行深度优先或广度优先遍历的时间复杂度为（O(n+e)）。
9. 设散列表的长度为8，散列函数H(k)=k % 7，用线性探测法解决冲突，则根据一组初始关键字序列(8，15，16，22，30，32)构造出的散列表的平均查找长度是（8/3）。
10. 设一组初始关键字序列为(38，65，97，76，13，27，10)，则第3趟冒泡排序结束后的结果为（(38，13，27，10，65，76，97)）。
11. 设一组初始关键字序列为(38，65，97，76，13，27，10)，则第3趟简单选择排序后的结果为(10，13，27，76，65，97，38)。
12. 设有向图G中的有向边的集合E={<1，2>，<2，3>，<1，4>，<4，5>，<5，3>，<4，6>，<6，5>}，则该图的一个拓扑序列为（124653）。
13. 下面程序段的功能是建立二叉树的算法，请在下划线处填上正确的内容。
    typedef struct node{int data;struct node *lchild;（struct node *rchild ）;}bitree;
    void createbitree(bitree &bt)
    {
    scanf(“%c”,&ch);
    if(ch==‘#’) （ bt=0）;else
    {bt=(bitree)malloc(sizeof(bitree));bt->data=ch;（createbitree(bt->lchild)）;
    createbitree(bt->rchild);}
    }
14. 下面程序段的功能是利用从尾部插入的方法建立单链表的算法，请在下划线处填上正确的内容。
    typedef struct node {int data; struct node *next;} lklist;
    void lklistcreate( （lklist） *&head )
    {
    for (i=1;i<=n;i++)
    {
    p=(lklist *)malloc(sizeof(lklist));scanf(“%d”,&(p->data));p->next=0;
    if(i== 1)head=q=p;else {q->next=p;（ q=p ）;}
    }
    }
    三、算法设计题
    1． 设计在二叉排序树上查找结点X的算法。
    参考答案：
    bitree *bstsearch1(bitree *t, int key)
    {
    bitree *p=t;
    while(p!=0) if (p->key== key) return§;else if (p->key>key)p=p->lchild; else p=p->rchild;
    return(0);
    }
    2． 设关键字序列(k1，k2，…，kn-1)是堆，设计算法将关键字序列(k1，k2，…，kn-1，x)调整为堆。
    参考答案：
    void adjustheap(int r[ ],int n)
    {
    int j=n,i=j/2,temp=r[j-1];
    while (i>=1) if (temp>=r[i-1])break; else{r[j-1]=r[i-1]; j=i; i=i/2;}
    r[j-1]=temp;
    }