数据结构单元9Word文件下载.docx
《数据结构单元9Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构单元9Word文件下载.docx（19页珍藏版）》请在冰豆网上搜索。
A．集合B．图C．树D．文件
（2）顺序查找法适合于存储结构为（B）的线性表。
A．散列存储B．顺序存储或链接存储
C．压缩存储D．索引存储
（3）在表长为ｎ的链表中进行线性查找，它的平均查找长度为（B）。
Ａ.ASL＝ｎ;
Ｂ.ASL＝（n+1）/２;
Ｃ.ASL＝
＋１;
Ｄ.ASL≈log2ｎ
（4）对线性表进行二分查找时，要求线性表必须（D）。
A．以顺序方式存储B．以链接方式存储，且结点按关键字有序排序
C．以链接方式存储D．以顺序方式存储，且结点按关键字有序排序
（5）衡量查找算法效率的主要标准是（B）。
A．元素个数B.平均查找长度C．所需的存储量D．算法难易程度
（6）如果要求一个线性表既能较快地查找，又能适应动态变化的要求，可以采用（A）查找方法。
A．分块B．顺序C．二分D．散列
（7）链表适用于（A）查找。
A．顺序B．二分C．随机D．顺序或二分
（8）一个有序表为{1，3，9，12，32，41，45，62，75，77，82，95，100}，当二分查找值为82的结点时，（C）次比较后查找成功。
A．2B．3C．4D．5
（9）二分查找有序表{4，6，10，12，20，30，50，70，88，100},若查找表中元素58，则它将依次与表中（B）比较大小，查找结果是失败。
A．30，88，70，50B．20，70，30，50C．20，50D．30，88，50
（10）对有14个元素的有序表A[1..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]
（11）有一个长度为12的有序表，按二分查找法对其进行查找，在表内各元素等概率情况下查找成功所需的平均比较次数为（B）。
A．35／12B．37／12C．39／12D．43／12
（12）采用分块查找时，若线性表共有625个元素，查找每个元素的概率相等，假设采用顺序查找来确定结点所在的块时，每块分（C）个结点最佳。
A．6B．10C．25D．625
（13）下列（C）不是利用查找表中数据元素的关系进行查找的方法。
A．平衡二叉树B．有序表的查找
C.散列查找D．二叉排序树的查找
（14）设哈希表长m=14，哈希函数H（key）=key％11。
表中已有4个结点：
addr（15）=4
addr（38）=5
addr（61）=6
addr（84）=7
其余地址为空。
如用二次探测再散列处理冲突，关键字为49的结点的地址是（D）。
A．8B．3C．5D．9
（15）对包含n个元素的散列表进行查找，平均查找长度为（D）。
A．O（n2）B．O（log2n）C.O（n）D．不直接依赖于n
（16）冲突指的是（C）。
A．两个元素具有相同序号B.两个元素的键值不同
C．不同键值对应相同的存储地址D．两个元素的键值相同
（17）在查找过程中，不做增加、删除或修改的查找称为（A）。
A．静态查找B.内创造C．动态查找D．外查找
（18）已知8个元素为{34，76，45，18，26，54，92，65}，按照依次插入结点的方法生成一棵二叉树，最后两层上结点的总数为（B）。
A．1B．2C.3D．4
（19）不可能生成下图二叉排序树的关键字的序列是（A）。
A．45312B．42531C．45213D．42315
（20）动态查找包括（B）查找。
A．顺序表B.二叉排序树
C．有序表D．索引顺序表
四．应用题
1．对于给定结点的关键字集合K={5，7，3，1，9，6，4，8，2，10}，
（1）试构造一棵二叉排序树；
（2）求等概率情况下的平均查找长度ASL。
解：
（1）构造二叉排序树：
（2）ASL=（1*1+2*2+3*4+4*3）/10=2.9
2．对于给定结点的关键字集合K={10，18，3，5，19，2，4，9，7，15}，
（2）ASL=（1*1+2*2+3*4+4*2+5*1）/10=3
3．将数据序列：
25，73，62，191，325，138，依次插入下图所示的二叉排序树，并画出最后结果。
4．对于给定结点的关键字集合K={1，12，5，8，3，10，7，13，9}，
（2）在二叉树排序BT中删除“12”后的树结构：
或
5．对于给定结点的关键字集合K={34，76，45，18，26，54，92，38}，
（1）构造二叉排序树
（2）ASL=（1*1+2*2+3*3+4*2）/8=2.75（或=11/4）
6．对于给定结点的关键字集合K={4，8，2，9，1，3，6，7，5}，
（2）ASL=（1*1+2*2+3*4+4*2）/9=2.78（或=25/9）
7．画出对长度为10的有序表进行折半查找的判定树，并求其等概率时查找成功的平均查找长度。
长度为10的判定树：
-------------------------------1次能找到
------------------------2次能找到
------------------3次能找到
-------------4次能找到
ASL=1/10（1*1+2*2+3*4+4*3）=2.9
8．二叉排序树如图所示，分别画出：
（1）画出删除关键字15以后的二叉树，并要求其平均查找长度尽可能小；
（2）在原二叉排序树（即没有删除15）上，插入关键字20。
（1）
（2）
9．给定结点的关键字序列为：
19，14，23，1，68，20，84，27，55，11，10，79。
设散列表的长度为13，散列函数为：
H（K）=K%13。
试画出线性探测再散列解决冲突时所构造的散列表，并求出其平均查找长度。
（1）线性探测再散列解决冲突时所构造的散列表：
1
2
3
4
5
6
7
8
9
10
11
12
14
68
27
55
19
20
84
79
23
①②①④③①①③⑨①①③
（2）平均查找长度ASL=（1*6+2*1+3*3+4*1+9*1）/12=30/3=3
10．给定结点的关键字序列为：
47，7，29，11，16，92，22，8，3，哈希表的长度为11。
设散列函数为：
H（K）=K%11。
试画出平方探测再散列解决冲突时所构造的散列表，并求出其平均查找长度。
（1）平方探测再散列解决冲突时所构造的散列表。
22
47
92
16
29
①②②①①①①②②
（2）平均查找长度ASL=（1*5+2*4）/9=13/9=5/3（或1.44）
11．给定结点的关键字序列为：
试画出链地址法解决冲突时所构造的哈希表，并求出其平均查找长度。
（1）链地址法解决冲突时所构造的哈希表。
∧
（2）平均查找长度ASL=（1*6+2*4+3*1+4*1）/12=21/12=7/4（或1.75）
12．给定结点的关键字序列为：
H（K）=K%11。
（2）平均查找长度ASL=（1*6+2*3）/9=12/9=4/3（或1.33）
五．算法设计题
1．设单链表的结点是按关键字从小到大排列的，试写出对此链表进行查找的算法。
如果查找成功，则返回指向关键字为x的结点的指针，否则返回NULL。
2．试设计一个在用开放地址法解决从突的散列表上删除一个指定结点的算法。
3．设给定的散列表存储空间为H[1-m]，每个单元可存放一个记录，H[i]的初始值为零，选取散列函数为H（R.key），其中key为记录R的关键字，解决冲突的方法为线性控测法，编写一个函数将某记录R填入到散列表H中。
1．解：
实现本题功能的算法如下，如果查找成功，则返回指向关键字为x的结点的指针，否则返回NULL。
node*sqsearch（node*head，intx）
{
node*p=head;
while（p!
=NULL）
{if（x>
p->
key）
p=p->
link;
else
if（x==p->
returnp;
else
{p=NULL;
}
}
2．解：
算法思想是：
首先计算要删除的关键字为k的记录所在的位置，将其置为空（即删除），然后利用线性探测法查找是否有与k发生冲突而存储到下一地址的记录，如果有则将记录移到原来k所在的位置，直至表中没有与k冲突的记录为止。
实现本题功能的算法如下：
voiddelete（sqlistr，intn，intk）
{inth,h0,h1;
h=k%n;
while（r[h].key!
=k）
h=（h+1）％n;
r[h]=NULL;
h0=h;
hl=（h+1）％n;
while（hl!
=h）
{
while（r[h1].key％n!
hl=（hl+1）％n;
r[h0]=r[h1];
r[h1]=NULL;
h0=h1;
h1=（hl+1）％n;
}
3．解：
本题的算法思想：
先计算地址H（R.key），如果没有冲突，则直接填入;
否则利用线性探测法求出下一地址，直到找到一个为零的地址，然后填入。
实现本题功能的函数如下：
voidinsert（recordH,intm,recordR）
{inti;
i=H（R.key）;
if（H[i]==NULL）
H[i]=R;
else
while（H[i]!
i=（i+1）%（m+1）;
H[i]=R;
模拟考试
查找应用题
1．在一棵空的二叉排序树中依次插入关键字序列为12，7，17，11，16，2，13，9，21，4，
试画出二叉排序树的草图，并回答下列问题。
（1）在二叉排序树查找9，依次和哪些关键字进行比较。
（2）求平均查找长度ASL
（1）查找过程：
12，7，11，9。
8
（2）ASL＝1/10（1×
1＋2×
2＋3×
4＋4×
3）＝29/10≈2.92
2．折半查找的的判定树如下图所示，
（1）若查找元素56，需依次与哪些元素比较？
（2）若查找元素16，需依次与哪些元素比较？
（3）假定每个元素的查找概率相等，求查找成功时的平均查找长度（保留2位小数）。
（1）查找元素56，需依次与32,65,47,56等元素比较4
（2）查找元素16，需依次与32,5，18,16等元素比较4
（3）ASL＝1/12（1×
5）＝37/12≈3.082
3．设哈希表的地址范围为0～17，哈希函数为：
H（K）＝K%16。
其中K为关键字，用线性探测法再散列法处理冲突，输入关键字序列：
（10，24，32，17，31，30，46，47，40，63，49）。
其哈希表如下：
13
15
17
32
63
49
24
40
30
31
46
试回答下列问题：
（1）若查找关键字63，需要依次与哪些关键字进行比较？
（2）假定每个关键字的查找概率相等，求查找成功时的平均查找长度。
（1）查找63，需要比较6次。
分别为：
31，46,47,32,17,63。
8
（2）ASL=1/11（1×
6＋2×
1＋3×
3＋6×
1）＝23/11=≈2.12
3．对于给定结点的关键字集合K={1，12，5，8，3，10，7，13，9}，
（2）如何依据此二叉排序树得到D的有序序列。
（1）构造二叉排序树：
（2）按中序遍历二叉排序树可以得到D的有序序列。
4．对于给定结点的关键字集合K={15，9，20，12，17，4，18，10，29，6}，构成一棵二叉排序树，并写出该二叉排序树中序遍历的结点序列。
（1）构造二叉排序树
（2）中序遍历的结点序列：
4，6，9，10，12，15，17，18，20，29。
5．给定结点的关键字序列为：
①②①①①④①②②
（2）平均查找长度ASL=（1*5+2*3+4*1）/9=15/9=5/3（或1.67）
6．给定结点的关键字序列为：
87，25，11，8，27，28，68，95，70，6，83，63，47，已知设散列函数为：
∧
28
95
70
83
87
25
（2）平均查找长度ASL=（1*10+2*3）/13=16/13（或1.23）
查找程序填空
1．从键盘输入若干个整数，以回车为间隔，以-1为结束符号，建立一个顺序存储的线性表，然后按提示输入一个待查找的数进行查找。
若找到，则显示找到的数据在线性表中的位置；
否则显示“找不到”，试填空完成下列程序。
voidSeqSearch（）
{inta[n],i,x,y;
cout<
<
"
建立整数的顺序表（以回车为间隔，以-1结束）：
;
for（i=1;
i<
=MAXLEN;
i++）
{cin>
>
a[i];
if（a[i]==-1）
{y=i;
break;
请输入要查找的数据：
cin>
x;
i=y-1;
while（i>
=0&
&
a[i]!
=x）
i--;
（或i=i+1）
if（i==0）
cout<
"
没有找到"
;
已找到，在第"
i<
个位置上"
2．对有序表R[0]至R[n-1]进行二分查找，查找成功时返回记录在表中的位置；
查找失败时显示：
“没有找到！
”，试编写此程序。
voidBinSearch（）
{intR[MAXLEN],i,low,high,mid,n,x;
charch;
cout<
请输入要查找的数据:
cin>
x;
low=0;
high=n-1;
while（low<
=high）
{mid=（low+high）/2;
if（R[mid]>
x）
high=mid-1;
else
if（R[mid]<
x）
low=mid+1;
else
break;
}
if（low>
high）
{cout<
没有找到！
if（R[mid]<
mid++;
cout<
可将此数插入到"
<
mid+1<
的位置上。
else
要找的数据"
x<
在第"
的位置上"
升级会员 