数据结构习题与答案Word文件下载.docx
《数据结构习题与答案Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构习题与答案Word文件下载.docx（18页珍藏版）》请在冰豆网上搜索。
C.front=（frontmodm）+1
D.front=（front+1）mod（m-1）
11、设s=’IAMASTUDENT’,t=’GOOD’,q=’WORKER’则Concat（Substring（s,6,2）
Concat（t,Replace（s,’STUDENT’,q）））=（）。
A.AGOODWORKER
B.AGOODIAMAWORKER
C.STGOODSTUDENT
D.AGOODSTUDENT
12、设串sl=″Data_Structures_with_Java″,s2=“it″，则子串定位函数index（s1,s2）的值为（ ）。
A.16
B.15
C.17
D.18
13、数组A中，每个元素A的长度为3个字节，行下标i从1到8，列下标j从1到10，从首地址SA开始连续存放在存储器内，存放该数组至少需要的单元数是（）。
A.100
B.80
C.270
D.240
14、假设有二维数组A6×
8，每个元素用相邻的6个字节存储，存储器按字节编址。
已知A的起始存储位置为1000，计算数组A按行存储时元素A[14]第一个字节的位置（）。
A.1072
B.1018
C.1030
D.1024
15、广义表（（（））,a,（（b,c）,（）,d）,（（（e））））的长度为（）。
A.4
B.5
C.2
D.3
16、下面说法不正确的是（）。
A.广义表可以是一个多层次的结构
B.广义表难以用顺序存储结构
C.广义表的表头总是一个广义表
D.广义表的表尾总是一个广义表
17、已知一棵树边的集合为{<
I,M>
<
I,N>
E,I>
B,E>
B,D>
A,B>
G,J>
G,K>
C,G>
C,F>
H,L>
C,H>
A,C>
},问这棵树中结点G的双亲结点为（）。
A.I
B.C
C.B
D.A
18、一棵二叉树中，叶子的个数为10，则其度为2的结点的个数为（）。
A.10
B.12
C.9
D.11
19、假如一棵二叉树的中序遍历结果为ABCD，则结点A和结点D的关系一定不是（）。
A.结点A是结点D的左子树上的结点
B.结点A是结点D的右子树上的结点
C.结点A是结点D的双亲结点
D.结点A与结点D具有共同的双亲的右子树上的结点
20、已知一棵树边的集合为{<
},将此树转化为二叉树后，E的左孩子为（）
A.B
B.A
C.C
D.I
21、一棵哈夫曼树有17个结点，则其叶子结点的个数是（）。
B.8
C.7
D.9
22、下图中结点B的出度为（）
A.1
B.3
D.0
23、对于一个具有n个顶点的无向图,若采用邻接矩阵表示,则该矩阵的大小为（）
A.n×
n
B.（n-1）×
（n-1）
C.n×
（n+1）
D.（n-1）×
n
24、采用邻接表存储的图的宽度优先遍历算法类似于二叉树的（）
A.先序遍历
B.后序遍历
C.层次遍历
D.中序遍历
25、下面的无向带权图的最小生成树包含的边有（）
A.aeebbccddfeg
B.aegegfebbccd
C.aeeddccbegdf
D.aggffddccbbe
26、判定一个有向图是否存在回路除了可以利用拓扑排序方法外,还可以利用（）
A.深度优先遍历算法
B.求最短路径的Dijkstm方法
C.求关键路径的方法
D.宽度优先遍历算法
27、对线性表进行二分查找时,要求线性表必须（）。
A.以顺序方式存储
B.以顺序方式存储,且结点按关键字有序排序
C.以链接方式存储
D.以链接方式存储,且结点按关键字有序排序
28、下列描述中不符合二叉排序树特点的是（）
A.根结点的关键字大于左、右子树中所有结点的关键字
B.左子树中所有结点的关键字小于根结点的关键字
C.右字树中所有结点的关键字大于根节点的关键字
D.关键字插入的顺序影响二叉排序树的形态
29、设哈希表长m=14，哈希函数H（key）=key%11。
表中已有4个结点：
addr（15）=4;
addr（38）=5;
addr（61）=6;
addr（84）=7
如用二次探测再散列处理冲突，关键字为49的结点的地址是（）。
A.9
C.8
D.5
30、设一组初始记录关键字序列为（50，40，95，20，15，70，60，45），则以增量d=4的一趟希尔排序结束后前4条记录关键字为（）。
A.15，20，40，45
B.15，40，60，20
C.45，40，15，20
D.40，50，20，95
31、快速排序方法在情况下最不利于发挥其长处。
（）
A.要排序的数据个数为奇数
B.要排序的数据中含有多个相同值
C.要排序的数据已基本有序
D.要排序的数据量太大
32、一组记录的排序码为（46,79,56,38,40,84）,则利用堆排序的方法建立的初始推为（）
A.84,79,56,38,40,46
B.84,79,56,46,40,38
C.79,46,56,38,40,80
D.84,56,79,40,46,38
33、设一组初始记录关键字序列为（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，20，36，40，70，85
D.15，25，35，50，80，85，20，36，40，70
34、设有1000个无序的元素,希望用最快的速度挑选出其中前10个最大的元素,最好的排序方法是（）。
A.插入排序
B.堆排序
C.快速排序
D.选择排序
35、具有10个记录的序列，采用冒泡排序最少的比较次数是（）
A.54
B.1
C.81
36、设一组初始记录关键字序列为（345，253，674，924，627），则用基数排序需要进行（）趟的分配和回收才能使得初始关键字序列变成有序序列。
二、填空题
1、假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，请编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许表中含有值相同的元素）排列的线性表C，并要求利用原表（即A表和B表）的结点空间构造C表。
//将合并逆置后的结果放在C表中，并删除B表
StatusListMergeOppose_L（LinkList&
A,LinkList&
B,LinkList&
C）{
LinkListpa,pb,qa,qb;
pa=A;
pb=B;
qa=pa;
//保存pa的前驱指针
qb=pb;
//保存pb的前驱指针
pa=pa->
next;
pb=pb->
A->
next=NULL;
C=A;
while（pa&
&
pb）{
if（pa->
data<
pb->
data）{
qa->
next=A->
next=qa;
}else{
//将当前最小结点插入A表表头
next=qb;
}
while（pa）{
while（pb）{
qb->
free（pb）;
returnOK;
}
qb->
2、假设某个单向循环链表的长度大于1，且表中既无头结点也无头指针。
已知s为指向链表中某个结点的指针，试编写算法在链表中删除指针s所指结点的前驱结点。
StatusListDelete_CL（LinkList&
S）{
LinkListp,q;
if（S==S->
next）returnERROR;
q=S;
p=S->
while（）{
q=p;
p=p->
q->
next=p->
free（p）；
p->
next!
=s
3、试写一个算法，识别依次读入的一个以@为结束符的字符序列是否为形如‘序列1&
序列2’模式的字符序列。
其中序列1和序列2中都不含字符‘&
’，且序列2是序列1的逆序列。
例如，‘a+b&
b+a’是属该模式的字符序列，而‘1+3&
3-1’则不是。
BOOLSymmetry（chara[]）{
inti=0;
Stacks;
InitStack（s）;
ElemTypex;
while（a[i]!
='
'
&
a[i]）{
;
i++;
if（a[i]）returnFALSE;
while（a[i]）{
Pop（s,x）;
if（x!
=a[i]）{
DestroyStack（s）;
returnFALSE;
returnTRUE;
Push（s,a[i]）
4、假设称正度和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’则不是回文。
试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。
StatusSymmetryString（char*p）{
Queueq;
if（!
InitQueue（q））return0;
ElemTypee1,e2;
while（*p）{
Push（s,*p）;
;
p++;
while（!
StackEmpty（s））{
Pop（s,e1）;
DeQueue（q,e2）;
if（e1!
=e2）returnFALSE;
EnQueue（q,*p）
5、试按教科书5.5节图5.10所示的结点结构编写复制广义表的递归算法。
//由广义表L复制广义表T
intCopyGList（GList&
T,GList&
L）{
L）T=NULL;
else{
T=newGLNode;
T）exit（OVERFLOW）;
T->
tag=L->
tag;
if（L->
tag==ATOM）T->
atom=L->
atom;
CopyGList（T->
tp,L->
tp）;
CopyGList（T->
hp,L->
hp）
6、编写递归算法，将二叉树中所有结点的左、右子树相互交换。
StatusExchangeBiTree（BiTree&
T）
{
BiTreep;
if（T）{
p=T->
lchild;
lchild=T->
rchild;
rchild=p;
ExchangeBiTree（T->
rchild）;
ExchangeBiTree（T->
lchild）
7、试写一个算法，为一棵二叉树建立后序线索二叉树。
StatusPostOrderThreading（BiThrTree&
T,BiThrTree&
pre）;
//首先建立后序线索树
StatusFindNextInBiThrTree（BiThrTree&
q,TElemType*p）;
//再进行查找
//后序线索二叉树的算法
Thrt,BiThrTree&
T）{
BiThrTreepre;
Thrt=newBiThrNode;
//为线索二叉树建立头结点
Thrt）exit（OVERFLOW）;
Thrt->
LTag=Link;
RTag=Thread;
rchild=Thrt;
//右子树回指
T）Thrt->
lchild=Thrt;
//若二叉树空，左子树回指
lchild=T;
pre=Thrt;
PostThreading（T,pre）;
//后序遍历进行后序线索化
pre->
//最后一个结点线索化
rchild=pre;
StatusPostThreading（BiThrTree&
pre）{
if（T->
LTag==Link）PostThreading（T->
lchild,pre）;
RTag==Link）PostThreading（T->
rchild,pre）;
T->
lchild）{
LTag=Thread;
if（pre&
!
pre->
rchild）{
rchild=T;
pre=T;
lchild=pre
8、编写算法实现建立图的邻接表
StatusCreateAG（ALGraph&
G）{
intn,e,k,i,j;
cout<
<
"
请输入顶点数：
;
cin>
>
n;
请输入边数：
e;
G.vernum=n;
G.arcnum=e;
//建立顶点数组
for（k=0;
k<
G.vernum;
k++）{
请输入顶点信息：
G.vertices[k].data;
G.vertices[k].firstarc=NULL;
//建立邻接表
VertexTypev1,v2;
ArcNode*p,*q;
G.arcnum;
请输入弧的始点和终点信息，中间用空格分开:
v1>
v2;
i=LocateVex（G,v1）;
if（i<
0||i>
G.vernum-1）returnERROR;
j=LocateVex（G,v2）;
if（j<
0||j>
if（i==j）returnERROR;
p=newArcNode;
p）returnERROR;
p->
adjvex=j;
nextarc=NULL;
q=G.vertices[i].firstarc;
q）G.vertices[i].firstarc=p;
while（q->
nextarc）；
//指针定位于邻接表的尾结点
nextarc=p;
q=q->
nextarc
9、编写算法实现从邻接表中取出某个顶点V的存储位置。
intLocateVex（ALGraph&
G,VertexTypev）
while（&
i<
G.vernum）i++;
if（G.vertices[i].data==v）returni;
elsereturn-1;
G.vertices[i].data!
=v
10、试将折半查找的算法改写成递归算法。
Intbisearch（sqlistL,intlow,inthigh,elemtypex）{
If（low>
high）reeturn（0）;
else{mid=（low+high）/2;
if（L.data[mid]==x）return（mid）;
elseif（L.data[mid]>
x）bisearch（L,low,mid-1,x）;
else;
}
}//bisearch
bisearch（L,mid+1,high,x）
11、设计算法判定给定二叉树是否为二叉排序树。
voidBSTree（BiTreet,int&
flag,int&
last）;
//声明
StatusIsBSTree（BiTreet）{
intflag=1;
intlast=0;
BSTree（t,flag,last）;
returnflag;
last）{//取地址不需要返回值
if（t->
lchild&
flag）BSTree（t->
lchild,flag,last）;
//遍历左子树
data.key>
last&
flag）last=t->
data.key;
elseflag=0;
//last原为父节点值，但到了树叶节点后被树叶节点的key值覆盖，然后开始向上反馈key
if（t->
rchild&
flag）；
BSTree（t->
rchild,flag,last）
12、试以L.r[k+1]作为监视哨改写教科书10.2.1节中给出的直接插入排序算法。
其中，L.r[1..k]为待排序记录且k<
MAXSIZE。
voidInsertionSort（SqList&
L）{//对顺序表L作直接插入排序。
for（i=k-1-1;
i>
=1;
--i）{
if（L.r[i+1].key<
L.r[i].key）{
L.r[k+1]=L.r[i];
//复制为监视哨
for（j=i+1;
L.r[k+1].key>
L.r[j].key;
++j）
L.r[j]=L.r[j+1];
//记录前移
}//endif
；
}//endfor
}//InsertSort
L.r[j-1]=L.r[k+1]
13、编写算法，对n个关键字取整数值的记录序列进行整理，以使所有关键字为负值的记录排在关键字为非负值的记录之前，要求：
（1）采用顺序存储结构，至多使用一个记录的辅助存储空间；
（2）算法的时间复杂度为O（n）;
voidDivide（inta[],intn）{//把数组a中所有值为负的记录调到非负的记录之前
low=0;
high=n-1;
while（low<
high）{
high&
a[high]>
=0）high--;
//以0作为虚拟的枢轴记录
;
a[low]<
0）low++;
->
a[high];
}//Divide
a[high]
升级会员 