数据结构模拟题1讲解.docx

数据结构模拟题1讲解.docx

《数据结构模拟题1讲解.docx》由会员分享，可在线阅读，更多相关《数据结构模拟题1讲解.docx（15页珍藏版）》请在冰豆网上搜索。

数据结构模拟题1讲解

数据结构试题1

总共：

15题，共100.0分

一、单选（共8小题，24.0分）

1.向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动______个元素。

（3分）

A.8　　　　　　　B.63.5

C.63　　　　　　D.7

2.设有一个二维数组A[m][n],假设A[0][0]存放位置在644（10）,A[2][2]存放位置在676（10），每个元素占一个空间，则A[4][5]在（）位置，（10）表明用10进数表示。

（3分）

A.672（10）　　　　　　　B.626（10）

C.709（10）　　　　　　　D.724（10）

3.一个有序顺序表有255个对象，采用顺序搜索法查表，平均搜索长度为________。

（3分）

A.128　　　　　B.127

C.126　　　　　D.255

4.含5个结点（元素值均不相同）的二叉顺序搜索法查表，平均搜索长度为_______。

（3分）

A.54　　　　　B.42

C.36　　　　　D.65

5.在分析折半搜索的性能时常加入失败结点，即外结点，从而形成扩充的二叉树。

若设失败结点i所在层次为Ii，那么搜索失败到达失败所做的数据比较次数是__________。

（3.0分）

A.Ii+1　　　　B.Ii+2

C.Ii-1　　　　D.Ii

6.设有一个含200个表项的散列表，用线性探查法解决冲突，按关键码查询时找到一个表项的平均控查次数不超过1.5，则歼列存储空间应容纳________个表项。

（设搜索成功的平均搜索长度为sm=（1+1/（1-α））/2，其中α为装填因子）

A.400　　　　B.526

C.624　　　　D.676

7.n个顶点的连通图至少有______条边。

（3.0分）

A.n-1　　　　B.n

C.n+1　　　　D.0

8.一个二叉树按顺序方式存储在一个一维数组中，如图

0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

A

B

C

D

E

F

G

H

I

J

二、简答（共4小题，46.0分）

1.如右所示的连通图，请画出：

（1）以顶点①为根的深度优先生成树；

（2）如果有关节点，请找出所有的关节点。

2.设有13个初始归并段，其长度分别为28，16，37，42，5，9，13，14，20，17，30，12，18。

试画出4路归并时的最佳归并树，并计算它路径长度WPL。

（12.0分）

3.设散列表HT[0..12]，，即表的大小为m=13。

采用双散列法解决冲突。

散列函数和再散列函数分别为：

H0（Key）=Key%13注：

％是求余数运算（=mod）

Hi=（Hi-1+Rev（key+1）%11+1）%13

i=1,2,3,...m-1

其中，函数REV（x）表示颠倒10进制数x的各位，如REV（37）=37，REV（7）=7等。

若插入的关键码序列为{2,8,31,20,19,53,27}，画出插入这8个关键码后的散列表。

　0

　1

　2

　3

　4

　5

　6

　7

　8

　9

　10

　11

　12

4.已知一棵二叉树如左，请分别写出按前序、中序、后序和层次遍历时得到的结点序列。

三、计算（共1小题，10.0分）

1.有一种简单的排序算法，叫做计数排序（countsorting）。

这种排序算法对一个待排序的表（用数组表示）进行排序，并将排序结果放入一个新的表中。

必须注意的是，表中所有待排序的关键码互不相同。

计数排序算法针对表中的第个记录，投其所好待排序的表一趟，统计表中多少个记录的关键码比该记录的关键小。

假设针对某一个记录，统计出的计数值为C，那么，这个记录在新的有序表中的合适的存放位置即：

（1）给出适用于计数排序的数据表定义；（4分）

（2）使用C++语言编写实现计数排序的算法；（4分）

（3）对于有n个记录的表，关键码比较次数是多少？

（2分）

四、其它（共2小题，20.0分）

1.intunknown（BinTreeNode*t）{

　　//指针t是二叉树的根指针

　　if（t==NULL）return0;

　　elseif（t→leftChild）==NULL&&t→rightChild==NULL）return1;

　　　　　elsereturnunknown（t→leftChilk）+unknown（t→rightChild）;

}（10.0分）

2.下面给出的是一个在二叉树中查找值为x的结点，并打印该结点所有祖先结点的算法。

在此算法中，假设值为X的结点不多于一个。

此算法排序的非递归遍历形式。

因退栈时需要区分其左、右子树是否已经遍历，故在结点进栈时附带有一个标志=0，进入左子树，=1，进入右子树栈ST保存结点指针ptr以及标志tag,top是栈顶指针。

voidprint（BinTreeNode*t;Type&x）{

　　　stackST;inti,top;

　　　top=0;//置空栈

　　　while（t!

=NULL&&t→data!

=x||top!

=0）{//寻找值为X的结点

　　　　　while（t!

=NULL&&t→data!

=x）{

　　　　　①____________________;

　　　　　ST[top].ptr=t;//进栈

　　　　　ST[top].tag=0;

　　　　　②___________________;

　　　｝

　　　if（t!

=NULL&&t→data==x）//找到值为X的结点

　　　　for（i=1;③____________________;i++）

　　　　　　cout<

　　　else{

　　　　　　　while（top>0&&ST[top].tag==1）//未找到值为X的结点

　　　　　　　　　top--;

　　　　　　　　　if（top>0）{

　　　　　　　　　　　ST[top].tag=1;//转向右子树

　　　　　　　　　　　④__________________;

　　　｝

　　｝

　｝

｝

（1）请将缺失的语句补上

（2）请给出对于右图所示的二叉树，使用上述算法搜索值为9的结点和值为10的结点的结果，以及在栈ST中的变化。

（top是栈顶指针）

数据结构试题1答案

一、单选

1.B2.C3.A4.B5.D6.A7.A8.B

二、简答

1.

（1）、该连通图从①出做深度优先搜索，得到的深度优先生成树为：

结果不唯一（6分）

（2）、关节点为①、②、③、⑦、⑧（6分）

2.因为（13-1）％（4-1）=12%3=0,所以不需要添加空段。

最佳归并树为WPL=（5+9+13+12+16+14+17+18+28+37+20+30）*2+42=480

散列表HT[0..12]，散列函数与再散列函数为

H0（key）=keymod13;

Hi=（Hi-1+REV（key+1）mod11+1）mod13;

插入关键码序列为{2,8,31,20,19,18,53,27}

H0

（2）=2,比较次数为1　　　　H0（8）=8,比较次数为1

H0（31）=5,比较次数为1　　　　　H0（20）=7,比较次数为1

H0（19）=6,比较次数为1

H0（18）=5,冲突，H1=9，比较次数为2

H0（53）=1,比较次数为1

H0（27）=1,冲突，H1=7，冲突，H2=0，比较次数为3

插入8个关键码后的散列表

0

1

2

3

4

5

6

7

8

9

10

11

12

27

53

2

31

19

20

8

18

4.各遍历次序如下：

（10分）

前序：

A,B,D,G,C,E,F,H（2分）

中序：

D,G,B,A,E,C,H,F（3分）

后序：

G,D,B,E,H,F,C,A（2分）

层次：

A,B,C,D,E,F,G,H（3分）

三、计算

1.

（1）、数据表定义

constintDefaultSize=100;

templateclassdatalist;　　//数据表的前视声明

templateclassElement//数据表元素类的定义

private:

　　Typekey;//关键码

　　fieldotherdata;//其它数据成员

public:

　　TypegetKey（）{returnkey;}//取当前结点的关键码

　　voidsetKey（constTypex）{key=x;}//将当前结点的关键参政修改为x

}

templateclassdatalist{

//用顺序表来存储待排序的元素，这些元素的类型是Type

public:

　　datalist（intMaxSz=DefaultSize）:

MaxSize（Maxsz）,CurrentSize（0）

　　　　　{Vector=newElement[MaxSz];}

private:

　　Element*Vector;//存储待排序的元素的向量

　　intMaxSize,CurrentSize;//最大元素个数与当前元素个数

}

（2）、计数排序的算法（４分）

template

voidcountsort（datalist&initList,datalist&resultList）{

　　inti,j,c:

Typerefer;

　　for（i=0;i

　　c=0;

　　refer:

=initList.Vector[i].getKey（）;

　　for（j=0;j

　　　　if（initList.Vector[j].getKey（）

　　　　resultList.Vector[0]=initList.Vector[i];

　　}

　　resultList.CurrentSize=initList.CurrentSize;

}

[解答2]

template

voidcountsort&initList.datalist&resultList）{

　　int*c=newint[initList.CurrentSize];

　　for（inti=0;i

　　for（i=0;i

　　　　for（intj=i+1;j

　　　　　　if（initList.Vector[j].getKey（）

　　　　　　c[i]++;

　　　　　　elsec[j]++;

　　for（i=0）;i

　　　　resultList.Vector[c[i]]=initList.Vector[i];

　　resultList.CurrentSize=initList.CurrentSize;

}

（3）、对于n个记录的表。

（2分）

[解答1]关键码比较次数为

[解答2]关键码比较次数n（n-1）/2

四、其它

1、答案：

计算二叉树的叶结点的个数。

2、

（1）、

　①top++

　②t=t→leftChild

　③i<=top

　④t=ST[top].ptr→rightChild

搜索值为10的结点

④

0

②

0

①

0

→

⑨

0

⑦

0

④

1

②

0

①

0

→

⑨

1

⑦

0

④

1

②

0

①

0

⑦

1

④

1

②

0

①

0

②

1

①

0

⑤

0

③

0

①

1

→

→

→

ptrtag　ptr　tag　ptrtag　　ptrtag　　ptrtag　ptrtag

⑧

0

⑤

1

③

0

①

1

⑧

1

⑤

1

③

0

①

1

⑥

0

③

1

①

1

⑥

0

③

1

①

1

→

→

→

ptrtag　ptrtag　ptrtag　　ptrtag　ptrtag　　

搜索值为9的结点

④

0

②

0

①

0

⑦

0

④

1

②

0

①

0

→

→

　ptrtag　　ptrtag

数据结构试题2

一、单选题判断下列各小题叙述的正误。

对，在题号前的括号内填入“√”；错，在题号前的括号内填入“×”。

（每小题3分，共24分）

（）

（1）有n个结点的不同的二叉树有n！

棵。

（）

（2）直接选择排序是一种不稳定的排序方法。

（）（3）在2048个互不相同的关键码中选择最小的5个关键码，用堆排序比用锦标赛排序更快。

（）（4）当3阶B_树中有255个关键码时，其最大高度（包括失败结点层）不超过8.

（）（5）一棵3阶B_树是平衡是平衡的3路搜索树，反之，一棵平衡的3路搜索树是3阶B_树。

（）（6）在用散列表存储关键码集合时，可以用双散列法寻找下一个空桶。

在设计再散列函数时，要求计算出的值与表的大小m互质。

（）（7）在只有度为0和度为k的结点的k叉树中，设度为0的结点有n0个，度为K的结点有nk个，则有n0=nk+1.

（）（8）折半搜索只适用于有序表，包括有序的顺序表和有序的链表。

二、阅读理解题：

说明下面递归过程的功能（10分）

intunknown（BinTreNode*t）{

//指针t是二叉树的根指针。

　　if（t==NULL）return-1;

　　elseif（unknown（t→leftChild）>=unknown（t→rightChild））

　　　　　return1+unknown（t→leftChild）;

　　　elsereturn1+unknown（t→rightChild）;

三、简答题（每小题12分，共36分）

1.设已有12个不等长的初始归并段，各归并段的长度（包括记录数）分别为RUN1（25），RUN1（12），RUN1（04），RUN1（55），RUN1（30），RUN1（47），RUN1（19），RUN1（80），RUN1（76），RUN1（92），RUN1（55），RUN1（89）若采用的是4路平衡归并排序，试画出其最佳归并树，并计算每趟归并时的读记录数。

（括号内即为该归并段包含的记录数）

2.设散列表的长度m=13;散列函数为H（K）=Kmodm,给定的关键码序列为19，14，23，01，68，20，84，27，55，11，试画出用线性探查法解决冲突时所构造的散列表。

并求出在等概率的情况下，这种方法的搜索成功时的平均搜索长度和搜索不成功时的平均搜索长度。

0

1

2

3

4

5

6

7

8

9

10

11

12

搜索成功时的平均搜索长度：

ASLsucc=

搜索不成功时的平均搜索长度：

ASLsucc=

3.画出在一个初始为空的AVL树中依次插入3，1，4，6，9，8，5，7时每一步插入后AVL树的形态。

若做了某种旋转，说明旋转的类型。

然后，给出在这棵插入后得到的AVL树中删去根结点后的结果。

四、（10分）

已知一级元素为（46，25，78，62，12，37，70，29），试画出按元素排列次序插入生成的一棵二叉树。

五、综合算法题（10分）

设有一个表头指针为first的单链表。

试设计一个算法，通过遍历一趟链表，将链表中所有结点按逆序链接。

六、程序填空题

下面给出的算法是建立AOV网络并对其进行拓扑排序的算法，其中有多个语句缺失。

ViodGraph:

:

TopologicalSort（）{

　Edge*p,q;inti,j,k;

　for（i=0;i

　　　NodeTable[i].adj=NULL;

　　　①___________________;

　}

　cin>>j>>k;//输入有向边

　while（j&&k）{

　　　p=newEdge（k）;//建立边结点，dest域赋为k

　　　p→link=NodeTable[j].adj;//链入顶点j的边链表的前端

　　　②__________________;

　　　count[k]++;//顶点k入度加一

　　　cin>>j>>k;

　　　}

　　　inttop=-1;

　　　for（i=0;i

　　　　　if（count[i]=0）{

　　　　　　　count[i]=top;

　　　　　　　③_____________;

　　　　　　｝

　　　for（i=0;i

　　　　　if（top=-1）

　　　　　　　{cout<<"Networkhasacycle"<

　　　　　else{

　　　　　　　　j=top;④________________;

　　　　　　　　cout<

　　　　　　　　q=NodeTable[j].adj;

　　　　　　　　while（q）{

　　　　　　　　　k=q→dest;

　　　　　　　　　if（--count[k]==0）

　　　　　　　　　　　cout[k]=top;

　　　　　　　　　　　top=k;

　　　　　　　　　}

　　　　　　　　　⑤_______________;

　　　　　　　　｝

　　　　　　｝

｝

⑴请将缺失的语句补上：

（5分）

⑵　请给出对于右面AOV网络，使用上述算法进行拓扑排序的结果，以及在count数据中建立的链式栈的变化。

（top是栈顶指针）（5分）

top→

A

B

C

D

E

F

　　　初始

数据结构试题2答案

一、×√√√×√××

二、求二叉树的高度

三、

1、构造4路归并树的过程

m=4:

构造4佳归并树

n=12：

共有12个初始归并段

（n-1）/（m-1）=（12-1）/（4-1）=3所以有3个度为4的内结点

u=（12-1）mod（4-1）=2≠0所以需要加内结点

m-u-1=4-2-1=1所以需增加一个内结点

第一趟读记录数据=（4+13+19）*1=36条

第二趟读记录数=（04+13+19）*2+（25+30+47）*1=174条

第三趟读记录数=（04+13+19）*3+（25+30+47）*2+（55+55+76）*1=498条

第四趟读记录数=（04+13+19）*4+（25+30+47）*3+（55+55+76）*2+（80+89+92）=1083条

2、H（19）=19mod13=6　　　　　H1

（2）=（1+1）mod13=2　冲突

H（14）=14mod13=1　　　　　　H2

（2）=（2+1）mod13=3　冲突

H（23）=23mod13=10　　　　　　H3

（2）=（3+1）mod13=4

H（01）=01mod13=1冲突　　　　H（55）=55mod13=3　冲突

H1（01）=（1+1）mod13=2　　　　H1（55）=（3+1）mod13=4　冲突

H（68）=68mod13=3　　　　　　H2（55）=（4+1）mod13=5

H（20）=20mod13=7　　　　　　H（11）=11mod13=11

H（84）=84mod13=6　　冲突

H1（84）=（6+1）mod13=7　冲突

H1（84）=（7+1）mod13=8　

H（27）=27mod13=1　冲突

0

1

2

3

4

5

6

7

8

9

10

11

12

14

01

18

27

55

19

20

84

23

11

搜索成功时的平均搜索长度：

ASLsucc=（1+1+1+2+1+1+3+4+3+1）/10=0.8

搜索不成功时的平均搜索长度：

ASLsucc=（1+9+8+7+6+5+4+3+2+1+3+2+1）/13=4

3、答案

（1）

（2）

（3）（4）（5）

（6）　（7）　（8）

（9）

四、答案

五、

voidinverse（ListNode*first）

{　if（first==NULL）retur