数据结构查找
数据结构中的查找方法
数据结构中的查找方法
数据结构中的查找方法是指在指定的数据集合中,找到目标值的过程。在计算机科学中,查找方法通常用于在海量数据中快速找到特定项,
以提高程序的效率和性能。常见的查找方法包括线性查找、二分查找、哈希查找等。
线性查找,也称为顺序查找,是最简单的查找方法之一。它的思路就
是从数据集合的第一个元素开始逐个遍历,直到找到目标值或遍历完
整个数据集合。线性查找的时间复杂度为 O(n),其中 n 为数据集合的元素个数。因此,当数据集合很大时,这种方法的效率非常低,并不
适用于大规模数据的查找。
二分查找,也称为折半查找,是一种高效的查找方法。二分查找的前
提是数据集合已经按照升序或降序排列,每次都将数据集合不断折半,直到找到目标值为止。二分查找的时间复杂度为 O(log n),其中 n 为数据集合的元素个数。由于二分查找需要先对数据集合进行排序,因
此在处理大规模数据时,需要额外的时间和空间开销。
哈希查找利用哈希表的数据结构进行查找,将目标值映射为哈希表的
索引位置,根据索引快速定位目标值。哈希查找的时间复杂度为O(1),是一种非常高效的查找方法。但是哈希查找需要占用大量内存空间,
因此适用于数据集合较小的情况。
在实际应用中,不同的查找方法应根据具体情况选择。如果数据集合
较小,且不需要进行频繁的查找操作,可以使用简单的线性查找方法。如果数据集合较大,或需要频繁查找目标值,可以考虑使用高效的二
分查找或哈希查找方法。此外,对于某些特定的数据集合,如有序数组、二叉搜索树等,还可以使用其专用的查找方法进行查找操作。
数据结构 查找算法
数据结构查找算法
数据结构是计算机科学中用于组织和存储数据的方式,包括数组、链表、堆栈、队列、树、图等。查找算法是计算机科学中用于在数据结构中查找特定数据或元素的命令,通常用于在数据结构中查找预定义元素的位置或值。
以下是一些常见的数据结构和查找算法:
1.数组:数组是一种线性数据结构,其中元素存储在连续的内存空间中。使用顺序查找算法可以快速找到数组中的某个元素,例如使用牛顿迭代法或二分查找算法。
2.链表:链表是一种由节点组成的数据结构,每个节点包含一个值和一个指向下一个节点的指针。使用顺序查找算法可以快速找到链表中的任何一个元素,例如使用冒泡排序算法。
3.堆栈:堆栈是一种后进先出的数据结构,其中元素按照升序排列。使用顺序查找算法可以快速找到堆栈中的任何一个元素,例如使用二分查找算法。
4.队列:队列是一种线性数据结构,其中元素按照先进先出排列。使用顺序查找算法可以快速找到队列中的任何一个元素,例如使用冒泡排序算法。
5.树:树是一种常见的数据结构,其中元素按照一种特定的关系存储。使用顺序查找算法可以快速找到树中的任何一个元素,例如使用深度优先搜索算法。
6.图:图是一种包含多个节点和边的复杂数据结构。使用顺序查
找算法可以快速找到图中的任何一个元素,例如使用深度优先搜索算法。
查找算法通常基于以下原则:
1.选择一个适当的数据结构,例如数组、链表、栈、队列或树。
2.编写一个查找算法,该算法基于该数据结构的特性,使用相应的递归或迭代方法。
3.维护一个数组或指针,该数组或指针用于存储要查找的元素。
4.根据指定的规则,查找目标元素,并将结果存储在相应的数组或指针中。
《数据结构》--查找
8.2 查找概论
数据元 素(记录)
查找表(Search Table)是由同一类型的数据元素 (或记录)构成的集合。
数据项 (字段)
关键字 (Key) 是数据元素中某个数据项的 值,又称键值,用它可以标识一个数据元素。 标识一个记录的某个数据项(字段),称为 关键码。
主关 键码 主关 键字
次关 键码 次关 键字
算法分析
有序表数组{0,1,16,24,35,47,59,62,73,88,99}
小 小 小 1 大 16 24 大 35 小 大 47 47 大 小 59 小 大 62 73 88 小 大 99 大
折半算法时 间的时间复 杂 度 为 O(logn)。
课堂练习
实现顺序表的顺序查找和折半查找算法,函数原 型如下: int Sequential_Search1(int *a,int n, int key); int Sequential_Search2(int *a,int n, int key);
7 75
8 9 10 80 88 92
low mid high
找70
例
0 5
1 13
2 19 2 19 2 19
3 21 3 21 3 21
4 37 4 37 4 37
5 56
6 64
7 75 7 75
8 80
数据结构与算法-查找
数据结构与算法-查找
目录
一、查找的定义二、线性表的查找 2.1 、顺序查找 2.2、二分查
找 2.3、分块查找三、树表查找 3.1 、二叉排序树 3.2 、平衡二叉树一、查找的定义
查找又称检索,是数据处理中经常使用的一种重要运算。采用何种查
找方法,首先取决于使用哪种数据结构来表示“表”,及表中的数据元素按何种方式组织。查找有内查找和外查找之分。若整个查找过程都在内
存进行,则称为内查找;反之,若查找过程需要访问外存,则称为外查
找。关键字是指数据元素(记录)中一些项或组合项的值,用它可以标
识一个数据元素(记录)。能唯一确定一个数据元素(记录)的关键字,称为主关键字;而不能唯一确定一个数据元素(记录)的关键字,称为次关键
字。查找表是指由具有同一类型(属性)的数据元素(记录)组成的集合。
分为静态查表和动态查找表。静态查找是指仅对查找表进行查找操作,而不改变查找表中的数据元素。动态查找是指除进行查找操作外,可能还要进行向表中插入或删除数据元素的操作。
平均查找长度
二、线性表的查找
2.1 、顺序查找
顺序查找( Sequential Search) 是一种最基本也是最简单的查找方法。它的基本思想是蛮力法,从表的一端开始,顺序扫描线性表,逐个进行结点关键字值与给定的值k相比较,若当前扫描到的结点关键字与k相等,
则查找成功;若扫描整个表后,仍未找到关键字与给定值k相等的结点,则查找失败。顺序查找方法既适用于线性表的顺序存储结构,也适用
于线性表的链式存储结构。使用单链表作存储结构时,查找必须从头指针开始,因此只能进行顺序查找。顺序查找代码如下:
数据结构(八)查找
search1(st,key,n) { st[0]=key; i=n; while(st[i]!=key) i- -; return i; //查找返回序号,0为不成功 }
算法主要时间在循环,为减少判定,n个数据用容量为n+1的 一维数组表示。st[1]到st[n]存储数据,st[0]作为监视哨
顺序查找的平均时间为表长的一半。 2、顺序有序表的查找——— 二分(折半)查找 查找过程:每次将待查记录所在区间缩小一半 适用条件:采用顺序存储结构的有序表 算法实现 设表长为n,low、high和mid分别指向待查元素所在区 间的上界、下界和中点,k为给定的待查值 初始时,令low=1,high=n,mid=(low+high)/2 让k与mid指向的记录比较: 若k=r[mid],查找成功,结束 若k<r[mid],则high=mid-1 若k>r[mid],则low=mid+1 重复上述操作,直至low>high时,查找失败 low mid high
122
99
250
110
300
280
类C程序实现: void InsertBST(*&t,key) //在二叉排序树中插入查找关键字key { if(t= = NULL){ t=new BiTree; t->lchild=t->rchild=NULL; t->data=key; return; } if(key<t->data ) InsertBST(t->lchild,key); else InsertBST (t->rchild, key ); } void CreateBiTree(tree,d[ ],n) //n个数据在数组d中,tree为二叉排序树根 { tree=NULL; for(i=0;i<n;i++) InsertBST(tree,d[i]); }
数据结构-查找
数据结构-查找
写在前⾯:这些内容是以考研的⾓度去学习和理解的,很多考试中需要⽤到的内容在实际应⽤中可能⽤不上,⽐如其中的计算问题,但是如果掌握这些东西会帮你更好的理解这些内容。
这篇关于查找的博客也只是⽤来记录以便于后续复习的,所以很多地⽅只是浅谈,并没有代码的实现
如果有缘发现这篇⽂章想要深⼊了解或者因为作者表达能⼒差⽽看不懂以及有错的地⽅,欢迎留⾔指出来,我会尽快去完善的,期待有缘⼈
内容多和杂,如果有机会我进⼀步进⾏梳理,将其重新梳理⼀⽚⽂章(会更注重于代码)
本来只是想简单写⼀下的,但是不⼩⼼就get不到重点了
本来打算等逐步完善和优化后再发出来的,但那样继续往前总感觉有所顾及,所以就先给这⼏天查找的复习暂时告⼀段落吧。
导学
概览
总体
(⼀)概念
查找:在数据集合中查找特定元素的过程
查找表(查找结构):同⼀类型数据元素构成的集合
静态查找表:只涉及查找,不存在修改
适⽤:顺序查找,折半查找,散列查找等
动态查找表:动态插⼊和删除,对查找表进⾏修改
适⽤:⼆叉排序树,散列查找等
所有数据结构都可以看作是查找表,对于折半查找和顺序查找这些都属于查找算法
关键字:数据元素中唯⼀标识该元素的某数据项的值
主关键字:此关键字能唯⼀表⽰⼀个数据元素
次关键字:此关键字⽤以识别若⼲记录(⼀对多)
说明:在查找表中每个数据元素就相当于⼀条记录,包含有不同的数据项,例如拿学⽣为例,⼀个学⽣作为数据元素,那么学号,⾝⾼,姓名就是这个元素中的数据项,每个学⽣都有特定的学号,因此学号可以作为关键字。(当然如果数据项包含⾝份证号,你⽤⾝份证号⾛位关键字也可以)
第9章 数据结构 查找
14 0
34 5
66 10
85 15
100 key 20 link
8 14 6 9 10 22 34 18 19 31 40 38 54 66 46 71 78 68 80 85 100 94 88 96 87 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
25 10 30 15 3 20 28 29 35 40
二分查 找判定 树
2
(1) 若 查 找 给 定 值为20的元素,依次 与 表 中 25,10,15,20 元素比较 , 共比较 4 次。
(2)若查找给定值为26的元素,依次与25,30,28元素比较,共比 较3次。 (3)在查找成功时 ,会找到图中某个圆形结点 ,则成功时的平 均查找长度:
n
例 10.1 对 于 给 定 11 个 数 据 元 素 的 有 序 表 {2,3,10,15,20,25,28,29,30,35,40}, 采用二分查找 , 试 问: (1)若查找给定值为20的元素,将依次与表中哪 些元素比较?
(2)若查找给定值为26的元素,将依次与哪些元 素比较?
(3)假设查找表中每个元素的概率相同,求查找 成功时的平均查找长度和查找不成功时的平均查 找长度。
}
return -1; }
若以二分查找来确定块 , 则分块查找成功时的 平均查找长度为:
数据结构的查找算法
数据结构的查找算法
在计算机科学中,数据结构是用于组织和存储数据的一种方式。查
找算法是数据结构中的重要部分,它用于在数据集合中搜索特定元素
或信息。本文将介绍几种常见的数据结构查找算法,包括线性查找、
二分查找、哈希查找以及树结构的查找算法。
1. 线性查找
线性查找是一种简单直观的查找方法,适用于无序的数据集合。其
基本思想是从数据集合的第一个元素开始逐个比较,直到找到目标元
素或者遍历完整个数据集合。由于线性查找需要遍历所有元素,所以
时间复杂度为O(n),其中n为数据集合的大小。
2. 二分查找
二分查找是一种高效的查找算法,但它要求数据集合中的元素必须
有序。具体实现方式是将数据集合分为两半,然后与目标元素进行比较,不断缩小查找范围,直到找到目标元素或者确定目标元素不存在。由于每次都将查找范围减小一半,所以时间复杂度为O(log n),其中n
为数据集合的大小。
3. 哈希查找
哈希查找利用哈希函数将目标元素映射到哈希表中的特定位置,从
而快速定位目标元素。哈希表是一种以键-值对形式存储数据的数据结构,可以快速插入和删除元素,因此在查找时具有良好的性能。哈希
查找的时间复杂度为O(1),但在处理哈希冲突时可能会影响性能。
4. 树结构的查找算法
树是一种常见的数据结构,其查找算法主要包括二叉搜索树、平衡二叉搜索树以及B树和B+树。二叉搜索树是一种有序的二叉树,左子树的所有节点值都小于根节点,右子树的所有节点值都大于根节点。通过比较目标元素与节点的值,可以快速定位目标元素。平衡二叉搜索树是为了解决二叉搜索树在某些情况下可能出现的退化情况,通过旋转操作保持树的平衡性。B树和B+树是一种多路搜索树,它们可以减少磁盘I/O操作,适用于大规模数据的查找。
数据结构 查找 实验报告
数据结构查找实验报告
数据结构查找实验报告
1. 简介
查找是计算机科学中一种常见的操作,它用于在一组数据中快
速定位特定的元素。数据结构是计算机存储、组织数据的方式,可
以有效地支持查找操作。本实验报告将介绍查找算法的原理和实现,以及实验结果的分析和总结。
2. 查找算法
2.1 顺序查找
顺序查找是一种简单直观的查找算法,它从数据集的第一个元
素开始逐个比较,直至找到目标元素或遍历完所有元素。顺序查找
的时间复杂度为O(n),其中n是数据集的大小。
2.2 二分查找
二分查找是一种高效的查找算法,它要求数据集必须是有序的。它通过将数据集分成两部分,并与目标元素进行比较,以确定目标
元素所在的区间,然后在该区间内继续二分查找,直至找到目标元
素或确定目标元素不存在。二分查找的时间复杂度为O(log n),其
中n是数据集的大小。
2.3 插值查找
插值查找是对二分查找的一种改进,它根据目标元素的估计位
置来确定比较的起始位置。它适用于数据集分布均匀的情况,可以
进一步减少查找的次数。插值查找的时间复杂度为O(log(log n))。
3. 实验结果
本次实验我们使用了三种查找算法(顺序查找、二分查找和插
值查找)在不同大小的数据集上进行了性能测试。实验结果如下表
所示:
---- 数据集大小 ---- 顺序查找时间(ms) ---- 二分查找时
间(ms) ---- 插值查找时间(ms) ----
-------------------------------------------------------
-------------------------------
数据结构查找范文
数据结构查找范文
数据结构是计算机科学的基础领域之一,它主要研究如何高效地存储和组织数据,以便于查找和检索。在计算机程序中,数据结构的选择和设计直接影响到程序的运行效率和性能。本文将介绍几种常见的数据结构查找算法,并分析它们的优缺点。
一、顺序查找
顺序查找是最简单直观的查找算法,它逐个比较待查找的元素和每个数据项,直到找到目标元素或者遍历完整个数据集。
优点:
-实现简单,易于理解和实现。
-对于小规模的数据集,性能较好。
缺点:
-对于大规模的数据集,性能较差,时间复杂度为O(n)。
二、二分查找
二分查找也称为折半查找,它要求查找的数据集必须是有序的。在每一次查找过程中,将待查找的元素与数据集的中间元素进行比较,如果相等则返回,如果待查找元素比中间元素小,则在前半部分继续查找,否则在后半部分继续查找,以此类推,直到找到目标元素或者查找范围为空。优点:
- 对于有序数据集,性能较好,时间复杂度为O(log n)。
-查找过程每一次都能将查找范围缩小一半,效率高。
缺点:
-要求数据集必须是有序的。
-对于插入、删除等操作频繁的场景,性能较差。
三、哈希查找
哈希查找通过哈希函数计算数据的哈希值,将数据存储在哈希表中,提供快速的查找速度。在查找过程中,利用哈希函数计算待查找元素的哈希值,然后在相应的哈希表位置查找目标元素。
优点:
-查找速度快,平均时间复杂度为O(1)。
-适用于大规模数据集和频繁插入、删除操作的场景。
缺点:
-对于哈希冲突较多的情况,性能会降低。
-哈希函数的设计和哈希表的大小选择对性能有影响。
四、二叉查找树
数据结构中的常用查找算法
数据结构中的常用查找算法
在数据结构中,查找算法是一种常见且重要的操作,它用于在给定数据集中查找特定元素的位置或者判断该元素是否存在。常用的查找算法包括线性查找、二分查找、哈希查找和树查找等。本文将介绍这些常用的查找算法,以帮助读者更好地理解和运用它们。
一、线性查找算法
线性查找算法是最简单的一种查找算法,也称为顺序查找。它的原理是逐个遍历数据集中的元素,直到找到目标元素为止。线性查找算法适用于无序数据集和小规模数据集的查找操作。其时间复杂度为O(n),其中n为数据集中元素的个数。
线性查找算法的实现思路如下:
1. 从数据集的第一个元素开始,逐个与目标元素进行比较;
2. 如果找到目标元素,则返回其位置;
3. 如果遍历完整个数据集仍未找到目标元素,则返回查找失败。
线性查找算法的优点是实现简单,适用于小规模数据集;缺点是时间复杂度较高,在大规模数据集中效率较低。
二、二分查找算法
二分查找算法是一种高效的查找算法,也称为折半查找。它要求数据集必须是有序的,通常是升序排列。二分查找算法的时间复杂度为O(log n),其中n为数据集中元素的个数。
二分查找算法的实现思路如下:
1. 将数据集按照某种规则排序;
2. 确定数据集的中间元素,与目标元素进行比较;
3. 如果中间元素等于目标元素,则返回其位置;
4. 如果中间元素大于目标元素,则在左半部分继续查找;
5. 如果中间元素小于目标元素,则在右半部分继续查找;
6. 重复以上步骤,直到找到目标元素或者确定目标元素不存在。
二分查找算法的优点是效率高,适用于大规模有序数据集的查找操作;缺点是要求数据集必须有序,且实现稍复杂。
数据结构中常见的查找算法
数据结构中常见的查找算法
在数据结构中,查找算法是一种常见且重要的算法,用于在给定数据集中查找特定元素的位置或信息。不同的查找算法适用于不同的数据结构和数据规模,各有优劣。本文将介绍数据结构中常见的查找算法,包括线性查找、二分查找、哈希查找和树结构查找。
一、线性查找
线性查找是最简单的查找算法之一,也称为顺序查找。它从数据集的第一个元素开始逐个比较,直到找到目标元素或遍历完整个数据集。线性查找适用于无序数据集,时间复杂度为O(n),其中n为数据集的大小。
线性查找的实现思路是遍历整个数据集,逐个比较目标元素与当前元素是否相等,如果相等则返回当前元素的位置,否则继续比较下一个元素。由于线性查找需要逐个比较,因此在大规模数据集中效率较低。
二、二分查找
二分查找是一种高效的查找算法,适用于有序数据集。它通过将数据集分成两部分并重复比较中间元素的方式,每次可以将查找范围缩小一半。二分查找的时间复杂度为O(log n),其中n为数据集的大小。
二分查找的实现思路是首先确定数据集的中间元素,然后将目标元素与中间元素进行比较,如果相等则返回位置,如果目标元素大于中间元素则在右半部分继续查找,反之在左半部分查找。通过不断缩小查找范围,最终可以找到目标元素或确定其不存在。
三、哈希查找
哈希查找是一种基于哈希表的查找算法,通过将元素的键映射到哈希表中的位置来实现快速查找。哈希查找的时间复杂度为O(1),是一种高效的查找算法。
哈希查找的实现思路是首先构建哈希表,将元素的键映射到哈希表的位置。当需要查找元素时,通过计算元素的哈希值快速定位到哈希表中的位置,然后比较元素是否相等。哈希查找适用于大规模数据集和需要频繁查找的场景。
数据结构 查找
low
( 08, ( 08, 14, 23, 23, 37, 37,
mid
46, 46, 55, 55, 68, 68, 79, 79,
high
91 ) 91 )
low
mid
14,
high=mid-1 high
low=mid+1
mid
( 08, 14, 23, 37, 46, 55, 68, 79, 91 )
生成二叉排序树过程。
10 3 2 7 8 18 12
注:二叉排序树与关键字排列顺序有关,排列顺 序不一样,得到的二叉排序树也不一样。
二叉排序树的建立的算法
反复调用二叉排序树的插入算法即可 Bitree Creat (int n) { //建立含有n个结点的二叉排序树
Bitree T= NULL;
for ( int i=1; i<=n; i++) {
8.3 动态查找表
特点
表结构在查找过程中动态生成。
要求
对于给定值 key, 若表中存在其关键字等于 key的记 录,则查找成功返回;否则插入关键字等于 key的记录。 动态查找表主要有二叉树结构和树结构两种类型。二 叉树结构有二叉排序树、平衡二叉树等。树结构有B-树、 B+树等。
8.3.1 二叉排序树
while(ST[i].key!=key)&&(i>=1)
数据结构-第9章 查找
图9.2 分块查找法示意图
最大关键字 起始地址
索 引 表 22 48 86 1 7 13
22 12 13 8
9
20 33 42 44 38 24 48 60 58 74 48 86 53
分块查找的基本过程:
⑴ 首先,将待查关键字K与索引表中的关键字 进行比较,以确定待查记录所在的块。具体 的可用顺序查找法或折半查找法进行。 ⑵ 进一步用顺序查找法,在相应块内查找关 键字为K的元素。 例如,在上述索引顺序表中查找38。首先,将 38与索引表中的关键字进行比较,因为22< 38≤48,所以36在第二个块中,进一步在第 二个块中顺序查找,最后在10号单元中找到 38。
图9.3 二叉排序树
(a)
二叉排序树示例1
若中序遍历,则可得到一个递增有序序列为:1, 2,3,4,5,6,7,8,9。
图9.3 二叉排序树
(b)
二叉排序树示例2(根据字符ASCII码的大小)
二叉排序树的结点结构说明
在下面讨论二叉排序树的操作中,使用二叉链 表作为存储结构,其结点结构说明如下: typedef struct node { KeyType key ; /*关键字的值*/ struct node *lchild,*rchild;/*左右指针*/ }BSTNode,*BSTree;
静态查找表 对查找表的查找仅是以查询为 目的,不改动查找表中的数据。 动态查找表 在查找的过程中同时插入不存 在的记录,或删除某个已存在的记录。
如何通过数据结构实现快速查找
如何通过数据结构实现快速查找
数据结构在计算机科学中起着至关重要的作用,其中快速查找是其中一个核心功能。通过合理选择和设计数据结构,可以实现高效的查找操作,提高程序的运行效率。本文将介绍如何通过数据结构实现快速查找,包括常用的数据结构及其查找算法。
一、哈希表
哈希表(Hash Table)是一种通过哈希函数来计算数据存储位置的数据结构,具有快速查找的特点。在哈希表中,每个元素都有一个对应的哈希值,通过哈希函数将元素映射到对应的位置。在查找时,只需通过哈希函数计算元素的哈希值,即可快速定位到元素所在的位置,从而实现快速查找。
哈希表的查找时间复杂度为O(1),即在平均情况下,查找一个元素的时间与数据规模无关,具有非常高的效率。然而,哈希表也存在一些缺点,如哈希冲突、空间利用率低等问题,需要通过合适的哈希函数和解决冲突的方法来优化。
二、二叉搜索树
二叉搜索树(Binary Search Tree)是一种基于二叉树结构的数据结构,具有快速查找的特点。在二叉搜索树中,每个节点的左子树中的所有节点的值均小于该节点的值,右子树中的所有节点的值均大于该节点的值。通过这种有序性,可以通过比较大小的方式快速定位到目标元素。
在二叉搜索树中,查找操作的时间复杂度取决于树的高度,平均
情况下为O(logn),最坏情况下为O(n)。为了提高查找效率,可以通
过平衡二叉搜索树(如AVL树、红黑树)来保持树的平衡,减少最坏
情况的发生。
三、堆
堆(Heap)是一种特殊的树形数据结构,常用于实现优先队列等场景。在堆中,每个节点的值都大于等于(或小于等于)其子节点的值,称
《数据结构-查找》课件
目录
引言查找算法的分类查找算法的性能分析查找算法的应用场景实践案例分析总结与展望
01
CHAPTER
引言
目的
介绍数据结构中的查找操作,包括各种查找算法的原理、时间复杂度、适用场景等。
背景
随着计算机技术的发展,数据结构在计算机科学中扮演着越来越重要的角色。查找作为数据结构中的基本操作之一,其性能的优劣直接影响到整个程序的效率。因此,理解和掌握查找算法对于计算机专业的学生来说至关重要。
哈希查找利用哈希表实现快速查找,通过将目标元素的关键字通过哈希函数转换成哈希值,快速定位到哈希表中对应的位置进行查找。
哈希表中的元素无序,但可以通过哈希函数保证元素唯一性。
时间复杂度:O(1),在最理想的情况下,如果哈希函数分布均匀且无冲突,哈希查找的时间复杂度可以达到O(1)。
03
CHAPTER
在许多应用场景中,我们需要快速地查找数据。如何设计高效的实时查找算法也是一个重要的研究方向。
实时查找
ห้องสมุดไป่ตู้
05
CHAPTER
实践案例分析
Python实现
定义一个函数,输入为待查找的列表和目标值。
如果找到目标值,返回该元素的索引;否则返回-1。
使用for循环遍历列表,逐个比较每个元素与目标值。
线性查找:从数据结构的一端开始,逐个检查每个元素,直到找到目标元素或检查完所有元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
查找成功
查找不成功 ——否则,称查找不成功(也应输出失败标志或失败位臵)
静态查找 ——只查找,不改变集合内的数据元素。
动态查找 ——既查找,又改变(增减)集合内的数据元素。 关键字 ——记录中某个数据项的值,可用来识别一个记录
( 预先确定的记录的某种标志 )
主关键字 ——可以唯一标识一个记录的关键字 次关键字 ——识别若干记录的关键字
{ // 若查找成功,则返回指向该数据元素结点的指针,
否则返回空指针
if ( (!T) || EQ(key,T—>data.key) )
// 查找结束
return(T);
else if LT(key,T—>data.key) // 在左子树中继续查找 return ( SearchBST(T—>lchild, key) ); else return ( SearchBST(T—>rchild, key) );
要求: 对于给定值key,若表中存在其关键字等于key的记录, 则查找成功返回; 否则插入关键字等于key 的记录。
典型的动态表———二叉排序树 一、二叉排序树的定义
二、二叉排序树的插入与删除
三、二叉排序树的查找分析
四、平衡二叉树
一、二叉排序树的定义
----或是一棵空树;或者是具有如下性质的非空二叉树: (1)左子树的所有结点均小于根的值; (2)右子树的所有结点均大于根的值; (3)它的左右子树也分别为二叉排序树。 练:下列2种图形中,哪个不是二叉排序树 ?
讨论② 查找效率怎样计算?
——用平均查找长度ASL衡量。
讨论③ 如何计算ASL?
分析: 查找第1个元素所需的比较次数为1; 查找第2个元素所需的比较次数为2; …… 查找第n个元素Baidu Nhomakorabea需的比较次数为n;
未考虑查找不成功的 情况:查找哨兵所需 的比较次数为n+1
总计全部比较次数为:1+2+…+n = (1+n)n/2 若求某一个元素的平均查找次数,还应当除以n(等概率), 即: ASL=(1+n)/2 ,时间效率为 O(n)
22 12 13 8
9 20 33 42 44 38 24 48 60 58 74 49 86 53
第1块
第2块
第3块
查找步骤分两步进行: ① 对索引表使用折半查找法(因为索引表是有序表); ② 确定了待查关键字所在的子表后,在子表内采用顺序 查找法(因为各子表内部是无序表); 查找效率:ASL=Lb+Lw
( a)
讨论:对(a)中序遍历后的结果是什么?
( b)
二、二叉排序树的查找、插入与删除
将数据元素构造成二叉排序树的优点: ① 查找过程与顺序结构有序表中的折半查找相似,查找效率高; ② 中序遍历此二叉树,将会得到一个关键字的有序序列(即实 现了排序运算); ③一个无序序列可以通过构造一棵二叉排序树而变成一个有序序 列,构造树的过程即为对无序序列进行排序的过程。 ④如果查找不成功,能够方便地将被查元素插入到二叉树的叶子 结点上,而且插入或删除时只需修改指针而不需移动元素。 ——这种既查找又插入的过程称为动态查找。 二叉排序树既有类似于折半查找的特性,又采用了链表存储, 它是动态查找表的一种适宜表示。 注:若数据元素的输入顺序不同,则得到的二叉排序树形态 也不同!
一、顺序查找(线性查找)
二、折半查找(二分或对分查找) 三、静态树表的查找 四、分块查找(索引顺序查找)
一、顺序查找( Linear search,又称线性查找 )
顺序查找:即用逐一比较的办法顺序查找关键字,这显然是最 直接的办法。 对顺序结构如何线性查找?见下页之例或教材P216; 对单链表结构如何线性查找?函数虽未给出,但也很容易 编写;只要知道头指针head就可以“顺藤摸瓜”; 对非线性树结构如何顺序查找?可借助各种遍历操作! (1)顺序表的机内存储结构: typedef struct { ElemType *elem; //表基址,0号单元留空。表容量为全部元素 int length; //表长,即表中数据元素个数 }SSTable;
折半查找举例: 已知如下11个元素的有序表: (05 13 19 21 37 56 64 75 80 88 92), 请查找关键字为21 和85的数据元素。
Low指向待查元素 所在区间的下界 mid指向待查元素所在 区间的中间位臵 high指向待查元素所 在区间的上界
解:① 先设定3个辅助标志: low,high,mid, 显然有:mid= (low+high)/2
数据结构课程的内容
第 9章
查找
9.1 基本概念
9.2 静态查找表 9.3 动态查找表 9.4 哈希表
教材第8、11和12章省略,因《操作系统》课程会涉及。
9.1 基本概念
查 找
是一种数据结构
查找表 ——由同一类型的数据元素(或记录)构成的集合。 ——查询(Searching)特定元素是否在表中。 ——若表中存在特定元素,称查找成功,应输出该记录;
这是查找成功的情况
讨论④ 顺序查找的特点: 优点:算法简单,且对顺序结构或链表结构均适用。 缺点: ASL 太长,时间效率太低。 如何改进?
二、折半查找(又称二分查找或对分查找)
这是一种容易想到的查找方法。 先给数据排序(例如按升序排好),形成有序表,然后再将key 与正中元素相比,若key小,则缩小至右半部内查找;再取其中 值比较,每次缩小1/2的范围,直到查找成功或失败为止。 对顺序表结构如何编程实现折半查找算法? ——见下页之例,或见教材(P219) 对单链表结构如何折半查找? ——无法实现!因全部元素的定位只能从头指针head开始 对非线性(树)结构如何折半查找? ——可借助二叉排序树来查找(属动态查找表形式)。
其中: n是文件记录个数; Pi是查找第i个记录的查找概率(通常取等概率,即Pi =1/n); Ci是找到第i个记录时所经历的比较次数。
物理意义:假设每一元素被查找的概率相同,则查找每 一元素所需的比较次数之总和再取平均,即为ASL。 显然,ASL值越小,时间效率越高。
9.2 静态查找表
静态查找表的抽象数据类型参见教材P216。 针对静态查找表的查找算法主要有:
// 在右子树中继续查找
} // SearchBST
Status SearchBST( BiTree T, KeyType key, BiTree f, BiTree &p) {
if (!T) { p = f;return FALSE;} // 查找不成功 else if EQ (key, T—>data.key) { p=T;return TRUE;} // 查找成功 else if LT (key, T—>data.key) return SearchBST(T—>lchild, key, T,p); // 在左子树中继续查找 else return SearchBST(T—>rchild, key, T, p); // 在右子树中继续查找 } // SearchBST
例如“学号”
例如“女”
讨论:
(1)查找的过程是怎样的?
给定一个值K,在含有n个记录的文件中进行搜索,寻找 一个关键字值等于K的记录,如找到则输出该记录,否则输出 查找不成功的信息。
(2)对查找表常用的操作有哪些?
查询某个“特定的”数据元素是否在表中; 查询某个“特定的”数据元素的各种属性; 在查找表中插入一元素; 从查找表中删除一元素。 查找方法取决于表中数据的排列方式;
② 运算步骤:
(1) low =1,high =11 ,mid =6 ,待查范围是 [1,11]; (2) 若 ST.elem[mid].key < key,说明 key[ mid+1,high] , 则令:low =mid+1;重算 mid= (low+high)/2;. (3) 若 ST.elem[mid].key > key,说明key[low ,mid-1], 则令:high =mid–1;重算 mid ; (4)若 ST.elem[ mid ].key = key,说明查找成功,元素序号=mid; 结束条件: (1)查找成功 : ST.elem[mid].key = key (2)查找不成功 : high<low (意即区间长度小于0)
全部比较总次数为1×20+2×21+3×22+4×23…+m×2m—1 =
三、分块查找(索引顺序查找)
这是一种顺序查找的另一种改进方法。 先让数据分块有序,即分成若干子表,要求每个子表中的数 值(用关键字更准确)都比后一块中数值小(但子表内部未必 有序)。 然后将各子表中的最大关键字构成一个索引表,表中还要包 含每个子表的起始地址(即头指针)。 例: 索引表 特点:块间有 48 86 最大关键字 22 序,块内无序 起始地址 1 7 13
return i; //若到达0号单元才结束循环,说明不成功,返回0值
(i=0)。成功时则返回找到的那个元素的位臵i。
} // Search_Seq
讨论① 查不到怎么办? ——返回特殊标志,例如返回空记录或空指针。前例中设立了“哨
兵”,就是将关键字送入末地址ST.elem[0].key使之结束并返回 i=0。
讨论1:二叉排序树的插入和查找操作 例:输入待查找的关键字序列=(45,24,53,45,12,24,90) 则生成二叉排序 树的过程为:
24 查 找 成 功, 返 回 查 找 成 功, 返 回
45 53
12
90
如果待查找的关键字序列输入顺序为: (24,53, 45,45,12,24,90), 则生成的二叉排 查 序树形态不同: 找
对索引表查找的ASL 对块内查找的ASL
n s ASLbs log 2 ( 1) s 2
n 1 (log2 n ASLbs ) 2
S为每块内部的记录个数,n/s即块的数目
例如当n=9,s=3时,ASLbs=3.5,而折半法为3.1,顺序法为5
9.3
动态查找表
特点: 表结构在查找过程中动态生成。
查 找 成 功, 返 回 24 12 45 53 90
成 功, 返 回
二叉排序树的查找&插入算法如何实现? 查找算法参见教材P228算法9.5(a);
插入算法参见教材P228算法9.5(b)_9.6;
一种“二合一”的算法如下:
BiTree SearchBST(BiTree T,KeyType key)
(2)算法的实现:
技巧:把待查关键字key存入表头或表尾(俗称“哨兵”), 这样可以加快执行速度。 例: 若将待查找的特定值key存入顺序表的首部(如0号单 元),则顺序查找的实现方案为:从后向前逐个比较!
int Search_Seq( SSTable ST , KeyType key ){
//在顺序表ST中,查找关键字与key相同的元素;若成功,返回其位 臵信息,否则返回0
―特定的”= 关键字
(3) 有哪些查找方法?
例如查字典
针对静态查找表和动态查找表的查找方法也有所不同。
(4)如何评估查找方法的优劣?
明确:查找的过程就是将给定的K值与文件中各记录的关键字 项进行比较的过程。所以用比较次数的平均值来评估算法的优 劣。称为平均查找长度(ASL:average search length)。 统计意义上的 数学期望值
讨论① 若关键字不在表中,怎样得知和停止?
——典型标志是:当查找范围的上界≤下界时停止查找。
讨论② 二分查找的效率(ASL)
推 导 过 程
1次比较就查找成功的元素有1个(20),即中间值; 2次比较就查找成功的元素有2个(21),即1/4处(或3/4)处; 3次比较就查找成功的元素有4个(22),即1/8处(或3/8)处… 4次比较就查找成功的元素有8个(23),即1/16处(或3/16)处… …… 则第m次比较时查找成功的元素会有(2m-1)个; 为方便起见,假设表中全部n个元素= 2m-1个,此时就不讨论第m 次比较后还有剩余元素的情况了。
ST.elem[0].key =key;
//设立哨兵,可免去查找过程中每一步 都要检测是否查找完毕。当n>1000时,查找时间将减少一半。
for( i=ST.length; ST.elem[ i ].key!=key; - - i );
//不要用for(i=n; i>0; - -i) 或 for(i=1; i<=n; i++)