PTA数据结构与算法-第八章——检索

---

第一章——褚论

第二章——线性表

第三章——栈与队列

第四章——字符串

第五章——树与二叉树

第六章——图

第七章——排序

第八章——检索

---

判断题

1-1
把数组中元素按某种顺序排列的过程叫做查找 。
F

---

1-2
将N个数据按照从小到大顺序组织存放在一个单向链表中。如果采用二分查找，那么查找的平均时间复杂度是O(logN)。
F
解析：
二分查找是不可以用链表存储的

这是由链表的特性决定的。链表是很典型的顺序存取结构，
数据在链表中的位置只能通过从头到尾的顺序检索得到，即使是有序的，要操作其中的某个数据也必须从头开始。
这和数组有本质的不同。数组中的元素是通过下标来确定的，只要你知道了下标，就可以直接存储整个元素，
比如a[5],是直接的。链表没有这个，所以，折半查找只能在数组上进行。

---

1-3
在一棵二叉搜索树上查找63，序列39、101、25、80、70、59、63是一种可能的查找时的结点值比较序列。
F
解析：根结点39，63大，往右子树找，但是右子树中有25比39小，二叉搜索树右子树的结点一定比根结点大，所以错

---

1-4
二叉搜索树的查找和折半查找的时间复杂度相同。
F
只有平衡的二叉搜索树才与折半查找时间复杂度相同
1-8
(neuDS)由顺序表和单链表表示的有序表均可使用二分查找法来提高查找速度。
F
二分查找法不用单链表

---

1-6
在散列表中，所谓同义词就是具有相同散列地址的两个元素。
T

---

1-5
在散列中，函数“插入”和“查找”具有同样的时间复杂度。
T

---

1-7
即使把2个元素散列到有100个单元的表中，仍然有可能发生冲突。
T

---

1-9
在散列表中，所谓同义词就是被不同散列函数映射到同一地址的两个元素。
F

---

单选题

2-1
已知一个长度为16的顺序表L，其元素按关键字有序排列。若采用二分查找法查找一个L中不存在的元素，则关键字的比较次数最多是：

4
5
6
7
解析：
==二分查找的最大比较次数是 ==

即[log(N)](向下取整）+1=4+1=5

---

2-2
用二分查找从100个有序整数中查找某数，最坏情况下需要比较的次数是：

7
10
50
99
解析：代入上列公式：
[log(100)] (向下取整)+1=6+1=7

---

2-13
若在线性表中采用二分查找法查找元素，该线性表应该（）。

元素按值有序
采用顺序存储结构
元素按值有序，且采用顺序存储结构
元素按值有序，且采用链式存储结构

---

2-12
设有一个已排序的线性表（长度>=２），分别用顺序查找法和二分查找法找一个与K相等的元素，比较的次数分别是S和B，在查找不成功的情况下，S和B的关系是（）。

S=B
S< B
S>B
S>=B

---

2-17
在有n（n>1000）个元素的升序数组A中查找关键字x。查找算法的伪代码如下所示：

k = 0;
while ( k<n 且 A[k]<x )  k = k+3;
if ( k<n 且 A[k]==x )  查找成功;
else if ( k-1<n 且 A[k-1]==x ) 查找成功;
     else if ( k-2<n 且 A[k-2]==x ) 查找成功;
          else 查找失败;

本算法与二分查找（折半查找）算法相比，有可能具有更少比较次数的情形是：

当x不在数组中
当x接近数组开头处
当x接近数组结尾处
当x位于数组中间位置

---

2-4
在散列表中，所谓同义词就是：

两个意义相近的单词
具有相同散列地址的两个元素
被映射到不同散列地址的一个元素
被不同散列函数映射到同一地址的两个元素

---

2-5
在下列查找的方法中，平均查找长度与结点个数无关的查找方法是：

顺序查找
二分法
利用哈希（散列）表
利用二叉搜索树
2-6
设散列表的地址区间为[0,16]，散列函数为H(Key)=Key%17。采用线性探测法处理冲突，并将关键字序列{ 26，25，72，38，8，18，59 }依次存储到散列表中。元素59存放在散列表中的地址是：

8
9
10
11

---

2-7
将元素序列{18，23，11，20，2，7，27，33，42，15}按顺序插入一个初始为空的、大小为11的散列表中。散列函数为：H(Key)=Key%11，采用线性探测法处理冲突。问：当第一次发现有冲突时，散列表的装填因子大约是多少？

0.27
0.45
0.64
0.73

解析：
18%11=7；
23%11=1；
11%11=0;
20%11=9;
2%11=2;
7%11=7(第一次发现冲突是第六个数字)
装填因子=5/11=0.45；

---

2-9
给定散列表大小为11，散列函数为H(Key)=Key%11。采用平方探测法处理冲突：
h​i(k)=(H(k)±i​²​​ )%11将关键字序列{ 6，25，39，61 }依次插入到散列表中。那么元素61存放在散列表中的位置是：

5
6
7
8
解析：
6%11=6
25%11=3
39%11=6+1=7
61%11=6-1=5

---

2-10
给定散列表大小为11，散列函数为H(Key)=Key%11。按照线性探测冲突解决策略连续插入散列值相同的4个元素。问：此时该散列表的平均不成功查找次数是多少？

1
4/11
21/11
不确定
分析：
区别概念平均成功查找次数和平均不成功查找次数。
平均成功查找次数=每个关键词比较次数之和÷关键词的个数
平均不成功查找次数=每个位置不成功时的比较次数之和÷表长（所谓每个位置不成功时的比较次数就是在除余位置内，每个位置到第一个为空的比较次数，比如此题表长为11，散列函数为Key%11，除余的是11，那么除余位置就是0—10；如果表长为15，但散列函数为Key%13，那么除余位置就是0—12）
明确概念后做题：

连续插入散列值相同的4个元素，我们就假设它的散列值都为0，那么插入后的位置：
在这里插入图片描述
其中位置0到第一个为空的位置4的比较次数为5，其余的位置以此类推。
平均不成功查找次数=（5+4+3+2+1+1+1+1+1+1+1）÷ 11 = 21/11

---

2-14
现有长度为 7、初始为空的散列表HT，散列函数H(k)=k%7，用线性探测再散列法解决冲突。将关键字 22, 43, 15 依次插入到HT后，查找成功的平均查找长度是：

1.5
1.6
2
3
解析：
22%7=1
43%7=1+1=2
15%7=1+1+1=3
平均成功查找次数=每个关键词比较次数之和÷关键词的个数=（1+2+3）/3=2

---

2-15
将10个元素散列到100000个单元的哈希表中，是否一定产生冲突？

一定会
可能会
一定不会
有万分之一的可能会

---

2-16
采用线性探测法解决冲突时所产生的一系列后继散列地址：

必须大于等于原散列地址
必须小于等于原散列地址
可以大于或小于但不等于原散列地址
对地址在何处没有限制

---

程序填空题

5-2
本题要求实现折半查找的递归查找操作。 例如对于下图的有序表：

输入样例：
2
21 70
输出样例：
21 is found
70 is not found
程序如下：

#include <stdio.h>
#include <stdlib.h>
typedef int KeyType;
typedef struct {
          KeyType   *data; /*表基址*/
          int     length;      /*表长*/
}SSTable;
void  CreatSSTable(SSTable *ST);/*有序表创建，由裁判实现，细节不表*/
int  BiSearch(SSTable ST,KeyType e,int low,int high);
int main()
{
   SSTable  ST;
   int n,result,i;
   KeyType e;
   CreatSSTable(&ST);
   scanf("%d",&n);
   for( i=0;i<n;i++)
   {
	scanf("%d",&e);
	result = BiSearch(ST,e,1,ST.length);
	if(result) printf("%d is found\n",e);
	else printf("%d is not found\n",e);
	}
	return 0;
}
int  BiSearch(SSTable ST,KeyType e,int low,int high)
{
   int mid;
   if(
low>high
) return 0;
   mid=(low+high)/2;
   if(ST.data[mid]==e) return  mid;
   if(e<ST.data[mid]) return 
BiSearch(ST,e, low,mid-1)
;
   else 
return  BiSearch(ST,e, mid+1,high)
;
}

low>high
BiSearch(ST,e,low,mid-1)
return BiSearch(ST,e,mid+1,high)

---

5-1
下列代码的功能是利用散列函数hash将一个元素插入到散列表ht[]中。其中list类型的结点包含element类型的项item、以及一个next指针。如果插入成功，则函数返回1，否则返回0。

int insert( struct element item, list_pointer ht[] )
{
   int ret, hash_value;
   list_pointer ptr, trail, lead;

   ret = 1;
   hash_value = hash(item.key);
   trail = NULL; lead = ht[hash_value];
   for ( ; lead; trail = lead, lead = lead->next) {
      if (!strcmp(lead->item.key, item.key)) {
         printf("The key is in the table\n");
         ret = 0;
      }
   }
   if (ret) {
      ptr = (list_pointer)malloc(sizeof(struct list));
      
ptr->item = item
;
      ptr->next = NULL;
      if (trail)
         
trail->next = ptr
;
      else
         
ht[hash_value] = ptr
;
   }
   return ret;
}

ptr->item=item
trail->next=ptr
ht[hash_value]=ptr