数据结构:第七章 查找

合集下载

数据结构 查找

数据结构 查找

用二次探测再散列技术处理冲突
再哈希法
当发生冲突时,用另一个哈希函数计算出 另—个哈希地址,如果还发生冲突,再使 用另一个哈希函数,直至不发生冲突为止。 这种方法要求预先设置一个哈希函数的序 列。
链地址法
链地址法解决冲突的做法是将所有关键字为同义 词的结点链接在同一个单链表中。若哈希函数的 值域为0~m-1,则可将散列表定义为一个由m 个头指针组成的指针数组HT[m],凡是散列地址 为i的结点,均插入到以HT[i]为头指针的单链表 中。
7.4.4 哈希表查找的性能分析
由于冲突的存在,产生冲突后的查找仍然是给定值与 关键码进行比较的过程。
在查找过程中,关键码的比较次数取决于产生冲突的 概率。而影响冲突产生的因素有: (1)散列函数是否均匀
(2)处理冲突的方法
(3)散列表的装载因子 α =表中填入的记录数/表的长度
几种不同处理冲突方法的平均查找长度
查找算法的性能
平均查找长度:查找算法进行的关键码的比较 次数的数学期望值。计算公式为:
ASL = pi ci i =1
其中:n:问题规模,查找集合中的记录个数; pi:查找第i个记录的概率; ci:查找第i个记录所需的关键码的比较次数。
n
结论:ci取决于算法;pi与算法无关,取决于具体应用。如果 pi是已知的,则平均查找长度只是问题规模的函数。
使用条件: 线性表中的记录必须按关键码有序; 必须采用顺序存储。 基本思想: 在有序表中,取中间记录作为比较对象,若给定值与 中间记录的关键码相等,则查找成功;若给定值小于 中间记录的关键码,则在中间记录的左半区继续查找; 若给定值大于中间记录的关键码,则在中间记录的右 半区继续查找。不断重复上述过程,直到查找成功, 或所查找的区域无记录,查找失败。

数据结构7 查找

数据结构7 查找

折半法算法分析
假设:查找关键字为0-6的数据
查找的过程形成二叉判定树
3
5 2 4 6
ASL=1/7(1+2×2+4×3)
1
=2.43

0
假设:有序表长度为n,且n≤2h-1 二叉判定树 若n=2h-1 则:查找过程为一棵深度为h的满二叉树,
2014-7-4 第7章 查找 18
则满二叉树的第 i 层有2i-1个结点。
分块[17,8,21,19],[31,33,25,22], [43,37,35,40], [61,73,78,55] 索引表:21 33 43 78
数据表
17 8 21 19 31 33 25 22 43 37 35 40 61 73 78 55 … … … … … … … … … … … … … … … …
(2)key与R[mid].key比较
若key=R[mid].key则查找成功; 若key<R[mid].key ,则high=mid-1,转(3)。 若key>R[mid].key ,则low=mid+1,转(3)。 (3)若low≤high, 则重复(1) 否则:查找不成功,结束。
2014-7-4
关键字 地址 21 33 43 78
2014-7-4
第7章 查找
22
表结构说明:
typedef struct {KeyType key; int link; } indextype; indextype Lr[m] typedef struct {char name[10]; KeyType key; } DataType; DataType r[Max];
ASL=∑[(1/n)×2i-1 ×i]

《数据结构(C语言版 第2版)》(严蔚敏 著)第七章练习题答案

《数据结构(C语言版 第2版)》(严蔚敏 著)第七章练习题答案

《数据结构(C语言版第2版)》(严蔚敏著)第七章练习题答案第7章查找1.选择题(1)对n个元素的表做顺序查找时,若查找每个元素的概率相同,则平均查找长度为()。

A.(n-1)/2B.n/2C.(n+1)/2D.n答案:C解释:总查找次数N=1+2+3+…+n=n(n+1)/2,则平均查找长度为N/n=(n+1)/2。

(2)适用于折半查找的表的存储方式及元素排列要求为()。

A.链接方式存储,元素无序B.链接方式存储,元素有序C.顺序方式存储,元素无序D.顺序方式存储,元素有序答案:D解释:折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。

(3)如果要求一个线性表既能较快的查找,又能适应动态变化的要求,最好采用()查找法。

A.顺序查找B.折半查找C.分块查找D.哈希查找答案:C解释:分块查找的优点是:在表中插入和删除数据元素时,只要找到该元素对应的块,就可以在该块内进行插入和删除运算。

由于块内是无序的,故插入和删除比较容易,无需进行大量移动。

如果线性表既要快速查找又经常动态变化,则可采用分块查找。

(4)折半查找有序表(4,6,10,12,20,30,50,70,88,100)。

若查找表中元素58,则它将依次与表中()比较大小,查找结果是失败。

A.20,70,30,50B.30,88,70,50C.20,50D.30,88,50答案:A解释:表中共10个元素,第一次取⎣(1+10)/2⎦=5,与第五个元素20比较,58大于20,再取⎣(6+10)/2⎦=8,与第八个元素70比较,依次类推再与30、50比较,最终查找失败。

(5)对22个记录的有序表作折半查找,当查找失败时,至少需要比较()次关键字。

A.3B.4C.5D.6答案:B解释:22个记录的有序表,其折半查找的判定树深度为⎣log222⎦+1=5,且该判定树不是满二叉树,即查找失败时至多比较5次,至少比较4次。

(6)折半搜索与二叉排序树的时间性能()。

王道数据结构 第七章 查找思维导图-高清脑图模板

王道数据结构 第七章 查找思维导图-高清脑图模板

每次调整的对象都是“最小不平衡子树”
插入操作
在插入操作,只要将最小不平衡子树调整平衡,则其他祖先结点都会恢复平衡
在A的左孩子的左子树中插入导致不平衡
由于在结点A的左孩子(L)的左子树(L)上插入了新结点,A的平衡因子由1增
至2,导致以A为根的子树失去平衡,需要一次向右的旋转操作。
LL
将A的左孩子B向右上旋转代替A成为根节点 将A结点向右下旋转成为B的右子树的根结点
RR平衡旋转(左单旋转)
而B的原左子树则作为A结点的右子树
在A的左孩子的右子树中插入导致不平衡
由于在结点A的左孩子(L)的右子树(R)上插入了新结点,A的平衡因子由1增
LR
至2,导致以A为根的子树失去平衡,需要两次旋转操作,先左旋转再右旋转。
将A的左孩子B的右子树的根结点C向左上旋转提升至B结点的位置
本质:永远保证 子树0<关键字1<子树1<关键字2<子树2<...
当左兄弟很宽裕时,用当前结点的前驱、前驱的前驱来填补空缺 当右兄弟很宽裕时,用当前结点的后继、后继的后继来填补空缺
兄弟够借。若被删除关键字所在结点删除前的关键字个数低于下限,且与此结点 右(或左)兄弟结点的关键字还很宽裕,则需要调整该结点、右(或左)兄弟结 点及其双亲结点及其双亲结点(父子换位法)
LL平衡旋转(右单旋转)
而B的原右子树则作为A结点的左子树
在A的右孩子的右子树中插入导致不平衡
由于在结点A的右孩子(R)的右子树(R)上插入了新结点,A的平衡因子由-1
减至-2,导致以A为根的子树失去平衡,需要一次向左的旋转操作。
RR
将A的右孩子B向左上旋转代替A成为根节点 将A结点向左下旋转成为B的左子树的根结点

第1.7章 数据结构——查找

第1.7章 数据结构——查找
The College of Computer Science and Technology
若对此算法进行一些改进, 若对此算法进行一些改进,在表尾增加一个关键字为 指定值K的记录 可避免每“比较”一次, 的记录, 指定值 的记录,可避免每“比较”一次,就要判别查找 是否结束。 很大时, 是否结束。当n很大时,大约可节省一半的时间。 很大时 大约可节省一半的时间。
The College of Computer Science and Technology
性能分析
折半查找成功的平均查找长度为: 折半查找成功的平均查找长度为: ASLbs=[log2n]+1 (求解过程从略 求解过程从略) 求解过程从略 折半查找的优点是比较次数少,查找速度快, 折半查找的优点是比较次数少,查找速度快,但只能 对有序表进行查找。 对有序表进行查找。它适用于一经建立就很少变动而又经 常需进行查找的有序表。 常需进行查找的有序表。
改进算法
#define MAXLEN n+1 int seqsearch2(DATATYPE A[],int k) { int i; i=0; A[MAXLEN−1].key=k;
The College of Computer Science and Technology
while (A[i].key!=k) i++; if (i<MAXLEN−1) return i; else return –1; } 称作监视哨, 将A[MAXLEN−1]称作监视哨,这个增加的记录起 称作监视哨 到了边界标识的作用。 到了边界标识的作用。
第一篇 数据结构
第7章 查找 章
章节分布
1 2 3 4
查找的基本概念
顺序查找

数据结构:第七章 查找

数据结构:第七章 查找
算法描述
索引表
22 48 86 1 7 13
查38
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 22 12 13 8 9 20 33 42 44 38 24 48 60 58 74 57 86 53
查找方法比较
ASL 表结构 存储结构
顺序查找 最大
折半查找 最小
关键字输入顺序:45,24,53,12,28,90
45
24
53
12
28
90
9.4 哈希查找
基本思想:在记录的存储地址和它的关键字之间建立一 个确定的对应关系(函数关系);这样,不经过比较, 直接通过计算就能得到所查元素。
一、定义
❖哈希函数——在记录的关键字与记录的存储地址之间 建立的一种对应关系叫哈希函数。
high low
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
6
56
3
9
19
80
1
4
7
10
5 21 64 88
比较1次 比较2次 比较3次
2
13
5
8
37 75
11
92
比较4次
判定树(二叉排序树):描 述查找过程的二叉树
把当前查找区间的中间位 置上的结点作为根,左子表 和右子表中的结点分别作 为根的左子树和右子树
适用条件:采用顺序存储结构的有序表。 算法实现
❖设表长为n,low、high 和 mid分别指向待查元素所 在区间的上界、下界和中点,k为给定值
❖初始时,令low=1, high=n, mid=(low+high)/2 ❖让k与mid指向的记录比较

数据结构实验七 查找

数据结构实验七 查找

数据结构实验七查找在计算机科学中,数据结构是组织和存储数据的方式,而查找则是在给定的数据结构中寻找特定元素的操作。

本次实验七的重点就是深入研究查找这一重要的数据处理操作。

查找操作在我们日常生活和计算机程序中无处不在。

想象一下在电话簿中查找一个朋友的号码,或者在图书馆的书架中寻找一本书,这都是查找的实际应用场景。

在计算机程序中,当我们需要从大量数据中快速找到所需的信息时,高效的查找算法就显得至关重要。

常见的查找算法有顺序查找、二分查找、哈希查找等。

顺序查找是最简单直接的方法,它从数据结构的起始位置开始,依次比较每个元素,直到找到目标元素或者遍历完整个数据结构。

这种方法适用于数据量较小或者数据未排序的情况。

让我们通过一个简单的示例来理解顺序查找。

假设有一个整数数组5, 3, 8, 2, 9,我们要查找数字 8。

从数组的第一个元素 5 开始,依次与8 进行比较。

当比较到第三个元素时,找到了目标数字 8,查找结束。

虽然顺序查找的思路简单,但在数据量较大时,它的效率相对较低。

与顺序查找不同,二分查找则要求数据是有序的。

它通过不断将待查找的区间一分为二,逐步缩小查找范围,从而提高查找效率。

还是以整数数组为例,比如 2, 4, 6, 8, 10 要查找数字 6。

首先,比较中间元素 6 和目标数字 6,正好相等,查找成功。

如果要查找的数字小于中间元素,则在左半区间继续查找;如果大于中间元素,则在右半区间查找。

二分查找的效率在有序数据中表现出色。

然而,如果数据经常变动,需要频繁进行插入和删除操作,维护数据的有序性可能会带来较大的开销。

哈希查找则是另一种常见的查找方法。

它通过一个哈希函数将关键字映射到一个特定的位置,从而实现快速查找。

哈希函数的设计至关重要,如果设计不当,可能会导致大量的冲突,影响查找效率。

在实际应用中,选择合适的查找算法取决于多种因素,如数据的规模、数据的分布特征、查找的频繁程度以及对时间和空间复杂度的要求等。

《数据结构(C语言)》第7章 查找

《数据结构(C语言)》第7章 查找
第7章 查找
教学要求
❖ 建议学时:6学时 ❖ 总体要求
掌握顺序查找、折半查找的实现方法; 掌握动态查找表(二叉排序树、二叉平衡树)的构造
和查找方法; 掌握哈希表、哈希函数a structures
教学要求
❖ 相关知识点
顺序查找、折半查找的基本思想、算法实现和查找效 率分析
Data structures
静态查找表
❖ 顺序查找
❖1. 一般线性表的顺序查找
(2) 静态查找表的顺序存储结构
静态查找表采用顺序存储结构,其类型定义如下:
typedef struct
{ ElemType *elem; 建表时按实际长度分配*/
/*元素存储空间基址,
int TableLen;
/*表的长度*/
Data structures
静态查找表
❖ 分块查找
索引表的类型定义如下:
typedef struct{
Elemtype key;
/*块内最大关键字值*/
int stadr; 的位置*/
/*块中第一个记录
}indexItem;
typedef struct{
indexItem elem[n];
int length;
Data structures
静态查找表
❖ 折半查找
4.折半查找算法 算法7.2 折半查找算法
else if(L.elem[mid].key>key)high=mid-1; 前半部分继续查找*/
else low=mid+1; /*从后半部分继续查找*/
}
return -1; /*顺序表中不存在待查元素*/
(1) 基本思想 从线性表的一端开始,逐个检查关键字是否满足给定

数据结构-第7章-静态查找

数据结构-第7章-静态查找

27
例:查找key为22的过程:
0 1 2 3 4 5 6 7 8 9 10 11 12 13
7 14 18 21 23 29 31 35 38 42 46 49 52
low=1 18<22 mid=7 31>22 mid=3 high=6
low=4 mid=5 23>22
2021/4/9
high=4
0 1 2 3 4 5 6 7 8 9 10 11
2021/4/9
kval = 60
ST .Length
20
int//不Se带ar岗c哨h_的S从eq前(S向S后Ta查b找le ST, while ( i<=L.length && SKT.eelyemTy[ip].keeey!)={e)
// 在顺序i++表; ST中顺序查找其关键字等于 //ifk(eyi<的=数ST据.le元ng素th。) 若ret找ur到n ,i; 则函数值为
}
return 0;
// 顺序表中不存在待查元素
} // S20e2a1/4r/9ch_Bin
29
折半查找——递归算法
int Search_Bin1 ( SSTable ST, int low,int high,
KeyType kval ) { if (low>high) return 0;
else { mid=(low+high)/2; if (kval<ST.elem[mid].key) return Search_Bin1(ST, low, mid-1, kval); else if (kval> ST.elem[mid].key) return Search_Bin1(ST, mid+1, high, kval); else return mid; }

数据结构》第七章查找

数据结构》第七章查找
5
(最坏情况)
可编辑ppt
11
7.2 顺序查找
成功查找的平均查找长度为(n+1)/2。显然不成功 查找次数为n+1,其时间复杂度均为 O(n)。
顺序查找的优点是:算法简单且适用面广,它对表的 结构无任何要求。无论记录是否按关键字的大小有序,其 算法均可应用,而且上述讨论对线性链表也同样适用。
顺序查找的缺点是:查找效率低,当 n 较大时,不宜 采用顺序查找。

5 13 19 21 37 56 64 75 80 88 92
low>high 查找失败
123456
low high
mid 7 8 9 10 11
5 13 19 21 37 56 64 75 80 88 92
可编辑ppt
16
high low
7.3 二分法查找
从二分法查找的执行情况分析,每做一次比较,查找的 范围都缩小一半。因此二分法查找的平均查找长度为
【答案】
查找成功时,最少比较1次,最多比较5次。
2、已知如下11个数据元素的有序表(6,14,19, 21,36,57,63,76,81,89,93),请画出 查找键值为21和85的查找过程。
可编辑ppt
18
7.4 分块查找
可编辑ppt
10
01 64 5
23456 13 19 21 37 56
找64 7 8 9 10 11 64 75 80 88 92
监视哨
比较次数:
查找第n个元素: 1
查找第n-1个元素:2
……….
查找第1个元素: n
查找第i个元素: n+1-i
查找失败:
n+1
iiiii

数据结构(Java语言描述)第七章 查找

数据结构(Java语言描述)第七章  查找
数据结构
第七章 查找
目录
1 查找
2 静态查找表
第七章 查找
动态查找表 哈希表 小结
总体要求
•掌握顺序查找、折半查找的实现方法; •掌握动态查找表(包括:二叉排序树、二叉平衡树 、B-树)的构造和查找方法; •掌握哈希表、哈希函数冲突的基本概念和解决冲突 的方法。
7.1基本概念
1、数据项 数据项是具有独立含义的标识单位,是数据不可分 割的最小单位。 2、数据元素 数据元素数是据由项若(名干) 数据项构成的数据单位,是在某
}
性能分析:i 0 1 2 3 4
5 13 19 21 37
Ci 3 4 2 3 4
查找成功:
比较次数 = 路径上的结点数
比较次数 = 结点 4 的层数
比较次数
2
56 7 56 64 75 1 34
判定树
5
8 9 10 80 88 92 2 34
查找37 8
树的深度
0
3
6
9
≤=
log2n +1
1
4
}
【算法7-1】初始化顺序表 public SeqTable(T[] data,int n){
elem=new ArrayList<ElemType<T>>(); ElemType<T> e; for(int i=0;i<n;i++){
e=new ElemType<T>(data[i]); elem.add(i, e); } length=n; }
前者叫作最大查找长度(Maximun Search Length),即 MSL。后者叫作平均查找长度(Average Search Length) ,即ASL。

数据结构第7章查找

数据结构第7章查找
于根结点的值; (2)若其右子树非空,则右子树上所有结点的值均大
于等于根结点的值; (3)其左右子树本身又各是一棵二叉排序树
2021年7月21日
练习
下列图形中,哪个不是二叉排序树 ?
2021年7月21日
练习
中序遍历二叉排序 树后的结果有什么 规律?
45 12
3
37
24 3,12,24,37,45,53,61,78,90,100
• 重复上述操作,直至low>high时,查找失败
2021年7月21日
折半查找(递归算法)
int Search_Bin (SSTable ST, keyType key, int low, int high) { if(low>high) return 0; //查找不到时返回0 mid=(low+high)/2; if(key与ST.elem[mid].key) return mid; else if(key小于ST.elem[mid].key)
……..//递归 else……. //递归 }
2021年7月21日
折半查找的性能分析-判定树
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
6 < => 3
1
4
7
1 2 9
10 内结点
-1 2 3-4 5 6-7 8 9-10 11 h
1-2 2-3
4-5 5-6
7-8 8-9 10-11 11-
外结点
查找成功时比较次数:为该结点在判定树上的层次数,不超过树 的深度 d = log2 n + 1
查找不成功的过程就是走了一条从根结点到外部结点的路径d或 d-1。

《数据结构实用教程(C语言版)》第7章查找.

《数据结构实用教程(C语言版)》第7章查找.
返回到本节首页
返回到本节首页
返回到本节首页
2.折半查找的算法
(1)折半查找的算法如算法7.3所示。 算法7.3 int BinSearch(LineList r[], int n, KeyType k) { int low,high,mid; low=1; high=n; /*置区间初值 */ while(low<=high) /*查找区间 不为空时*/ { mid=(low+high)/2;
数据结构实用教程(C语言版)
中国水利水电出版社
第7章 查找
本章主要介绍以下内容: 静态查找方法,主要介绍顺序查找、折半查找和 分块查找 动态查找方法,主要介绍二叉排序树查找 哈希表查找
本章目录
1 2 3 4 5
7.1 基本概念
7.2 静态查找
7.3 二叉排序树查找
7.4 哈希表查找
7.5 小结
结束
7.1 基本概念
1.查找表 用于查找的数据元素集合称为查找表。查找表 由同一类型的数据元素构成。 2.静态查找表 在查找过程中查找表本身不发生变化,称为静 态查找表。对静态表的查找称为静态查找。 3.动态查找表 若在查找过程中可以将查找表中不存在的数据 元素插入,或者从查找表中删除某个数据元 素,则称这类查找表为动态查找表。对动态 查找表进行的查找称为动态查找。
返回到本节首页
7.2 静态查找
静态查找主要有顺序查找、折半查找、分块 查找三种。 7.2.1顺序查找
7.2.2 折半查找
7.2.3 分块查找
返回到总目录
7.2.1顺序查找
1.顺序查找的主要思想 顺序查找是一种最简单的查找方法,它的基本 思路是:从表的一端开始,用所给定的关键 字依次与顺序表中各记录的关键字逐个比较, 若找到相同的,查找成功;否则查找失败。

数据结构与算法课件第7章查找

数据结构与算法课件第7章查找

1.二叉排序树的定义 二叉排序树(Binary Sort Tree),或者是一棵
空树;或者是具有下列性质的二叉树: (1)若左子树不空,则左子树上所有结点的值
均小于根结点的值; (2)若右子树不空,则右子树上所有结点的值
均大于根结点的值; (3)左、右子树本身又各都是一棵二叉排序树。
二叉排 序树
第一步以 X 为轴心,将 B 从 X 的左上方转到 X 的左下 侧,使 B 成为 X 的左孩子, X 成为 A 的左孩子。第二 步跟 LL 型一样处理 ( 应以 X 为轴心 ) 。
(4)右左(RL)型 新结点 X 插在 A 的右孩子的左子树里。分为两步进行:
第一步以 X 为轴心,将 B 从 X 的右上方转到 X 的右下 侧,使 B 成为 X 的右孩子, X 成为 A 的右孩子。第二 步跟 RR 型一样处理 ( 应以 X 为轴心 ) 。
二叉排序树 生成过程
4.二叉排序树的删除
如图三颗二叉排序树由值相同的关键字构成,但 是它们的输入顺序不ห้องสมุดไป่ตู้样:
图 (a)是按一月到十二月的自然月份序列输入所 生成的;
图 (b)的输入序列为(July, Feb, May, Mar, Aug, Jan, Apr, Jun, Oct, Sept, Nov, Dec)
比较的次数的期望值,通常记作ASL。
对于一个含有n个元素的表,查找成功时的平均查找长度 可表示为
其中,Pi为表中查找第i个记录的概率,Ci为查找第i个 记录所用到的比较次数。显然,对于不同的查找方法Ci 可能不一同。Pi很难通过分析给出,一般情形下我们认 为查找每个记录的概率相等。
顺序查找的基本思想是:从表的一端开始,顺序扫描 线性表,依次将扫描到的结点关键字和待查找值key相 比较,若相等,则查找成功,若整个表扫描完毕,仍 末找到关键字等于key的元素,则查找失败。

数据结构第七章-搜索结构

数据结构第七章-搜索结构

数据结构第七章-搜索结构数据结构第七章搜索结构在计算机科学中,数据结构是组织和存储数据的方式,以便能够高效地访问和操作这些数据。

搜索结构作为数据结构中的重要组成部分,它的作用在于能够在给定的数据集合中快速准确地找到所需的元素。

搜索,简单来说,就是在一组数据中查找特定的元素。

想象一下,你有一本厚厚的电话簿,要从中找到某个人的电话号码,这就是一个搜索的过程。

在计算机中,数据量可能极其庞大,如何快速有效地完成搜索就显得至关重要。

常见的搜索结构有线性搜索和二分搜索。

线性搜索是最简单直观的搜索方法。

它从数据集合的开头,依次检查每个元素,直到找到目标元素或者检查完整个集合。

就好像你在一个排好队的人群中,从第一个人开始,逐个询问是不是你要找的那个人。

这种方法的优点是简单易懂,容易实现。

但缺点也很明显,当数据量很大时,搜索效率会非常低。

举个例子,如果我们有一个包含 1000 个整数的数组,要查找一个特定的数。

使用线性搜索,最坏的情况是需要检查完这 1000 个数才能确定目标数是否存在。

二分搜索则是一种效率更高的搜索方法,但它要求数据集合是有序的。

它的基本思想是每次将搜索范围缩小一半。

就好比猜数字游戏,你先猜 50,被告知大了,那你就会在 1 到 49 之间猜,再比如猜 25,被告知小了,那就在 26 到 49 之间猜。

通过不断地将范围缩小一半,快速逼近目标。

二分搜索的时间复杂度要远远低于线性搜索。

对于一个包含 n 个元素的有序数组,二分搜索的最坏情况下的时间复杂度为 O(log n),而线性搜索为 O(n)。

这意味着当数据量越大,二分搜索的优势就越明显。

除了上述两种基本的搜索方法,还有一些更复杂的搜索结构,如二叉搜索树、哈希表等。

二叉搜索树是一种特殊的二叉树结构。

对于二叉搜索树中的每个节点,其左子树中的所有节点的值都小于该节点的值,右子树中的所有节点的值都大于该节点的值。

这使得在二叉搜索树中进行搜索、插入和删除操作的平均时间复杂度都为 O(log n)。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

iii
比较次数:
查找第n个元素: 1
查找第n-1个元素:2
……….
查找第1个元素: n
查找第i个元素: n+1-i
查找失败:
n+1
ii
比较次数=5
数据结构定义:
因一般不对查找表做修改,表长不变,所以可将其 作为常量。以顺序表为例:
#define n 100
typedef struct
{ keytype key;
1、 顺序查找
查找过程:从表的一端开始逐个进行记录的关键字和给 定值的比较。若相等则成功;若扫描结束仍未找到,则 失败。
找64
例 0 1 2 3 4 5 6 7 8 9 10 11 64 5 13 19 21 37 56 64 75 80 88 92
监视哨:设置在两 端r[0]或r[n+1], 使其关键字值为给 定值k。避免每次 的越界判断。
第七章 查 找
➢线性表的查找 ➢树上的查找 ➢散列技术
7.1 基本概念
查找——也叫检索,是根据给定的某个值,在表(指查找表) 中确定一个关键字等于给定值的记录或数据元素。
关键字——是数据元素中某个数据项的值,它可以标识一 个数据元素。
平均查找长度ASL——由于查找运算的关键操作是关键字的 比较。通常以查找过程中对关键字执行的平均比较次数, 即平均查找长度(ASL),作为衡量一个查找算法效率优劣的 标准。
high low
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
6
56
3
9
19
80
1
4
7
10
5 21 64 88
比较1次 比较2次 比较3次
2
13
5
8
37 75
11
92
比较4次
判定树(二叉排序树):描 述查找过程的二叉树
把当前查找区间的中间位 置上的结点作为根,左子表 和右子表中的结点分别作 为根的左子树和右子树
1 n
则ASL
n i 1
pi ci
1 n
n i 1
(n i 1)
n 1 2
顺序查找的优缺点:
优点:简单且适用面广,对表的结构没有要求, 无论记录是否按关键字有序都可应用。
缺点:效率低。
2、 折半查找(二分查找)
查找过程:以中间位置记录关键字与给定值比 较。相等则成功;不等,则缩小查找范围,继 续查找。每次将待查记录所在区间缩小一半。
查找方法的确定:首先取决于使用的数据结构(线性表、 图);其次是表的有序性(有序、无序)。主要分为:顺 序查找、折半查找和分块查找,这3种属于静态查找(查找 过程不修改原结构),一般以线性表做为数据结构。另一 类是二叉排序树查找,属于动态查找(即动态生成查找结 构,在查找同时,对原结构做修改)。
7.2 线性表的查找——静态查找
return 0;
// 顺序表中不存在待查元素
} // Search_Bin
算法评价
❖折半查找过程恰好是走了一条从根结点到被查结点的 路径.比较次数为路径上结点个数(被查结点在树上的 层数),在查找过程中进行的比较次数最多不超过其判 定树的深度.
算法描述
找21 例 1 2 3 4 5 6 7 8 9 10 11
5 13 19 21 37 56 64 75 80 88 92
low
mid
123456 7 5 13 19 21 37 56 64
high
8 9 10 11 75 80 88 92
low
mid
high
1 2 3 4 5 6 7 8 9 10 11
5 13 19 21 37 56 64 75 80 88 92
lowmid high
找70 例 1 2 3 4 5 6 7 8 9 10 11
5 13 19 21 37 56 64 75 80 88 92
low
mid
123456 7
5 13 19 21 37 56 64
high 8 9 10 11 75 80 88 92
{ mid = (low + high) / 2;
if(k= = r[mid].key ) return mid; //找到
if ( k < r[mid].key ) high = mid - 1;
// 继续在前半区间内进行查找
else low = mid + 1; // 继续在后半区间内进行查找
} //while
折半查找算法:
int Search_Bin ( Seqlist r, KeyType k )
{// 在有序表ST中折半查找其关键字等于kval的数据元素。 // 若找到,则函数值为该元素在表中的位置,否则为0。
int low = 1, high = n, mid; // 置区间初值
while (low <= high)
low
mid
high
1 2 3 4 5 6 7 8 9 10 11
5 13 19 21 37 56 64 75 80 88 92
low mid high 1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
low high mid
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
若找到则返回该元素在表中的位置,否则为0。
int i=n;
r[0].key == k;

// 设置"哨兵“
while(r[i].key != k) i--; // 从后往前查找
return i; // 成功则返回位置不成功返回0
} // Search_Seq
顺序查找方法的ASL
设表中每个元素的查找概率相等pi
适用条件:采用顺序存储结构的有序表。 算法实现
❖设表长为n,low、high 和 mid分别指向待查元素所 在区间的上界、下界和中点,k为给定值
❖初始时,令low=1, high=n, mid=(low+high)/2 ❖让k与mid指向的记录比较
若k==r[mid].key,查找成功 若k<r[mid].key,则high=mid-1 若k>r[mid].key,则low=mid+1 ❖重复上述操作,直至low>high时,查找失败
//关键字
infotype otherinfo; //其他数据项
} NodeType;
Typedef NodeType Seqlist[n+1]; //多一个设置哨兵
顺序查找算法:
int Search_Seq (Seqlist r, KeyType k)
{ // 在顺序表ST中顺序查找其关键字等于kval的数据元素,
相关文档
最新文档