数据结构.第9章.查找.1.静态查找表
§9.1 查找的基本概念
查找表的分类
静态查找表
仅作“查询”（检索）操作的查找表， 只查找，不改变数据元素集内的数据元素。 动态查找表： 作“插入”和“删除”操作的查找表 既查找，又改变(增减)集合内的数据元素。
§9.1 查找的基本概念
关键字
在实际应用问题中，每个记录一般包含有多 个数据域，查找是根据其中某一个指定的域进行 的，这个作为查找依据的域称关键字(key)。 主关键字 可唯一标识一个记录的关键字。例：学号 次关键字 可识别若干记录的关键字。例：性别
＝
§6.2 二叉树
二叉树的性质
讨论2：深度为k的二叉树，至多有多少个结点？2k-1个 （等比级数前k项和的公式） 1
2 4 8 9 10 5 11 12 6 13 14 3 7 15
性质2: 深度为k的二叉树至多有2k-1个结点（k>=1）
§6.2 二叉树
二叉树的性质
性质4：具有n个结点的完全二叉树的高度为
查找不成功： 比较次数 ≤ log2n +1
8 14
46 68
23 37
55
79 91
§9.2 静态查找表
算法性能分析
1 8 2 14 3 23 4 37 5 46 46 6 55 7 68 8 79 9 91
查找不成功：
14
8 23
68
55
79
37
91
§9.2 静态查找表
算法性能分析
若在树的高度为k的满二叉树n=2k-1中，树的第i层有2i-1 个结点，树的第 i 层结点的全部查询次数为 i*2i-1 ，在等概率 的情况下，Pi=1/n，因此，折半查找的平均查找长度为
0 60 1 5 2 37 3 19 4 21 5 13 6 56 7 64 8 92 9 88 10 80 11 75
§9.2 静态查找表
顺序查找的算法分析
对于n个数据元素的表，若给定值key与表中第i个元素
的关键字相等，则需要n-i+1次关键字比较，即Ci=n-i+1。
例如，当第n个元素的关键字为key时，需要进行1次 比较(n-n+1=1)，又如，当第一个元素为所求时，需要进 行n次比较(n-1+1=n)。因此，查找成功时，顺序查找的平 Pi每个元素的查 均查找长度为 n 找概率，假设所 ASL Ci Pi 有元素的查找概 i 1 率均相等。P 1
55
68
79
91
low
mid
high
low = 1 mid < > key mid = (low+high)/2 high = n mid = (low+high)/2 low = mid +1 high = mid-1 mid = (low+high)/2
§9.2 静态查找表
有序表的查找
例:查找79
0 60 1 5 2 37 3 19 4 21 5 13 6 56 7 64 8 92 9 88
找60
10 80 11 75
§9.2 静态查找表
顺序查找的算法
int Search_seq(SSTable ST[ ], int n, int key) { ST[0].key=key; 监视哨作用：避免每步都去判断是否查找结束 int i=n; while(ST[i].key!=key) i--; return i; 找60 } 监视哨
§9.2 静态查找表
算法性能分析
为了分析二分查找的性能，可以用二叉树来 描述二分查找过程。把当前查找区间的中点作为 根结点，左子区间和右子区间分别作为根的左子
树和右子树，左子区间和右子区间再按类似的方
法，由此得到的二叉树称为二分查找的判定树。
§9.2 静态查找表
算法性能分析
1 8 2 14 3 23 4 37 5 46 6 55 7 68 8 79 9 91
查找过程：
0 1 5 2 37 3 19 4 21 5 13 6 56 7ห้องสมุดไป่ตู้64
找64
8 92
9 88
10 80
11 75
§9.2 静态查找表
顺序查找的算法
int Search_seq(SSTable ST[ ], int n, int key) { ST[0].key=key; int i=n; while(ST[i].key!=key) &&(i>=0) i--; return i; } 找不到时，i为0
静态查找如何进行查找
取决于查找表的结构，如字典，电话本
§9.1 查找的基本概念
平均查找长度(Average Search Length)
为确定记录在查找表中的位置，需和给定值进行比较 的关键字个数的期望值称为查找算法在查找成功时的平均 查找长度(ASL)。 对于含有n个记录的表，查找成功时的平均查找长度为
§9.2 静态查找表
有序表的查找
折半查找
又称为二分法查找，每次将待查记录所在区间缩小一半
查找思想 先确定待查找记录所在的范围，然后逐步缩小范围，直 到找到或确认找不到该记录为止 前提条件
必须在具有顺序存储结构的有序表中进行
§9.2 静态查找表
有序表的查找
例:查找23
8 14
key
23
37
46
ASL Ci Pi
i 1
n
找表中关键字与给定值相等 的第i个记录时，和给定值 已进行过比较的关键字个数
查找表中第i个 记录的概率， n 且 P 1
i 1
i
§9.2 静态查找表
静态查找表
顺序表的查找 有序表的查找 索引顺序表的查找
§9.2 静态查找表
顺序表的查找
顺序查找：从表的一端开始，逐个进行记录的关键 字和给定值的比较。
§9.2 静态查找表
折半查找的算法
int Search_Bin( SSTable ST[ ], int n, int key) { int low, high,mid; low=1; high=n; while(low<=high) { mid=(low+high)/2; if (ST[mid].key == key) return mid; else if ( key< ST[mid].key) high=mid-1; else low=mid+1; } return 0; }
1 n 1 i 1 0 1 ASL PC i 2 (1 2 2 2 i i n i 1 n i 1 n 1 log 2 (n 1) 1 log 2 n n
n
k 2k 1 )
§9.2 静态查找表
算法性能分析
1 8 2 14 3 23 4 37 5 46 6 55 7 68 8 79 9 91
└ log2n ┘ +
1
证明： 设完全二叉树的高度为k，则有 (2k-1 -1 ) < n ≤ (2k -1)
或 2k-1 ≤ n < 2k
两边取对数 k-1 ≤ log2n < k
因为k是整数，所以k = └ log2n ┘ + 1
§9.2 静态查找表
算法性能分析
1 8 2 14 3 23 4 37 5 46 6 55 7 68 8 79 9 91
第9 章
查找
查找的基本概念 静态查找表
动态查找表 哈希表
§9.1 查找的基本概念
查找的基本概念
查找表：是由同一类型的具有相同可辨认特性的 数据元素（或记录）构成的集合。 对查找表经常进行的操作： 1. 查询某个“特定的”数据元素是否在查找表中； 2. 查询某个“特定的”数据元素的各种属性； 3. 在查找表中插入一个数据元素； 4. 删除查找表中的某个数据元素。
0 1 5 2 37 3 19 4 21 5 13 6 56 7 64 8 92 9 88
找60
10 80 11 75
§9.2 静态查找表
顺序查找的算法
int Search_seq(SSTable ST[ ], int n, int key) { ST[0].key=key; int i=n; while(ST[i].key!=key) &&(i>=0) i--; return i; }
i
n
§9.2 静态查找表
顺序查找的算法分析
对于n个数据元素的表，若给定值key与表中第i个元素
的关键字相等，则需要n-i+1次关键字比较，即Ci=n-i+1。
例如，当第n个元素的关键字为key时，需要进行1次 比较(n-n+1=1)，又如，当第一个元素为所求时，需要进 行n次比较(n-1+1=n)。因此，查找成功时，顺序查找的平 均查找长度为
1 2 n n 1 ASL Pi (n i 1) n 2 i 1
n
§9.2 静态查找表
顺序查找的算法分析
若查找失败，则算法一直遍历到Elem[0]，总共比较
n+1次。
0 60 1 5 2 37 3 19 4 21 5 13 6 56 7 64 8 92 9 88 10 80 11 75
1 ASL (1 20 2 21 n
k2
k 1
1 25 ) (1 1 2 2 3 4 4 2) 9 9
§9.2 静态查找表
算法性能分析
折半查找的效率相当高，在最坏的情况下(即查找失
败时)的关键字比较次数也不超过判定树的深度，而且折
半查找的最坏性能与平均性能相当接近。 但折半查找只能用于有序表中，而排序本身是一件 很费时的事情。折半查找还要求对数据元素随机访问， 因此只能用顺序存储的线性表中，因此适用于查找频繁， 但是有序表元素改动少的应用中。
合集下载
数据结构教程 第5版 第9章-查找
4/51
4、影响查找的因素
采用何种查找方法? 使用哪种数据结构来表示“表”，即表中记录是按何种方式组织的？ 表中关键字的次序。是对无序集合查找还是对有序集合查找？
5/51
5. 查找方法的性能指标
查找运算时间主要花费在关键字比较上，通常把查找过程中执行的关键字平均 比较个数（称为平均查找长度）作为衡量一个查找算法效率优劣的标准。
int BinSearch(RecType R[],int n,KeyType k)
{
int low=0,high=n-1,mid;
while (low<=high)
//当前区间存在元素时循环
{ mid=(low+high)/2;
if (R[mid].key==k) //查找成功返回其逻辑序号mid+1
1
1
4
2
3
3
2
姓名 张三 李四 王五 刘六
存储
姓名 张三 李四 王五 刘六
学 生 表
学号 1 4 3 2
地址 0 1 2 3
索引表
学号 1 2 3 4
地址 0 3 2 1
提取
排序
38/51
存储地址
0 1 2 3
主数据表
学号 1 4 3 2
姓名 张三 李四 王五 刘六
索引表
学号 1 2 3 4
地址 0 3 2 1
36/51
9.2.3 索引存储结构和分块查找 1、索引存储结构
索引存储结构 = 主数据表 + 索引表
索引表中的每一项称为索引项，索引项的一般形式是： （关键字，地址）
关键字唯一标识一个记录，地址作为指向该关键字对应记录的指针，也可以 是相对地址。
4、影响查找的因素
采用何种查找方法? 使用哪种数据结构来表示“表”，即表中记录是按何种方式组织的？ 表中关键字的次序。是对无序集合查找还是对有序集合查找？
5/51
5. 查找方法的性能指标
查找运算时间主要花费在关键字比较上，通常把查找过程中执行的关键字平均 比较个数（称为平均查找长度）作为衡量一个查找算法效率优劣的标准。
int BinSearch(RecType R[],int n,KeyType k)
{
int low=0,high=n-1,mid;
while (low<=high)
//当前区间存在元素时循环
{ mid=(low+high)/2;
if (R[mid].key==k) //查找成功返回其逻辑序号mid+1
1
1
4
2
3
3
2
姓名 张三 李四 王五 刘六
存储
姓名 张三 李四 王五 刘六
学 生 表
学号 1 4 3 2
地址 0 1 2 3
索引表
学号 1 2 3 4
地址 0 3 2 1
提取
排序
38/51
存储地址
0 1 2 3
主数据表
学号 1 4 3 2
姓名 张三 李四 王五 刘六
索引表
学号 1 2 3 4
地址 0 3 2 1
36/51
9.2.3 索引存储结构和分块查找 1、索引存储结构
索引存储结构 = 主数据表 + 索引表
索引表中的每一项称为索引项，索引项的一般形式是： （关键字，地址）
关键字唯一标识一个记录，地址作为指向该关键字对应记录的指针，也可以 是相对地址。
数据结构教案第9章 查找
●性能分析 定义：为了确定记录在查找表中的位置，需和给定值进行比 较的关键字个数的期望值称为查找算法在查找成功时的平均查找 长度。
ASL = ∑ Pi C i
i =1
n
其中：Pi为查找表中第i个记录的概率；Ci为找到第i个记 录的比较次数； 查找成功的平均查找长度：
1 n n +1 ASL = ∑ (n − i + 1) = 2 n i =1
索引表 最大关键字 起始地址
22 48 86 1 7 13
22 12 13 8 9 20 33 42 44 38 24 48 60 58 74 49 86 53
9．2动态查找表 特点：表结构本身是在查找过程中动态生 成的，即对于给定值key，若表中存在其关键 字等于key的记录，则查找成功返回；否则插 入关键字等于key的记录。
10 10 9 15 9 17 17 15
a
16
作业：(P55)9.9, 9. 33
9．3哈希表 9．3．1什么是哈希表 哈希函数：在记录的关键字和它的存储位置之间建立 一个确定的对应关系f，使每个关键字和结构中一个 唯一的存储位置相对应，称对应关系f为哈希(Hash) 函数。 哈希表：按哈希函数建立的表称为哈希表。
void Delete(BiTree &p){ if(!p->rchild) { q=p; p=p->lchild; free(q); } else if(!p->lchild) { q=p; p=p->rchild; free(q); } else{ q=p; s=p->lchild; while(s->rchild) {q=s; s=s->rchild;} p->data=s->data; if(q!=p) q->rchild=s->lchild; \*q！=p正常情况 else q->lchile= s->lchild; \* q=p意外者，p的左子树的根没有右子树 free(s); }\\else }
数据结构_查找原理及典型的查找算法
无法实现！因全部元素的定位只能从头指针head开 始，是一种非随机存取结构。
3.对非线性(树)结构如何进行折半查找？ 可借助二叉排序树来查找（属动态查找表形式）。
9.1.2 有序表的查找
折半查找过程可以描述为一棵二叉树
折半查找的判定树 如：（a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11）
总之：
二叉排序树既有类似于折半查找的特性，又采用了链 表存储，它是动态查找表的一种适宜表示。
一、二叉排序树
（3）构造过程: 例：输入序列{45，12，37，3，53，100，24}
45
12
53
3
37
100
24
一、二叉排序树
（2）非递归查找过程 BiTree SearchBST(BiTree T,KeyType key){
CH9 查找
查找的基本概念 9.1 静态查找表
9.1.1 顺序查找 9.1.2 有序表的查找 9.1.3 索引顺序表的查找
9.2 动态查找表
9.2.1 二叉排序树和平衡二叉树 9.2.2 B－和B＋树
9.3 哈希表
查找的基本概念
1.查找表 2.查找
关键字 主关键字 次关键字
}
9.2.1 二叉排序树和平衡二叉树
一、二叉排序树 二、平衡二叉树
一、二叉排序树
1.定义、特点、构造过程
（1）定义 二叉排序树或者是一棵空树，或是具有下列性质的二叉树：
若左子树非空，则左子树上所有结点的值均小于它的 根结点的值。
若右子树非空，则右子树上所有结点的值均大于它的 根结点的值。
有序/无序表 有序表
顺序/链式存 储
顺序存储
分块查找 介于二者之间 表中元素逐段有序 顺序/链式存储
3.对非线性(树)结构如何进行折半查找？ 可借助二叉排序树来查找（属动态查找表形式）。
9.1.2 有序表的查找
折半查找过程可以描述为一棵二叉树
折半查找的判定树 如：（a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11）
总之：
二叉排序树既有类似于折半查找的特性，又采用了链 表存储，它是动态查找表的一种适宜表示。
一、二叉排序树
（3）构造过程: 例：输入序列{45，12，37，3，53，100，24}
45
12
53
3
37
100
24
一、二叉排序树
（2）非递归查找过程 BiTree SearchBST(BiTree T,KeyType key){
CH9 查找
查找的基本概念 9.1 静态查找表
9.1.1 顺序查找 9.1.2 有序表的查找 9.1.3 索引顺序表的查找
9.2 动态查找表
9.2.1 二叉排序树和平衡二叉树 9.2.2 B－和B＋树
9.3 哈希表
查找的基本概念
1.查找表 2.查找
关键字 主关键字 次关键字
}
9.2.1 二叉排序树和平衡二叉树
一、二叉排序树 二、平衡二叉树
一、二叉排序树
1.定义、特点、构造过程
（1）定义 二叉排序树或者是一棵空树，或是具有下列性质的二叉树：
若左子树非空，则左子树上所有结点的值均小于它的 根结点的值。
若右子树非空，则右子树上所有结点的值均大于它的 根结点的值。
有序/无序表 有序表
顺序/链式存 储
顺序存储
分块查找 介于二者之间 表中元素逐段有序 顺序/链式存储
第九章查找1静态查找表
①通常以顺序存储结构的线性表或有序表表示静态 查找表； ②数据存储空间中，0号单元留空。
9.1 静态查找表
二.顺序查找
算法： int Search_Seq(SSTable ST, KeyType key)
{
for(i=1; i<=ST.length&&ST. elem[i]. key!=key; i++) ; return i;
物理意义：假设每一元素被查找的概率相同，则查找每 一元素所需的比较次数之总和再取平均，即为ASL。显 然，ASL值越小，时间效率越高。
9.1 静态查找表
一.静态查找表的查找算法
1、顺序查找（线性查找） 2、折半查找（二分或对分查找）
3、静态树表的查找
4、分块查找（索引顺序查找）
9.1 静态查找表
ST.elem
17 0 1 8 2 21 19 31 33 22 25 42 37 40 52 61 78 73 55 94 88 79 85 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
21
1
33
5
52
9
78
13
94
17
索引表定义 typedef struct { KeyType key; int stadr; }IndexItem;//索引项 typedef struct { IndexItem *elem; int length; }IndexTable;//索引表
0 1 2 3 4 5 6 7 8 9 10 11
9.1 静态查找表
二.顺序查找
原则：
从表的最后一个记录（或第一个记录） 开始，依次将记录的关键字与给定值比较， 若相等：若找到，返回该元素在表中的位置； 否则，查找失败。 改进：设置“监视哨”
9.1 静态查找表
二.顺序查找
算法： int Search_Seq(SSTable ST, KeyType key)
{
for(i=1; i<=ST.length&&ST. elem[i]. key!=key; i++) ; return i;
物理意义：假设每一元素被查找的概率相同，则查找每 一元素所需的比较次数之总和再取平均，即为ASL。显 然，ASL值越小，时间效率越高。
9.1 静态查找表
一.静态查找表的查找算法
1、顺序查找（线性查找） 2、折半查找（二分或对分查找）
3、静态树表的查找
4、分块查找（索引顺序查找）
9.1 静态查找表
ST.elem
17 0 1 8 2 21 19 31 33 22 25 42 37 40 52 61 78 73 55 94 88 79 85 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
21
1
33
5
52
9
78
13
94
17
索引表定义 typedef struct { KeyType key; int stadr; }IndexItem;//索引项 typedef struct { IndexItem *elem; int length; }IndexTable;//索引表
0 1 2 3 4 5 6 7 8 9 10 11
9.1 静态查找表
二.顺序查找
原则：
从表的最后一个记录（或第一个记录） 开始，依次将记录的关键字与给定值比较， 若相等：若找到，返回该元素在表中的位置； 否则，查找失败。 改进：设置“监视哨”
数据结构查找
索引表
最大关键字 起始地址
22
48 7
86 13
22 12 13 8
9
20 33 42 44 38 24 48 60 58 74 49 86 53
索引顺序表的查找算法
查找关键字为k的元素，分两步进行： 1.根据给定的索引值，在索引表上查找出索引 项，确定对应子表在主表中的开始位置和长 度。 2.再根据给定的关键字，在对应子表中查找出 元素结点。 先用折半查找法由索引表查出 k 所在的块， 再用顺序查找法在对应的块中找出k。
顺序查找
int Seqsch1(ElemType A[],int n,KeyType K) { A[n].key=K; ∥设置岗哨 for(int i=0; ;i++) if(A[i].key==K) 省略了对下标越界 break; 的检查，提高算法 的执行速度 if(i<n) return i; else return -1; 时间复杂度为O(n) 速度慢 }
顺序查找表的平均查找长度
在等概率且查找成功的情况下： ASLss=∑PiCi=(1/n)∑(n-i+1)
i=1 i=1 n n
=(n+1)/2
顺序查找表的平均查找长度
顺序查找成功时最多查找n次，不成功时的 查找次数为n+1。 此时的查找概率为Pi=1/(2n)
ASLss=1/(2n)∑(n-i+1)+1/2(n+1)
9.2.1 二叉排序树和平衡二叉树
二叉排序树的定义 二叉排序树 Binary Sort Tree 二叉查找树、二叉搜索树Binary Search Tree 结点的关键字： 简单类型—结点的值 记录类型—结点的某一个域的值 以结点值域data中关键字域key作为结点 的关键字。
数据结构九章节查找
9.3 动态查找表
二叉排序树中序遍历 中序遍历二叉排序树，可得到一个关键字的有序序列,如 5,13,19,21,37,56,64,92,75,80,88
56 13
5
37
64 92
21
80
19
75
88
中国科大《数据结构》
9-25
9.3 动态查找表
二叉排序树删除 删除二叉排序树中的一个结点后，必须保持二叉排序树的特性：
顺序查找算法 1. 从表中最后一个记录开始 2. 逐个进行记录的关键字和给定值的比较 3. 若某个记录比较相等，则查找成功 4. 若直到第1个记录都比较不等，则查找不成功
9-6
中国科大《数据结构》
9.2 静态查找表
顺序查找算法描述
int Search_Seq(SSTable ST, KeyType key) { // 若查找成功，返回位置
中国科大《数据结构》
9-19
9.3 动态查找表
动态查找表 如果应用问题涉及的数据量很大，而且数据经常发生变化，如
图书馆经常购进图书，每购进新书，需将新书记录插入图书表，对 这类表除了提供前面的介绍的查找外，还要提供动态查找功能： 1. 查找某个“特定”元素是否在表中，若不在，将该元素插入； 2. 查找某个“特定”元素是否在表中，若在，从表中删除； 如何组织动态查找表？ 用静态查找方法不能满足要求了。本节介绍几种方法。
找到 21
64
92 无此数
80
19
75
88
找到
例1：在右图二叉排序树中查找关键字值等于37 例2：在右图二叉排序树中查找关键字值等于88 例3：在右图二叉排序树中查找关键字值等于94
中国科大《数据结构》
数据结构第9章 查找 4
8 75
9 80
10 88
11 92
high
2 13
3 19
4 21
5 37
6 56
7 64
8 75
9 80
10 88
11 92
若 k==r[mid] .key，查 找成功 若 k<r[mid]. key，则 high=mid1 若 k>r[mid]. key，则 low=mid+ 1
low 1 2 5 13
low mid high 6 7 8 9 56 64 75 80 low high 7 mid 8 9 64 75 80
10 88
11 92
1 5
2 13
3 19
4 21
5 37
6 56
10 88
11 92
high low
找21
1 5 low
1 5
2 13
3 19
4 21
5 37
6 56
mid
7 64
动态查找表
二叉排序树定义（Binary Sorting Tree）
它或者是一棵空树，或者是一棵具有如下特征的非空二叉树： 若 它 的 左 子 树 非 空 ， 则 左 子 树 上 所 有 结 点 的 关 键 字 均 小于根结点的关键字； 若 它 的 右 子 树 非 空 ， 则 右 子 树 上 所 有 结 点 的 关 键 字 均 大于等于根结点的关键字；
2 有序表查找(折半查找)
查找过程：每次将待查记录所在区间缩小一半 适用条件：采用顺序存储结构的有序表 算法实现
设表长为n，low、high和mid分别指向待查元素所在 区间的上界、下界和中点, k为给定值 初始时，令low=1,high=n,mid=(low+high)/2 让k与mid指向的记录比较
数据结构第九章 查找 习题及答案
第九章查找一、选择题1.若查找每个记录的概率均等，则在具有n个记录的连续顺序文件中采用顺序查找法查找一个记录，其平均查找长度ASL为( )。
A． (n-1)/2 B. n/2 C. (n+1)/2 D. n2. 下面关于二分查找的叙述正确的是 ( )A. 表必须有序，表可以顺序方式存储，也可以链表方式存储 C. 表必须有序，而且只能从小到大排列B. 表必须有序且表中数据必须是整型，实型或字符型 D. 表必须有序，且表只能以顺序方式存储3. 用二分（对半）查找表的元素的速度比用顺序法( )A．必然快 B. 必然慢 C. 相等 D. 不能确定4. 具有12个关键字的有序表，折半查找的平均查找长度（）A. 3.1B. 4C. 2.5D. 55．当采用分块查找时，数据的组织方式为 ( )A．数据分成若干块，每块内数据有序B．数据分成若干块，每块内数据不必有序，但块间必须有序，每块内最大（或最小）的数据组成索引块C. 数据分成若干块，每块内数据有序，每块内最大（或最小）的数据组成索引块D. 数据分成若干块，每块（除最后一块外）中数据个数需相同6. 二叉查找树的查找效率与二叉树的( （1）)有关, 在 (（2）)时其查找效率最低(1): A. 高度 B. 结点的多少 C. 树型 D. 结点的位置(2): A. 结点太多 B. 完全二叉树 C. 呈单枝树 D. 结点太复杂。
7. 对大小均为n的有序表和无序表分别进行顺序查找,在等概率查找的情况下,对于查找失败,它们的平均查找长度是((1)) ,对于查找成功,他们的平均查找长度是((2))供选择的答案:A. 相同的B.不同的9．分别以下列序列构造二叉排序树，与用其它三个序列所构造的结果不同的是( ) A．（100，80， 90， 60， 120，110，130） B.（100，120，110，130，80， 60， 90）C.（100，60， 80， 90， 120，110，130）D. (100，80， 60， 90， 120，130，110)10. 在平衡二叉树中插入一个结点后造成了不平衡，设最低的不平衡结点为A,并已知A的左孩子的平衡因子为0右孩子的平衡因子为1,则应作( ) 型调整以使其平衡。
数据库系统l试题库及答案 第9章 查找
第9章查找9.1知识点:静态查找表一、填空题1.在数据的存放无规律而言的线性表中进行检索的最佳方法是。
2.查找表是由构成的集合。
3.若对查找表只做“查询某个特定的数据元素是否在查找表中”和“查询某个特定的数据元素的各种属性”操作，则称此类查找表为。
若在查找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已存在的某个数据元素，则称此类查找表为。
4.在n个记录的有序顺序表中进行折半查找，最大的比较次数为。
5.是顺序查找的一种改进方法，又称索引顺序查找，具体实现为将一个主表分成n个子表，要求子表之间元素是按，而子表中元素可以无序的，用每个子表最大关键字和指示块中第一个记录在表中位置建立。
6.分块查找的时间复杂度是。
7.顺序查找n个元素的顺序表，若查找成功，则比较关键字的次数最多为次；当使用监视哨时，若查找失败，则比较关键字的次数为次。
8.由于查找运算的主要运算是关键字的比较,所以通常把______________作为衡量一个查找算法效率优劣的标准。
它的计算公式为________________________________________。
二、选择题1.（）在表长为ｎ的链表中进行顺序查找，它的平均查找长度为（）。
A. ＡＳＬ＝ｎB. ＡＳＬ＝（ｎ＋１）／２C. ＡＳＬ＝＋１D. ＡＳＬ≈ｌｏｇ２（ｎ＋１）－１2.（）采用折半查找方法查找长度为n的线性表时，平均时间复杂度为（）。
A.O(n2)B.O(nlogn)C.O(n)D.O(logn)3.（）折半查找有序表（4，6，10，12，20，30，50，70，88，100）。
若查找表中元素58，则它将依次与表中（）比较大小，查找结果是失败。
A．20，70，30，50 B．30，88，70，50 C．20，50 D．30，88，504.（）有序线性表（a1，a2，a3，…，a256)是从小到大排列的，对一个给定的值k，用二分法检索表中与k相等的元素，在查找不成功的情况下，最多需要检索（）次。
数据结构-第9章 查找
静态查找表 对查找表的查找仅是以查询为 目的，不改动查找表中的数据。 动态查找表 在查找的过程中同时插入不存 在的记录，或删除某个已存在的记录。
查找成功 查找表中存在满足查找条件的记 录。 查找不成功 查找表中不存在满足查找条件 的记录。
内查找 整个查找过程都在内存中进行。 外查找 在查找过程中需要访问外存。 平均查找长度ASL——查找方法时效的度量 为确定记录在查找表中的位置，需和给定值 进行比较的关键字个数的期望值。 n 查找成功时的ASL计算方法： ASL pici
3. 在二叉排序树上的操作
1)查找
[例] Key=28 f 24 12 T
45
53 28 90
Key=32 T 45 24 53 12 f 28 90 32
[算法描述]
2) 插入
[算法描述]
3) 生成
查找算法
返回
BiTree SearchBST(BiTree T,KeyType key){
//在根指针T所指二叉树中递归地查找某关键字等于 //key的数据元素,若查找成功,则返回指向该数据元 //素结点的指针,否则返回空指针
图9.1 用折半查找法查找12、50的过程 其中mid=(low+high)/2，当high<low时，表 示不存在这样的子表空间，查找失败。
成功！ 位 置 1 2 3 4 5 6 7 8 9 10 11
值
6 12 15 18 22 25 28 35 45 58 60
low hign mid mid hign mid low mid (a) 用折半查找法查找12的过程
[性能分析] • 空间：一个辅助空间。 • 时间： 查找成功时的平均查找长度 设表中各记录查找概率相等 n ASLs(n)= PiCi =(1+2+ ... +n)/n =(n+1)/2 i 1 [算法特点] • 算法简单，对表结构无任何要求 • n很大时查找效率较低 • 改进措施：非等概率查找时，可将查找概率高 的记录尽量排在表后部。