数据结构习题库

知识点：
01．绪论
02．顺序表
03．链表
04．栈
05．链队列
06．循环队列
07．串
08．数组的顺序表示
09．稀疏矩阵
10．广义表
11．二叉树的基本概念
12．二叉树遍历、二叉树性质
13．树、树与二叉树的转换
14．赫夫曼树
15．图的定义、图的存储
16．图的遍历
17．图的生成树
18．静态查找（顺序表的查找、有序表的查找）
19．动态查找（二叉排序树、平衡树、B树）
20．哈希查找
21．插入排序（直接插入、折半插入、2路插入、希尔排序）22．选择排序（简单选择、树形选择、堆排序）
23．快速排序、归并排序
101A1（1）．数据的逻辑结构是（A）。

A．数据的组织形式B．数据的存储形式C．数据的表示形式D．数据的实现形式
101A1（2）．组成数据的基本单位是（C）。

A．数据项B．数据类型C．数据元素D．数据变量
101B1（3）．与顺序存储结构相比，链式存储结构的存储密度（B）。

A．大B．小C．相同D．以上都不对
101B2（4）．对于存储同样一组数据元素而言，（D）。

A．顺序存储结构比链接结构多占空间B．在顺序结构中查找元素的速度比在链接结构中查找要快C．与链接结构相比，顺序结构便于安排数据元素D．顺序结构占用整块空间而链接结构不要求整块空间101B2（5）．下面程序的时间复杂度为（B）。

x=0；
for（i=1；i<n；i++）
for（j=i+1；j<=n；j++）
x++；
A．O（n）B．O（n2）C．O（1）D．O（n）
101B2（6）．下面程序的时间复杂度为（C）。

for（i=0；i<m；i++）
for（j=0；j<n；j++）
A[i][j]=i*j；
A．O（m2）B．O（n2）C．O（m×n）D．O（m+n）
101C2（7）．下面程序段的执行次数为（B）。

for（i=0；i<n-1；i++）
for（j=0；j>i；j++）
state；
A．n（n+1）/2 B．（n-1）（n+2）/2C．n（n+1）/2 D．（n-1）（n+2）
101D3（8）．下面程序的时间复杂度为（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（m×n×t）B．O（m+n+t）C．O（m+n×t）D．O（m×t+n）
102A1（9）．顺序表的特点是（B）。

A．表中元素的个数为表长B．按顺序方式存储数据元素
C．逻辑结构中相邻的结点在存储结构中仍相邻D．按表中元素的次序存储
102C2（10）．设顺序表共有n个元素，用数组elem存储，实现在第i个元素之前插入一个元素e的操作，其主要语句为（D）。

A．FOR j=n DOWNTO i DO elem[j]=elem[j+1]；
elem[i]=e；
B．FOR j=i TO n DO elem[j]=elem[j+1]；
elem[i]=e；
C．FOR j=i TO n DO elem[j+1]=elem[j]；
elem[i]=e；
D．FOR j=n DOWNTO i DO elem[j+1]=elem[j]；
elem[i]=e；
102D2（11）．顺序表有5个元素，设在任何位置上插入元素是等概率的，则在该表中插入一个元素时所需移动元素的平均次数为（C）。

A．3 B．2 C．2．5 D．5
102D2（12）．设顺序表有9个元素，则在第3个元素前插入一个元素所需移动元素的个数为（C）。

A．9 B．4．5 C．7 D．6
102D3（13）．设顺序表有19个元素，第一个元素的地址为200，且每个元素占3个字节，则第14个元素的存储地址为（B）。

A．236 B．239C．242 D．245
102D2（14）．设顺序表的第5个元素的存储地址为200，且每个元素占一个存储单元，则第14个元素的存储地址为（B）。

A．208 B．209C．210 D．214
103D3（15）．设p为指向双向循环链表中某个结点的指针，p所指向的结点的两个链域分别用p->llink 和p->rlink表示，则下列等式中（D）成立。

A．p=p->llink B．p=p->rlink C．p=p->llink->llink D．p=p->llink->rlink
103A1（16）．线性表采用链式存储时，其地址（D）。

A．必须是连续的B．一定是不连续的C．部分地址必须是连续的D．连续与否均可以
103B1（17）．线性表是（A）。

A．一个有限序列，可以为空B．一个有限序列，不可以为空C．一个无限序列，可以为空
D．一个无限序列，不可以为空
103B1（18）．链式存储的线性表中的指针指向其（B）。

A．前趋结点B．后继结点C．物理前趋D．物理后继
103C2（19）．设在链式存储的线性表中，设结点结构为p结点后插入一个结点q的关
键步骤为（A）。

A．q->link=p->link；p->link=q；B．p->link=q->link；p->link=q；
C．q->link=p->link；q->link=p；D．p->link=q->link；q->link=p；
103C3（20）．设有指针head指向的带表头结点的单链表，现将指针p指向的结点插入表中，使之成为第一个结点，其操作是（A）（其中，p->next、head->next分别表示p、head所指结点的链域）。

A．p->next=head->next；head->next=p；B．p->next=head->next；head=p；
C．p->next=head；head=p；D．p->next=head；p= head；
104A1（21）．在栈中，下列说法正确的是（A）。

A．每次插入总是在栈顶，每次删除也总是在栈顶。

B．每次插入总是在栈顶，每次删除总是在栈底。

C．每次插入总是在栈底，每次删除总是在栈顶。

D．每次插入总是在栈底，每次删除也总是在栈底。

104B2（22）．设有一个栈，按A、B、C的顺序进栈，则下列（C）为不可能的出栈序列。

A．ABC B．CBA C．CAB D．ACB
104B2（23）．设有一个栈，按A、B、C、D的顺序进栈，则下列（D）为可能的出栈序列。

A．DCAB B．CDAB C．DBAC D．ACDB
104A2（24）．顺序栈的上溢是指（B）。

A．栈满时作退栈运算B．栈满时作进栈运算C．栈空时作退栈运算D．栈空时作进栈运算
104D3（25）．顺序栈S中top为栈顶指针，指向栈顶元素所在的位置，elem为存放栈的数组，则元素e进栈操作的主要语句为（D）。

A．s．elem[top]=e；s．top=s．top+1；B．s．elem[top+1]=e；s．top=s．top+1；
C．s．top=s．top+1；s．elem[top+1]=e；D．s．top=s．top+1；s．elem[top]=e；104C2（26）．设有5个元素A，B，C，D，E顺序进栈（进栈过程中可以出栈），出栈后依出栈次序进入队列，已知其出队次序为D，C，E，B，A，则该栈容量必定不小于（C）。

A．2 B．3 C．4 D．5
104B2（27）．设栈S的初始状态为空，现有五个元素组成的序列1，2，3，4，5，对该序列在栈S上依次进行PUSH，PUSH，POP，PUSH，POP，PUSH，PUSH操作，出栈的元素序列是（C）。

A．5，4，3，2，1 B．2，1 C．2，3D．3，4
104B2（28）．在一个具有n个单元的顺序栈中，假定以地址低端（即0单元）作为栈底，以top为栈顶指针，则当做出栈处理时，top变化为（C）。

A．top不变B．top=0 C．top- -D．top++
104D3（29）．向一个栈顶指针为hs的链栈中插入一个*s结点时，应执行（B）。

A．hs->next=s；B．s->next=hs；hs=s；C．s->next=hs->next；hs->next=s；
D．s->next=hs；hs=hs->next；
105A1（30）．在队列中，下列说法正确的是（A）。

A．每次插入总是在队尾，每次删除总是在队头。

B．每次插入总是在队尾，每次删除也总是在队尾。

C．每次插入总是在队头，每次删除也总是在队头。

D．每次插入总是在队头，每次删除总是在队尾。

105D3（31）．在带头结点的链队列q中，用q．front表示队头指针，q．rear表示队尾指针，结点结构
为B）。

A．s=q．front；q．front->next= s．next；B．s=q．front->next；q．front->next= s．next；
C．s=q．front->next；q．front= s．next；D．s=q；q．front->next= s．next；
106C3（32）．循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear 指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则队列满的条件为（D）。

A．sq．front= sq．rear B．sq．front= sq．rear+1 C．（sq．front +1）mod MAXSIZE= sq．rear D．（sq．rear+1）mod MAXSIZE= sq．front
106C2（33）．循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear 指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则在队列未满时元素x入队列的主要操作为（A）。

A．sq．rear= （sq．rear+1）mod MAXSIZE；sq．elem[sq．rear]=x；
B．sq．elem[sq．rear]=x；sq．rear= （sq．rear+1）mod MAXSIZE；
C．sq．front= （sq．front+1）mod MAXSIZE；sq．elem[sq．front]=x；
D．sq．elem[sq．front]=x；sq．front= sq．front+1；
106B2（34）．循环队列sq中，用数组elem[0‥25]存放数据元素，sq．front指示队头元素的前一个位置，sq．rear指示队尾元素的当前位置，设当前sq．front为20，sq．rear为12，则当前队列中的元素个数为（D）。

A．8 B．16 C．17 D．18
106B2（35）．设循环队列的元素存放在一维数组Q[0‥30]中，队列非空时，front指示队头元素的前一个位置，rear指示队尾元素。

如果队列中元素的个数为11，front的值为25，则rear应指向（B）元素。

A．Q[4] B．Q[5] C．Q[14] D．Q[15]
105A1（36）．队列操作的原则是（A）。

A．先进先出B．后进先出C．只能进行插入D．只能进行删除
105B2（37）．一个队列的入列序列是1234，则队列的输出序列是（B）。

A．4321B．1234C．1432 D．3241
108C2（38）．设6行8列的二维数组A6×8=（a ij）按行优先顺序存储，若第一个元素的存储位置为200，且每个元素占3个存储单元，则元素a54的存储位置为（B）。

A．308 B．305 C．266 D．269
109C2（39）．设有一个10阶的对称矩阵A，采用压缩存储方式，以行序为主存储，a11为第一个元素，其存储地址为1，每元素占1个地址空间，则a85的地址为（B）。

A．13 B．33C．18 D．40
108A1（40）．设二个数组为A[0‥7]、B[-5‥2，3‥8]，则这两个数组分别能存放的字符的最大个数是（C）。

A．7和35 B．1和5 C．8和48 D．1和6
108C3（41）．二维数组M[i，j]的元素是4个字符（每个字符占一个存储单元）组成的串，行下标i的范围从0到4，列下列j的范围从0到5。

M按行存储时元素M[3，5]的起始地址与M按列存储时元素（B）的起始地址下同。

A．M[2，4] B．M[3，4] C．M[3，5] D．M[4，4]
108C2（42）．设二维数组为M[0‥8，0‥10]，每个元素占2L个存储单元，以行序为主序存储，第一个元素的存储位置为P。

存储位置为P+50L的元素为（A）。

A．M[2，3] B．M[2，2] C．M[3，3] D．M[3，4]
108C2（43）．设二维数组A的维数界偶定义为[1‥8，0‥10]，起始地址为LOC，每个元素占2L个存储单元，以行序为主序存储方式下，某数据元素的地址为LOC+50L，则在列序为主序存储方式下，该元素的存储地址为（D）。

A．LOC+28L B．LOC+36L C．LOC+50L D．LOC+52L
109B2（44）．数组A[1‥40，1‥30]采用三元组表示，设数组元素与下标均为整型，则在非零元素个数小于（D）时，才能节省存储空间。

A．1200 B．401 C．399 D．400
108A1（45）．一维数组通常采用顺序存储结构，这是因为（C）。

A．一维数组是一种线性数据结构B．一维数组是一种动态数据结构
C．一旦建立了数组，则数组中的数据元素之间的关系不再变动D．一维数组只能采用顺序存储结构109A1（46）．对稀疏矩阵进行压缩存储的目的是（B）。

A．方便存储B．节省存储空间C．方便运算D．节省运算时间
108D3（47）．设二维数组a[0‥5，0‥6]按行存储，每个元素占d个存储单元，如果每个元素改为2d 个存储单元，起始地址不变，则元素a[2，6]的存储地址将要增加（A）个存储单元。

A．20d B．21d C．38d D．39d
108B2（48）．一维数组与线性表的区别是（A）。

A．前者长度固定，后者长度可变B．后者长度固定，前者长度可变
C．两者长度均固定D．两者长度均可变
107A1（49）．下列关于串的叙述中，不正确的是（B）。

A．串是字符的有限序列B．空串是由空格构成的串C．模式匹配是串的一种重要运算
D．串既可以采用顺序存储，也可以采用链式存储
107B2（50）．以下论断正确的是（A）。

A．“”是空串，“”是空白串B．“BEIJING”是“BEI JING”的子串
C．“something”<“Somethig”D．”BIT”=”BITE”
107B2（51）．字符串“V ARTYPE unsignedint”若采用动态分配的顺序存储方法需要（C）个字节（假设每种数据均占用2个字节）。

A．38 B．动态产生，视情况而定C．40D．42
111A1（52）．由3个结点可以构造出（A）种不同形态的有向树。

A ．2
B ．3
C ．4
D ．5
111A1（53）．下列树的度为（B ）。

A ．2
B ．3
C ．5
D ．8
112C2（
54）．含10个结点的二叉树中，度为0的结点有4个，则度为2的结点有（A ）个。

A ．3
B ．4
C ．5
D ．6
111B2（55）．对一棵有100个结点的完全二叉树按层编号，则编号为49的结点，它的左孩子的编号为
（A ）。

A ．98
B ．99
C ．97
D ．50
112B2（56）．一棵深度为8（根的层次号为1）的满二叉树有（B ）个结点。

A ．256
B ．255
C ．128
D ．127
112C3（57）．设二叉树根结点的层数为1，若一棵高（深）度为h 的二叉树只有度为0与度为2的结
点，则其结点数至少为（B ）。

A ．h
B ．2h-1
C ．2h
D ．2h+1
112C2（58）A ）。

A ． C ．BCDAFE D ．DCBFEA
112D3（59）．一棵二叉树的前（先）序序列为ABCDEFG ，则它的中序序列不可能为（C ）。

A ．CBDAFEG
B ．DCBAEFG
C ．CDBAGEF
D ．BDCAFGE
112A1（60）．若先序遍历二叉树的结果为结点序列A ，B ，C ，则有（C ）棵不同的二叉树可以得到这
一结果。

A ．3
B ．4
C ．5
D ．6
111B2（61）．具有n 个结点的二叉树，有（B ）条边。

A ．n
B ．n-1
C ．n+1
D ．2n
112C2（62）．在具有n 个结点的二叉树的二叉链表表示中，2n 个孩子指针域中，只用到（B ）个域。

A ．n
B ．n-1
C ．n+1
D ．2n
114B2（63）．对哈夫曼树，下列说法错误的是（B ）。

A ．哈夫曼树是一类带树路径长度最短的树。

B ．给出一组数，构造的哈夫曼树唯一。

C ．给出一组数，构造的哈夫曼树的带树路径长度不变。

D ．哈夫曼树的带权路径长度为每个叶子的路径长度与该叶子权值乘积之和。

111D3（64）．假定在一棵二叉树中，双分支结点数为15个，单分支结点数为30个，则叶子结点数为
（B ）。

A ．15
B ．16
C ．17
D ．47
113C3（65）．假定一棵三叉树的结点数为50，则它的最小高度为（C ）。

A ．3
B ．4
C ．5
D ．6
114B2（66）．由带权为9，2，5，7的四个叶子结点构造一棵哈夫曼树，该树的带权路径长度为（D ）。

A ．23
B ．37
C ．46
D ．44
112C2（67）．二叉树的先序遍历为EFHIGJK ，中序遍历为HFIEJKG ，则该二叉树根的右子树的根是（C ）。

A ．E
B ．F
C ．G
D ．H
111A1（68）．在完全二叉树中，若一个结点是叶结点，则它没有（C ）。

A ．左孩子结点
B ．右孩子结点
C ．左孩子和右孩子结点
D ．左孩子结点，右孩子结点和兄弟结点 113B2（69）．（B ）二叉树，可以唯一地转化成一棵一般树。

A ．根结点无左孩子
B ．根结点无右孩子
C ．根据结点有两个孩子
D ．没有一棵
111C2（70）．具有65个结点的完全二叉树其深度为（B ）。

A ．8
B ．7
C ．6
D ．5
112C2（71）．某二叉树的先序序列和后序序列正好相反，则该二叉树一定是（B ）的二叉树。

A ．空或只有一个结点
B ．高度等于其结点数
C ．任一结点无左孩子
D ．任一结点无右孩子 113A1（72）．下面叙述中，不正确的是（C ）。

A ．线性表中除第一个元素和最后一个元素外，其他每个元素都有且仅有一个直接前驱和一个直接
后继
B ．树中有且仅有一个结点没有前驱
C ．环形队列中任何一个元素都有且仅有一个直接前驱和一个直接后继
D ．在树中，一个结点可以有多个直接后继
114B2（73）．有m 个叶子结点的哈夫曼树，其结点总数是（C ）。

A ．2m
B ．2m+1
C ．2m-1
D ．2（m+1）
115A1（74）．设图的邻接矩阵为⎥⎥⎥⎦
⎤⎢⎢⎢⎣⎡010100110，则该图有（A ）个顶点。

A ．3 B ．4 C ．6 D ．9
115B2（75）．设图的邻接矩阵为⎥⎥⎥⎦
⎤⎢⎢⎢⎣⎡010100110，则该图为（A ）。

A ．有向图 B ．无向图 C ．强连通图 D ．完全图
115B2（76） 1 2 3 4 A ．4 B ．5 C ．10 D ．20
115C2（77）．设有6个结点的无向图，该图至少应有（B ）条边才能确保是一个连通图。

A ．5
B ．6
C ．7
D ．8
116D3（78）．已知一有向图的邻接表存储结构如下，则根据有向图的深度优先遍历算法，从顶点V 1出发，不能得到的顶点序列是（C ）。

A ．V 1V 2V 3V 5V 4
B ．V 1 V 3 V 4V 5V 2
C ．V 1V 2V 4V 5V 3
D ．V 1 V 4V 3V 5V 2
119C3（79）．下列图的深度优先遍历序列为（B ）。

A ．ABCDEFGH
B ．ABDHECFG
C ．ABEDHCFG
D ．ABCFGEDH
115B1（80）．对一个具有n 个顶点的图，采用邻接矩阵表示则该矩阵的大小为（D ）。

A ．n
B ．（n-1）2
C ．（n+1）2
D ．n 2
118B2（81）．对含n 个记录的顺序表进行顺序查找，在最坏情况下需要比较（B ）次。

A ．n-1
B ．n
C ．（n+1）/2
D ．n （n-1）/2
118B2（82）．对含n 个记录的有序表进行折半查找，设每个记录的查找概率相等，则平均查找长度的
数量级为（C ）。

A ．O （n ）
B ．O （n 2）
C ．O （n 2log ）
D ．O （1）
119B2（83
A ．二叉平衡树
B ．二叉排序树
C ．堆的形状
D ．以上都不是
119C3（84）．已知10个数据元素（50，30，15，35，70，65，95，60，25，40），按照依次插入结点
的方法生成一棵二叉排序树后，在查找成功的情况下，查找每个元素的平均比较次数（又称平均查找长度）为（C ）。

A ．2.5
B ．3.2
C ．2.9
D ．2.7
118C3（85）．在顺序存储的线性表R[0‥29]上进行分块查找（设分为5块）的平均查找长度为（D ）。

A ．6
B ．11
C ．5
D ．6.5
120D3（86）．已知一个线性表（38，25，74，63，52，48），假定采用h （k ）=k%7计算散列地址进行
散列存储，若引用线性探测的开放定地址法解决冲突，则在该散列表上进行查找的平均查找长度为
（C ）。

A ．1.5
B ．1.7
C ．2
D ．2.3
119A1（87）．在一个3阶的B-树上，每个结点包含的子树相同，最多为（C ）。

A ．1
B ．2
C ．3
D ．4
120B2（88）．设散列地址空间为0~m-1，k 为关键字，用P 去除k ，将余数作为k 的散列地址，即：h
（k ）=k%P ，为了减少发生冲突的可能性，一般取P 为（B ）。

A ．小于m 的最大奇数
B ．小于m 的最大素数
C ．小于m 的最大偶数
D ．小于m 的最大合数
120C3（89）．设散列表表长m=14，散列函数为h （k ）=k%11，表中已有4个记录，如果用二次探测
再散列处理冲突，关键字为49的记录的存储地址是（D ）。

A．8 B．3 C．5 D．9
119C3（90）．已知8个元素（34，76，45，18，26，54，92，65），按照依次插入结点的方法生成一棵二叉排序树，该树的深度为（C）。

A．4 B．5 C．6 D．7
121B1（91）．直接插入排序算法的时间复杂度为（B）。

log）D．O（1）
A．O（n）B．O（n2）C．O（n
2
121B2（92）．设记录关键字序列为（84，67，21，50，33，79），采用对半插入排序方法自小到大进行排序时，记录的移动次数为（C）。

A．9 B．10 C．19 D．25
123D3（93）．下列四个序列中，（D）不是快速排序第一趟的可能结果。

A．[68，11，69，23，18，70，73] 93 B．11 [68，69，23，18，70，73，93]
C．[68，11，69，23，18] 70 [93，73] D．[18，11，23] 93 [68，70，69，73]
122C3（94）．下列四个关键字序列中，（C）不是堆。

A．{05，23，16，68，94，72，71，73} B．{05，16，23，68，94，72，71，73}
C．{05，23，16，73，94，72，71，68} D．{05，23，16，68，73，71，72，94}
123B2（95）．从未排序序列中依次取出元素与已排序序列中的元素作比较，将其放入已排序序列中的正确位置上，此方法称为（D）。

A．归并排序B．选择排序C．交换排序D．插入排序
123B2（96）．在所有排序方法中，关键字的比较次数与记录的初始排列无关的是（D）。

A．Shell排序B．冒泡排序C．直接插入排序D．直接选择排序
123B2（97）．下列排序算法中，第一趟排序后，任一元素都不能确定其最终位置的算法是（B）。

A．选择B．插入C．冒泡D．快速
123C2（98）．采用下列排序算法对n个元素进行排序，其排序趟数肯定为n-1趟的排序方法有（A）。

A．选择和插入B．冒泡和快速C．插入和快速D．选择和冒泡
123D3（99）．若用冒泡排序方法对序列{10，14，26，29，41，52}从大到小进行排序，需要进行（C）次比较。

A．5 B．10 C．15 D．25
121C3（100）．用直接插入排序方法对下面四个序列进行排序（由小到大），元素比较次数最少的是（C）。

A．94，32，40，90，80，46，21，69 B．32，40，21，46，69，94，90，80
C．21，32，46，40，80，69，90，94 D．90，69，80，46，21，32，94，40
二、填空题
101A1（1）．数据结构按逻辑结构可分为两大类，它们分别是（线性结构和非线性结构）。

101A1（2）．算法的计算量的大小称为（计算的复杂度）。

102B2（3）．顺序存储的线性表，设其长度为n ，在任何位置上插入或删除操作的时间代价基本上都是
等效的。

则插入一个元素大约要移动表中的（n/2）个元素。

103A2（4）．顺序表相对于链表的优点有（节省存储）和（随机存取）。

103B2（5）．线性表的长度是（表中数据元素的个数）。

103D3（6）在带有头结点的双链表L 中，指针p 所指结点是第一个元素结点的条件是（p=L->next ；或
L->next=p ；）。

103C3（7）．某链表如下所示
104A1（8）．对于栈只能在（栈顶）插入和删除元素。

104C2（9）．设有一空栈，现有输入序列1，2，3，4，5，6，经过push ，push ，pop ，push ，pop ，push ，push 后，输出序列是（2、3）。

106B2（10）．有一个循环队列如下图，其队满条件是（front=(rear+1)%n ），队列空的条件是（rear=front ）。

front
队头指针
队尾指针
109B2（11）．一个稀疏矩阵为⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎣⎡-00005100000302
00，则对应的三元组线性表为（（（0，2，2），（1，0，3），（2，2，-1），（2，3，5）））。

108C2（12）．设有二维数组A[0‥9，0‥19]，其每个元素占两个字节，数组按列优先顺序存储，第一个元素的存储地址为100，那么元素A[6，6]的存储地址为（232）。

112B1（13）．在一棵二叉排序树上按（中序）遍历得到的结点序列是一个有序序列。

111C3（14）．对于一棵具有n 个结点的二叉树，当进行链接存储时，其二叉链表中的指针域的总数为
2n 个，其中（n-1）个用于链接孩子结点。

112B2（15）．对于下面的二叉树，按后序遍历得到的结点序列为（4，2，5，6，3，1）。

115B1（16）0）边。

117C3（17）．对下列图
它的生成树有（6）棵。

118C3（18）．假定在有序表R[0‥19]上进行二分查找，则比较三次查找成功的结点数为（4）。

120D3（19）．设有两个散列函数H1（K）=K mod 13和H2（K）=K mod 11+1，散列表为T[0‥12]，用双重散列法（又称二次散列法）解决冲突。

函数H1用来计算散列地址，当发生冲突时，H2作为计算下一个探测地址的地址增量。

假定某一时刻散列表T的状态为：
T
下一个被插入的关键码为42，其插入位置是（0）。

122C3（20）．已知一棵二叉排序树如下图所示，则在查找成功的情况下查找每个元素的平均查找长度为（2.75）。

三、完形填空题
102D2（1）．设顺序存储的线性表存储结构定义为：
struct sequnce
{ELEMTP elem[MAXSIZE]；
int len；/*线性表长度域*/
}
将下列简单插入算法补充完整。

void insert（struct sequnce *p，int i，ELEMTP x）
{v=*p；
if（i<1）||（i>v.len+1）printf（“Overflow“）；
else {
for（j=v.len；j>=i；j- -）v.elem[j+1]=v.elem[j]；
v.elem[i]= x ；v.len=v.len+1；
}
}
103D3（2）．设线性链表的存储结构如下：
struct node
{ELEMTP data；/*数据域*/
struct node *next；/*指针域*/
}
试完成下列在链表中值为x的结点前插入一个值为y的新结点。

如果x值不存在，则把新结点插在表尾的算法。

void inserty（struct node *head，ELEMTP x，ELEMTP y）
{s=（struct node *）malloc（sizeof（struct node））；
s->data=y；
if（head->data= =x）{s->nexr=head；head=s；}
else {
q=head；p=q->next；
while（p->dqta!=x&&p->next!=NULL）{q=p；p=p->next；}
if（p->data= = x）{q->next=s；s->next=p；}
else{p->next=s；s->next=NULL；}
}
}
103D3（3）．设线性链表的存储结构如下：
struct node
{ELEMTP data；/*数据域*/
struct node *next；/*指针域*/
}
试完成下列建立单链表的算法。

creat（）
{char var；
head=（struct node *）malloc（sizeof（struct node））；
head->next= NULL ；
while（（var=getchar（））！=‘\n’）{
ptr=（struct node *）malloc（sizeof（struct node））；
ptr->data= var ；ptr->next=head->next；
head->next= ptr ；
}
}
103D3（4）．下列算法将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同，试完成该算法。

void DelSameNode（LinkList L）
//L是带头结点的单链表，删除其中的值重复的结点//
{ListNode * p，*q，*r；
p=L->next；//p初始指向开始结点//
while（p）{ //处理当前结点p//
q=p；
r=q->next；
do { //删除与结点*p的值相同的结点//
while（r&&r->data!=p->data）{
q=r；
r=r->next；
}
if（r）{ //结点*r的值与*p的值相同，删除*r//
q->next=r->next；
free（r）；
r=q->next；
}
}while（r ）；
p=p->next；
}
}
106D3（5）假设以带头结点的循环链表表示队列，并且只设一个指针R指向队尾元素结点（注意不设头指针），下列为出队一个元素的算法。

DeList（R，e）
LinkList *R，p；
ElemType e；
{p=R->next->next；
e=p->data；
R->next->next=p->next；
if（p= =R）R=R->next；
free（p）；
}
105D3（6）．链队列的存储结构为：
struct nodetype
{ELEMTP data；
struct nodetype *next；
}
struct linkqueue
{struct nodetype *front，*rear；
} /*front和rear分别为队列的头指针和尾指针*/
完成下列删除队头元素的算法。

delq（struct linkqueue *r，ELEMTP *x）
{q=*r；
if（q.front= =q.rear）printf（“QUEUE IS EMPTY\n“）；
else{p=q.front->next；
q.front->next=p->next；
if（p->next= =NULL）q.rear=q.front；
*x=p->data；free（p）；
}
111D3（7）．下面算法实现，用一棵二叉树中的结点建立一个按关键字值从小到大次序排列的带表头结点的双向循环链表。

二叉树的结点结构如下所示：
其中，p p->left和p->right分别表示结点的左、右孩子的指针域。

void fromtreetolist（p，l）
/*p，h是指向二叉树中结点的指针，*/
/*l是指向双向循环链表表头结点的指针*/
{if (p!=NULL)
{ fromtreetolist（p->left，l）；
fromtreetolist（p-> right，l）；
h=l；
while （h->right!=l）&&（h->right->key<p->key）h=h->right；
p->right=h->right；
p->left=h；
h->right->left=p；
h->rihght=p；
}
}
void buildlisttree（root，l）
/*root是指向二叉树根结点的指针，*/
/*l是指向双向循环链表表头结点的指针*/
{l=（struct nodetype *）malloc（sizeof（struct nodetype））；
l->left=l；
l->right=l；
fromtreetolist（root，l）；
}
115D3（8）．下列算法将图的邻接矩阵存储结构转换为如下图所示的邻接表存储结构。

图中左侧的记录数组的每个结点有两个域：el和fst；右侧链表中的结点是类型为node的记录类开，每个结点有两个域：adj和link。

若指针p指向node类型的结点，则对该结点的adj、link域的引用表示为：p->adh、p->link。

el fst adj link
void
/*c是邻接矩阵，n为阶数。

G是上图所示的邻接表*/
/*p、q是指向node类型结点的指针*/
/*i，j为整型*/
{ for（i=1；i<=n；i++）g[i].fst=NULL；
for（j=1；j<=n；j++）
if（c[i，j]!=0）
{ q=（struct nodetype *）malloc（sizeof（struct nodetype））；
q->link=NULL；
q->adj=j；
if（q[i].fst=NULL）
{q[i].fst=q ；
p=q；
}
else{ p->link=q；
p=q；
}
}
}
}
123D3（9）．在下面冒泡排序算法中填入适当内容，以使该算法在发现有序时能及时停止。

bubble（R）
Rectype R[n]；
{int i，j，exchang；
Rectype temp；
i=1；
do
{exchang=False；
for（j=n；j>=i+1 ；j- -）
if（R[j]<R[j-1]
{temp=R[j-1]；
R[j-1]=R[j]；
R[j]=temp；
exchang=True ；
}
i=i+1 ；
}while（exchang=False ）；
}
121D3（10）．完成下列折半插入排序算法。

Void binasort（struct node r[MAXSIZE]，int n）
{for（i=2；i<=n；i++）{
r[0]=r[i]；low=1；high=i-1；
while（low<=high）{
mid=（low+high）/2；
if（r[0].key<r[mid].key）high=mid-1 ；
else low=mid+1 ；
}
for（j=i-1；j>=low；j- -）r[j+1]=r[j] ；
r[low]=r[0] ；
}
}。