数据结构习题库汇总

知识点：
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〕．设在链式存储的线性表中，设结点构造为data link ，欲在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
表示队尾指针，结点构造为data next ，删除链队列的队头结点的主要语
句为〔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〕．字符串“VARTYPE 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 ．ABCDEF
B ．ADCBFE
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
B E
C F
D
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〕．设图的邻接链表如以下图所示，那么该图有〔B〕条边。

1 V1
2
3
4 ^
2 V2 1
3
4 ^
3 V3 1 2 ^
4 V4 1 2 ^
A．4 B．5 C．10 D．20
115C2〔77〕．设有6个结点的无向图，该图至少应有〔B〕条边才能确保是一个连通图。

A．5 B．6 C．7 D．8
116D3〔78〕．一有向图的邻接表存储构造如下，那么根据有向图的深度优先遍历算法，从顶点V1出发，不能得到的顶点序列是〔C〕。

1 3
2 4 ^
2 ^
3 4 5 ^
4 ^
5 2 4 ^
A．V1V2V3V5V4B．V1V3V4V5V2C．V1V2V4V5V3D．V1 V4V3V5V2
119C3〔79〕．以下图的深度优先遍历序列为〔B〕。

A B．ABDHECFG C．ABEDHCFG
D．
115B1〔80〕．对一个具有n个顶点的图，采用邻接矩阵表示那么该矩阵的大小为〔D〕。

A．n B．〔n-1〕2C．〔n+1〕2D．n2
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〔n2〕C．O〔n
log〕D．O〔1〕
2
119B2〔83〕．有一棵二叉树如以下图，该树是〔B〕。

50
20 95
10 30 55
70
85
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．
118C3〔85〕．在顺序存储的线性表R[0‥29]上进展分块查找〔设分为5块〕
的平均查找长度为〔D〕。

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

A．1.5 B．1.7 C．2 D．
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〕。

0 1 2 3 4 5 6 7 8 9 10 11 12 13
15 38 61 84
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〕。

A．O〔n〕B．O〔n2〕C．O〔n
log〕D．O〔1〕
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〕．某链表如下所示
info link p
A B C D E ^
假设要删除值为C的结点，应做操作〔p->link=p->link->link〕。

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
…队头指针
rear
队尾指针
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〕。

1
2 3
4 5 6
115B1〔16〕．设无向图G 的顶点数为n ，图G 最少有〔0〕边。

117C3〔17〕．对以下图
1
6 2
5 3
4
它的生成树有〔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的状态为：
0 1 2 3 4 5 6 7 8 9 10 11 12
T：80 55 34
下一个被插入的关键码为42，其插入位置是〔0〕。

122C3〔20〕．一棵二叉排序树如以下图所示，那么在查找成功的情况下查找每个元素的平均查找长度为〔〕。

80
50 90
40 70 100
60 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>=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〔〕printf〔“QUEUE IS EMPTY\n“〕；
else{p=q.front->next；
q.front->next=p->next；
if〔p->next= =NULL〕；
*x=p->data；free〔p〕；
111D3〔7〕．下面算法实现，用一棵二叉树中的结点建立一个按关键字值从小到大次序排列的带表头结点的双向循环链表。

二叉树的结点构造如下所示：
left key right
其中，p是指向结点的指针；p->key表示结点的关键字域，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
2 3 ^
4 ^
3 1 ^
4 2 3 ^
void Convert〔c，g〕
/*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] ；。