数据结构——查找,顺序查找,折半查找
查找排序
解:① 先设定3个辅助标志: low,high,mid, 显然有:mid= (low+high)/2 ② 运算步骤:
(1) low =1,high =11 ,故mid =6 ,待查范围是 [1,11]; (2) 若 S[mid] < key,说明 key[ mid+1,high] , 则令:low =mid+1;重算 mid= (low+high)/2;. (3) 若 S[mid] > key,说明key[low ,mid-1], 则令:high =mid–1;重算 mid ; (4)若 S[ mid ] = key,说明查找成功,元素序号=mid; 结束条件: (1)查找成功 : S[mid] = key (2)查找不成功 : high<low (意即区间长度小于0)
while(low<=high)
{ mid=(low+high)/2; if(ST[mid].key= = key) return (mid); /*查找成功*/
else if( key< ST[mid].key) high=mid-1; /*在前半区间继续查找*/ else } return (0); /*查找不成功*/
4 5 6 7
0
1
2
90
10
(c)
20
40
K=90
80
30
60
Hale Waihona Puke 25(return i=0 )
6
讨论:怎样衡量查找效率?
——用平均查找长度(ASL)衡量。
如何计算ASL?
c语言数据结构查找算法大全
printf("This number does not exist in this array.\n");
else
printf("a[%d]=%d\n",p,x);
}
9.2.2 折半查找(二分查找)
使用折半查找必须具备两个前提条件:
(1)要求查找表中的记录按关键字有序(设,从小到大有序) (2)只能适用于顺序存储结构
}
※折半查找算法性能分析:
在折半查找的过程中,每经过一次比较,查找范围都要缩小一半,所 以折半查找的最大查找长度为
MSL=[log2 n]+1
当n足够大时,可近似的表示为log2(n)。可见在查找速度上,折半查找 比顺序查找速度要快的多,这是它的主要优点。
结论:折半查找要求查找表按关键字有序,而排序是一 种很费时的运算;另外,折半查找要求表是顺序存储的,为 保持表的有序性,在进行插入和删除操作时,都必须移动大 量记录。因此,折半查找的高查找效率是以牺牲排序为代价 的,它特别适合于一经建立就很少移动、而又经常需要查找 的线性表。
查找技术分为: 1 静态查找表技术 顺序查找、折半查找、索引顺序查找 2 动态查找表技术 二叉查找树 3哈希表技术 哈希表技术
※查找算法的衡量指标
在查找一个记录时所做的主要操作是关键字的比较, 所以通常把查找过程中对关键字的平均比较次数作为衡量 一个查找算法效率优劣的标准,并称平均比较次数为平均 查找长度(Average Search Length)。平均查找长度的 定义为:
high2=N-1;
/*N为查找表的长度,high2为块在表中的末地址*/
else
high2=ID[low1+1].addr-1;
数据结构第九章--查找-习题及答案
第九章查找一、选择题1•若查找每个记录的概率均等,则在具有n 个记录的连续顺序文件中采用顺序查找法查找一个记录,其平均查找长度ASL 为()。
A .(n-1)/2B.n/2C.(n+1)/2D.n 2. 下面关于二分查找的叙述正确的是()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,则应作()型调整以使其平衡。
数据结构资料 ppt课件
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
low mid high
直至low>high时,查找失败
1 2 3 4 5 6 7 8 9 10 11 5 13 19 21 37 56 64 75 80 88 92
if (L.elem[i]==e) return i+1; return 0;}
改进:把待查关键字key存入表头(“哨兵”), 从后向前逐个比较,可免去查找过程中每一步都要 检测是否查找完毕,加快速度。
int Search_Seq( SSTable ST , KeyType key ){ //若成功返回其位置信息,否则返回0 ST.R[0].key =key;
for( i=ST.length; ST.R[ i ].key!=key; - - i ); //不用for(i=n; i>0; - -i) 或 for(i=1; i<=n; i++) return i;
}
顺序查找的性能分析
• 空间复杂度:一个辅助空间。 • 时间复杂度: 1) 查找成功时的平均查找长度
n个数存在一维数组A[1..n]中,在进行顺序查找时, 这n个数的排列有序或无序其平均查找长度ASL不同。
查找概率相等时,ASL相同; 查找概率不等时,如果从前向后查找,则按查找概率 由大到小排列的有序表其ASL要比无序表ASL小。
折半查找
123456 5 13 19 21 37 56
若k==R[mid].key,查找成功 若k<R[mid].key,则high=mid-1 若k>R[mid].key,则low=mid+1
考研数据结构复习
路径长度:从一个结点到另一个结点路径上的分支数目;
结点的路径长度:从根到该结点的路径长度;
树的路径长度:树中所有叶子结点的路径长度之和;记为PL.
在结点数相同的条件下,完全二叉树是路径最短的二叉树
1
1
2
4
5
3 6
2
4
5
3 67
7
8
8
非完全二叉树 PL=10
完全二叉树PL=9
(路径最短的二叉树不唯一,不是完全二叉树,也可能路径长度最短)
a1
a2
ai-1 ai ai+1
an
头指针:存放线性链表中第一个结点的存储地址; 头结点:链表的第一个元素结点前的附加结点;
带头结点的线性链表:第一个元素结点前增加一个附加 结点的线性链表称为 带头结点的线性链表;
head是头指针
head
a1
a2
头结点
线性链表的每个结点中只有一个指针域
故也称为单链表
ai-
ai
ai+1
ann
1
空指针
例1、设一单向链表的头指针为head,链表的记录中 包含着整数类型的key域,试设计算法,将此链表的记录 按照key递增的次序进行就地排序。(不允许使用数组 做辅助存储)或将最小的数据移到链表的最前面。
例2、将单链表L1拆成二个链表,其中以L1为头的 链表保持原来向后的链接,另一个链表的头为L2, 其链接方向与L1相反,L1包含原链表的奇数序号的 节点,L2包含原链表的偶数序号的节点。
中序遍历序列: D,B,G,E,A,C,F
后序遍历(L R T)
若二叉树非空 (1)后序遍历左子树 (2)后序遍历右子树
(3)访问根结点
数据结构_查找原理及典型的查找算法
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. 顺序查找2. 折半查找3. Fibonacci4. 分块查找静态查找可以⽤线性表结构组织数据,这样可以使⽤顺序查找算法,再对关键字进⾏排序就可以使⽤折半查找或斐波那契查找等算法提⾼查找效率,平均查找长度:折半查找最⼩,分块次之,顺序查找最⼤。
顺序查找对有序⽆序表均适⽤,折半查找适⽤于有序表,分块查找要求表中元素是块与块之间的记录按关键字有序动态查找是数据集合需要添加删除元素的查找包括: 1. ⼆叉排序树 2. 平衡⼆叉树 3. 散列表 顺序查找适合于存储结构为顺序存储或链接存储的线性表。
顺序查找属于⽆序查找算法。
从数据结构线形表的⼀端开始,顺序扫描,依次将扫描到的结点关键字与给定值k相⽐较,若相等则表⽰查找成功 查找成功时的平均查找长度为: ASL = 1/n(1+2+3+…+n) = (n+1)/2 ; 顺序查找的时间复杂度为O(n)。
元素必须是有序的,如果是⽆序的则要先进⾏排序操作。
⼆分查找即折半查找,属于有序查找算法。
⽤给定值value与中间结点mid的关键字⽐较,若相等则查找成功;若不相等,再根据value 与该中间结点关键字的⽐较结果确定下⼀步查找的⼦表 将数组的查找过程绘制成⼀棵⼆叉树排序树,如果查找的关键字不是中间记录的话,折半查找等于是把静态有序查找表分成了两棵⼦树,即查找结果只需要找其中的⼀半数据记录即可,等于⼯作量少了⼀半,然后继续折半查找,效率⾼。
根据⼆叉树的性质,具有n个结点的完全⼆叉树的深度为[log2n]+1。
尽管折半查找判定⼆叉树并不是完全⼆叉树,但同样相同的推导可以得出,最坏情况是查找到关键字或查找失败的次数为[log2n]+1,最好的情况是1次。
时间复杂度为O(log2n); 折半计算mid的公式 mid = (low+high)/2;if(a[mid]==value)return mid;if(a[mid]>value)high = mid-1;if(a[mid]<value)low = mid+1; 折半查找判定数中的结点都是查找成功的情况,将每个结点的空指针指向⼀个实际上不存在的结点——外结点,所有外界点都是查找不成功的情况,如图所⽰。
数据结构顺序查找与折半查找
数据结构顺序查找与折半查找1,顺序查找顺序查找⼜称线性查找,它对顺序表和链表都适⽤。
(1)以下给出相关函数1 typedef struct{2 ElemType *elem; //元素存储空间地址,建表时按实际长度分配,0号单元留空3int TableLen; //表的长度4 }SSTable;5int Search_Seq(SSTable ST,ElemType key)6 {7 ST.elem[0]=key; //把要查找的关键字放在0号位置,称“哨兵”8for(int i=ST.TableLen;ST.elem!=key;i--) //从后往前找9 {10return i; //若表中不存在关键字为key的元素,将查找i=0时退出循环11 }12 }在上述算法中,将ST.elem[0]称为“哨兵”。
引⼊它的⽬的是使得Search_Seq内的循环不必判断数组是否会越界。
因为满⾜i=0时,循环⼀定会跳出。
除此之外,引⼊“哨兵”可以避免很多不必要的判断语句,从⽽提⾼算法的执⾏效率。
(2)算法效率分析当每个元素查找概率相同时,平均查找长度ASL=(n+1)/2, 查找不成功时,需要⽐较整个顺序表,所以⽐较次数时(n+1)次,从⽽顺序查找不成功的平均查找长度为(n+1)。
2.有序表的顺序查找(假设从⼩到⼤排列)有序表的顺序查找成功的平均查找长度与⼀般的线性表⼀样,即(n+1)/2.当查找失败时,待查找的元素为key,当查找第i个元素时,发现第i个元素的对应的关键字⼩于key,但第i+1个元素对应的关键字⼤于key,这时就可以返回查找失败的信息。
查找失败的平均查找长度为ASL=n/2+n/(n+1).3.折半查找前提:折半查找仅适⽤于有序的顺序表。
折半查找原理:将给定的key与中间元素⽐较,直到查到要找的元素。
以下是相关函数1int Binary_Search(SeqList L,ElemType key){2int low=0,high=L.TableLen-1,mid;//low指向表头,high指向表尾,mid中间值3while(low<=high)4 {5 mid=(low+high)/2;6if(L.elem[mid]==key) //中间值等于要查找元素7return mid;8else if(L.elem[mid]<key) //要查找元素在中间值右边9 low=mid+1;10else11 hign=mid-1; //要查找元素在中间值左边12 }13 }查找成功的时间复杂度为log2n,平均情况下⽐顺序查找效率⾼⼀些。
Java常见的七种查找算法
Java常见的七种查找算法1. 基本查找也叫做顺序查找,说明:顺序查找适合于存储结构为数组或者链表。
基本思想:顺序查找也称为线形查找,属于无序查找算法。
从数据结构线的一端开始,顺序扫描,依次将遍历到的结点与要查找的值相比较,若相等则表示查找成功;若遍历结束仍没有找到相同的,表示查找失败。
示例代码:public class A01_BasicSearchDemo1 {public static void main(String[] args){//基本查找/顺序查找//核心://从0索引开始挨个往后查找//需求:定义一个方法利用基本查找,查询某个元素是否存在//数据如下:{131, 127, 147, 81, 103, 23, 7, 79}int[] arr ={131,127,147,81,103,23,7,79};int number =82;System.out.println(basicSearch(arr, number));}//参数://一:数组//二:要查找的元素//返回值://元素是否存在public static boolean basicSearch(int[] arr,int number){//利用基本查找来查找number在数组中是否存在for(int i =0; i < arr.length; i++){if(arr[i]== number){return true;}}return false;}}2. 二分查找也叫做折半查找,说明:元素必须是有序的,从小到大,或者从大到小都是可以的。
如果是无序的,也可以先进行排序。
但是排序之后,会改变原有数据的顺序,查找出来元素位置跟原来的元素可能是不一样的,所以排序之后再查找只能判断当前数据是否在容器当中,返回的索引无实际的意义。
基本思想:也称为是折半查找,属于有序查找算法。
用给定值先与中间结点比较。
比较完之后有三种情况:•相等说明找到了•要查找的数据比中间节点小说明要查找的数字在中间节点左边•要查找的数据比中间节点大说明要查找的数字在中间节点右边代码示例:package com.itheima.search;public class A02_BinarySearchDemo1 {public static void main(String[] args){//二分查找/折半查找//核心://每次排除一半的查找范围//需求:定义一个方法利用二分查找,查询某个元素在数组中的索引//数据如下:{7, 23, 79, 81, 103, 127, 131, 147}int[] arr ={7,23,79,81,103,127,131,147};System.out.println(binarySearch(arr,150));}public static int binarySearch(int[] arr,int number){//1.定义两个变量记录要查找的范围int min =0;int max = arr.length-1;//2.利用循环不断的去找要查找的数据while(true){if(min > max){return-1;}//3.找到min和max的中间位置int mid =(min + max)/2;//4.拿着mid指向的元素跟要查找的元素进行比较if(arr[mid]> number){//4.1 number在mid的左边//min不变,max = mid - 1;max = mid -1;}else if(arr[mid]< number){//4.2 number在mid的右边//max不变,min = mid + 1;min = mid +1;}else{//4.3 number跟mid指向的元素一样//找到了return mid;}}}}3. 插值查找在介绍插值查找之前,先考虑一个问题:为什么二分查找算法一定要是折半,而不是折四分之一或者折更多呢?其实就是因为方便,简单,但是如果我能在二分查找的基础上,让中间的mid点,尽可能靠近想要查找的元素,那不就能提高查找的效率了吗?二分查找中查找点计算如下:mid=(low+high)/2, 即mid=low+1/2*(high-low);我们可以将查找的点改进为如下:mid=low+(key-a[low])/(a[high]-a[low])*(high-low),这样,让mid值的变化更靠近关键字key,这样也就间接地减少了比较次数。
《数据结构》习题集:第9章查找(第1次更新2019-5)
第9章查找一、选择题1.顺序查找一个共有n个元素的线性表,其时间复杂度为(),折半查找一个具有n个元素的有序表,其时间复杂度为()。
【*,★】A.O(n)B. O(log2n)C. O(n2)D. O(nlog2n)2.在对长度为n的顺序存储的有序表进行折半查找,对应的折半查找判定树的高度为()。
【*,★】A.nB.C.D.3.采用顺序查找方式查找长度为n的线性表时,平均查找长度为()。
【*】A.nB. n/2C. (n+1)/2D. (n-1)/24.采用折半查找方法检索长度为n的有序表,检索每个元素的平均比较次数()对应判定树的高度(设高度大于等于2)。
【**】A.小于B. 大于C. 等于D. 大于等于5.已知有序表(13,18,24,35,47,50,62,83,90,115,134),当折半查找值为90的元素时,查找成功的比较次数为()。
【*】A. 1B. 2C. 3D. 46.对线性表进行折半查找时,要求线性表必须()。
【*】A.以顺序方式存储B. 以链接方式存储C.以顺序方式存储,且结点按关键字有序排序D. 以链接方式存储,且结点按关键字有序排序7.顺序查找法适合于存储结构为()的查找表。
【*】A.散列存储B. 顺序或链接存储C. 压缩存储D. 索引存储8.采用分块查找时,若线性表中共有625个元素,查找每个元素的概率相同,假设采用顺序查找来确定结点所在的块时,每块应分()个结点最佳。
【**】A.10B. 25C. 6D. 6259.从键盘依次输入关键字的值:t、u、r、b、o、p、a、s、c、l,建立二叉排序树,则其先序遍历序列为(),中序遍历序列为()。
【**,★】A.abcloprstuB. alcpobsrutC. trbaoclpsuD. trubsaocpl10.折半查找和二叉排序树的时间性能()。
【*】A.相同B. 不相同11.一棵深度为k的平衡二叉树,其每个非终端结点的平衡因子均为0,则该树共有()个结点。
计算机数据结构知识点梳理 顺序查找法、折半查找法
typedef struct node{ int A[m];
//每个结点含有m个整数,本例m为5 struct node *next;
}LNode, *LinkList; typedef struct{
int j; //正整数在结点内的序号 LNode *s; //结点的指针 }rcd;
}
[题2]顺序存储的某线性表共有123个元素,按分块查找的要求等分为3块。若对索引 表采用顺序查找方法来确定子块,且在确定的子块中也采用顺序查找方法,则在等 概率的情况下,分块查找成功的平均查找长度为( )。
A.21
B. 23
C. 41
D. 62
分析:分块查找成功的平均查找长度为ASL=(s2+s+n)/2s。在本题中,n=123, s=123/3=41,故平均查找长度为23。
对表中每个数据元素的查找过程,可用二叉树来描述,称这个描述折半查找过 程的二叉树为判定树,表的中间结点是二叉树的根,左子表相当于左子树, 右子表相当于右子树。折半查找的过程是从根结点到待查找结点的过程,不 论查找成功或失败,查找长度均不超过树的高度,因此,如果有序表的长度 为n,那么在查找成功时与给定值进行比较的关键字个数至多为[㏒2n] +1。
4 、分块查找法
分块查找法要求将列表组织成以下索引顺序结构: (1)首先将列表分成若干个块(子表)。一般情况下,块的长度均匀, 最后一块 可以不满。每块中元素任意排列,即块内无序,但块与块之间有序。 (2)构造一个索引表。其中每个索引项对应一个块并记录每块的起始位置,以及每 块中的最大关键字(或最小关键字)。索引表按关键字有序排列。
假定将长度为n的表分成b块,且每块含s个元素,则b=n/s。又假定表中每个元素的查 找概率相等,则每个索引项的查找概率为1/b,块中每个元素的查找概率为1/s。
数据结构复习--排序和查找
数据结构复习--排序和查找现在正在学习查找和排序,为了节省时间提⾼效率,就正好边学习边整理知识点吧!知识点⼀:⼆分查找/折半查找1.⼆分查找的判定树(选择题)下列⼆叉树中,可能成为折半查找判定树(不含外部结点)的是: (4分)1.2.3.4.注:折半查找判定树是⼀棵⼆叉排序树,它的中序遍历结果是⼀个升序序列,可以在选项中的树上依次填上相应的元素。
虽然折半查找可以上取整也可以下取整但是⼀个查找判定树只能有⼀种取整⽅式。
如果升序序列是偶数个,那么终点应该偏左多右少。
在2选项中,由根节点左⼦树4个节点⽽右⼦树5个节点可以确定⽤的是向下取整策略,但是它的左⼦节点在左⼦树种对应的终点左边2个,右边个,明显是上取整策略,策略没有统⼀,所以是错的。
其他的选项类似分析。
2.⼆分查找法/折半查找法已知⼀个长度为16的顺序表L,其元素按关键字有序排列。
若采⽤⼆分查找法查找⼀个L中不存在的元素,则关键字的⽐较次数最多是: (2分)1. 72. 63. 54. 4 注:⼀次找到最边界的那⼀个树的情况下有最多次数 这个题中结点数16是个偶数:第⼀次(0+15)/2 7 第⼆次(8+15)/2 11第三次(12+15)/2 14 第四次(14+15)/2 14 第五次(15+15)/2 15(下取整的就向右计算求最多次数)第⼀次(0+15)/2 8 第⼆次(0+7)/2 4 第三次(0+3)/2 2 第四次(0+1)/2 0第五次(0+0)/2 0(下取整的话就向左求最多次数)若结点数是奇数15:第⼀次(0+14)/2 7 第⼆次( 0+6)/2 3 第三次(0+2)/2 1第四次(0+0)/2 0第⼀次(0+14)/2 7 第⼆次(8+14)/2 11 第三次(12+14)/2 13第四次(14+14)/2 0这时候向左或者向右都是OK的(因为得到的数都是能够被2整除的)但是划重点了折半查找⼀个有序表中不存在的元素,若向下取整,则要最多⽐较[log2n]+1次,若向上取整,则要最多⽐较[log2(n+1)],其实就是求树的深度.(这⼀块⾃⼰的说法可能不够准确,希望⼤家看到有问题的可以指出来)结合实际,我们⽤[log2n]+1来算更简单并且计算[log2n]要取整数,因为可能会存在不是满⼆叉树的情况。
C语言实现顺序表的顺序查找和折半查找
C语⾔实现顺序表的顺序查找和折半查找本⽂实例为⼤家分享了C语⾔实现顺序表的顺序查找和折半查找的具体代码,供⼤家参考,具体内容如下顺序查找:#include <iostream>using namespace std;int SeqSearch(int r[],int n,int k){r[0]=k;//下标0⽤作哨兵存放要查询的数int i=n;while(r[i]!=k)//不⽤判断下标i是否越界{i--;}return i;}int main(){int n;cout<<"请输⼊数组元素个数:"<<endl;cin>>n;int a[n+1];cout<<"请输⼊数组元素:"<<endl;for(int i=1;i<=n;i++){cin>>a[i];}int k;cout<<"请输⼊要查询的数:"<<endl;cin>>k;for(int i=1;i<=n;i++){cout<<a[i]<<" ";}cout<<endl;cout<<"该数在数组中的位置为:";cout<<SeqSearch(a,n,k);return 0;}折半查找:#include<iostream>using namespace std;int BinSearch1(int r[],int n,int k)//⾮递归{int low=1,high=n;//设置查找区间while(low<=high)//如果区间存在{int mid=(low+high)/2;if(k<r[mid])high=mid-1;//查找在左半区进⾏,回到while那⼀步else if(k>r[mid])low=mid+1;else return mid;}return 0;//如果区间不存在,则返回0,查找失败}int BinSearch2(int r[],int low,int high,int k)//递归{int mid=(low+high)/2;if(low>high) return 0;else{if(k<r[mid])BinSearch2(r,low,mid-1,k);else if(k>r[mid])BinSearch2(r,mid+1,high,k);else return mid;}}int main(){int n;cout<<"请输⼊数组元素个数:";cout<<endl;cin>>n;int a[n+1];cout<<"请输⼊数组元素:";cout<<endl;for(int i=1;i<=n;i++){cin>>a[i];}cout<<"请输⼊要查找的数:";cout<<endl;int k;cin>>k;cout<<"该数在数组中的位置是:"<<endl;cout<<BinSearch1(a,n,k);cout<<endl;cout<<BinSearch2(a,1,n,k);}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
数据结构查找与排序练习题答案——查找排序练习题答案
数据结构查找与排序练习题答案一、选择题1.对N个元素的表做顺序查找时,若查找每个元素的概率相同,则平均查找长度为( ) A.(N+1)/2 B. N/2 C. N D. [(1+N)*N ]/22.适用于折半查找的表的存储方式及元素排列要求为( )A.链接方式存储,元素无序 B.链接方式存储,元素有序C.顺序方式存储,元素无序D.顺序方式存储,元素有序3.当在一个有序的顺序存储表上查找一个数据时,即可用折半查找,也可用顺序查找,但前者比后者的查找速度( )A.必定快 B.不一定 C. 在大部分情况下要快 D. 取决于表递增还是递减4.有一个长度为12的有序表,按二分查找法对该表进行查找,在表内各元素等概率情况下查找成功所需的平均比较次数为()。
A.35/12 B.37/12 C.39/12 D.43/125.折半查找的时间复杂性为()A. O(n2)B. O(n)C. O(nlogn)D. O(logn)6.对有18个元素的有序表作折半查找,则查找A[3]的比较序列的下标为()A.1,2,3B.9,5,2,3C.9,5,3D.9,4,2,37.设有序表的关键字序列为{1,4,6,10,18,35,42,53,67,71,78,84,92,99},当用二分查找法查找健值为84的结点时,经()次比较后查找成功。
A.2B. 3C. 4D.128.用n个键值构造一棵二叉排序树,最低高度为()A.n/2B.、nC.lognD.logn+19.分别以下列序列构造二叉排序树,与用其它三个序列所构造的结果不同的是( ) 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.设有一组记录的关键字为{19,14,23,1,68,20,84,27,55,11,10,79},用链地址法构造散列表,散列函数为H(key)=key% 13,散列地址为1的链中有()个记录。
数据结构(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。
《数据结构》课程教案
《数据结构》课程教案课程类别:专业基础课合用专业:计算机应用技术授课学时:32 学时课程学分:4 学分一、课程性质、任务课程性质:《数据结构》是计算机应用技术专业的必修课程,也是研究如何对数据进行组织和设计、如何编制高效率的处理程序的一门基础学科。
课程任务:1、学习计算机程序编写中的数据组织和设计;2、数据的物理结构和逻辑结构;3、经典算法的设计和算法效率的分析。
二、课程培养目标:(一)知识目标通过理论学习和程序的编写,使学生系统地掌握程序中数据的组织、数据的物理结构和逻辑结构,在重要算法的实现上逐步提高编程能力。
(二)技能目标通过课程的学习,让学生掌握重要的数据结构,对数据的逻辑结构和物理结构有深入的理解,同时能编写出使用重要算法知识的程序,并运用所学知识编写程序解决实际中的问题。
(三)素质目标通过课程的学习,让学习学会自学,培养学生的自学能力、克服学习艰难的能力,同时让学生掌握计算机编程中数据结构的学习方法,并养成严谨、认真、子细、塌实、上进的好习惯。
三、选用教材与参考资料教材版本信息《数据结构与算法简明教程(Java 语言版)》清华大学出版社叶小平陈瑛主编教材使用评价本教材经过两年的使用,得到了读者一致认可,同时也在不断改进,适合高职高专教学使用,内容基础、重难点突出,符合高职高专“理论够用、注重实践”的要求。
选用的参考资料严蔚敏.吴伟民《数据结构(C 语言版)》.清华大学出版社.2022 年版殷人昆. 《数据结构》 .清华大学出版社.1999 年版《C 语言程序设计》 .石油大学出版社《C 语言程序设计》 .中国石油大学出版社.2022 年版四、本课程与其他课程的联系与分工先修课程《离散数学》、《程序设计基础》后续课程《面向对象技术》、《操作系统》与其他课程配合与取舍情况《数据结构》与《离散数学》知识点结合较多,《离散数学》讲求逻辑思维能力的培养和训练,《数据结构》中逻辑结构的学习也需要逻辑思维能力做铺垫。
数据结构50:二分查找法(折半查找法)
数据结构50:⼆分查找法(折半查找法)折半查找,也称⼆分查找,在某些情况下相⽐于顺序查找,使⽤折半查找算法的效率更⾼。
但是该算法的使⽤的前提是静态查找表中的数据必须是有序的。
例如,在{5,21,13,19,37,75,56,64,88 ,80,92}这个查找表使⽤折半查找算法查找数据之前,需要⾸先对该表中的数据按照所查的关键字进⾏排序:{5,13,19,21,37,56,64,75,80,88,92}。
在折半查找之前对查找表按照所查的关键字进⾏排序的意思是:若查找表中存储的数据元素含有多个关键字时,使⽤哪种关键字做折半查找,就需要提前以该关键字对所有数据进⾏排序。
折半查找算法对静态查找表{5,13,19,21,37,56,64,75,80,88,92}采⽤折半查找算法查找关键字为 21 的过程为:图 1 折半查找的过程(a)如上图 1 所⽰,指针 low 和 high 分别指向查找表的第⼀个关键字和最后⼀个关键字,指针 mid 指向处于 low 和 high 指针中间位置的关键字。
在查找的过程中每次都同 mid 指向的关键字进⾏⽐较,由于整个表中的数据是有序的,因此在⽐较之后就可以知道要查找的关键字的⼤致位置。
例如在查找关键字 21 时,⾸先同 56 作⽐较,由于21 < 56,⽽且这个查找表是按照升序进⾏排序的,所以可以判定如果静态查找表中有 21这个关键字,就⼀定存在于 low 和 mid 指向的区域中间。
因此,再次遍历时需要更新 high 指针和 mid 指针的位置,令 high 指针移动到 mid 指针的左侧⼀个位置上,同时令 mid 重新指向 low 指针和 high 指针的中间位置。
如图 2 所⽰:图 2 折半查找的过程(b)同样,⽤ 21 同 mid 指针指向的 19 作⽐较,19 < 21,所以可以判定 21 如果存在,肯定处于 mid 和 high 指向的区域中。
所以令 low 指向 mid 右侧⼀个位置上,同时更新 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,则应作( ) 型调整以使其平衡。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验五查找的应用一、实验目的:1、掌握各种查找方法及适用场合,并能在解决实际问题时灵活应用。
2、增强上机编程调试能力。
二、问题描述1.分别利用顺序查找和折半查找方法完成查找。
有序表(3,4,5,7,24,30,42,54,63,72,87,95)输入示例:请输入查找元素:52输出示例:顺序查找:第一次比较元素95第二次比较元素87 ……..查找成功,i=**/查找失败折半查找:第一次比较元素30第二次比较元素63 …..2.利用序列(12,7,17,11,16,2,13,9,21,4)建立二叉排序树,并完成指定元素的查询。
输入输出示例同题1的要求。
三、数据结构设计(选用的数据逻辑结构和存储结构实现形式说明)(1)逻辑结构设计顺序查找和折半查找采用线性表的结构,二叉排序树的查找则是建立一棵二叉树,采用的非线性逻辑结构。
(2)存储结构设计采用顺序存储的结构,开辟一块空间用于存放元素。
(3)存储结构形式说明分别建立查找关键字,顺序表数据和二叉树数据的结构体进行存储数据四、算法设计(1)算法列表(说明各个函数的名称,作用,完成什么操作)序号 名称 函数表示符 操作说明1 顺序查找 Search_Seq 在顺序表中顺序查找关键字的数据元素2 折半查找 Search_Bin 在顺序表中折半查找关键字的数据元素3 初始化 Init 对顺序表进行初始化,并输入元素4 树初始化 CreateBST 创建一棵二叉排序树5 插入 InsertBST 将输入元素插入到二叉排序树中6 查找 SearchBST在根指针所指二叉排序树中递归查找关键字数据元素 (2)各函数间调用关系(画出函数之间调用关系)typedef struct { ElemType *R; int length;}SSTable;typedef struct BSTNode{Elem data; //结点数据域 BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree; typedef struct Elem{ int key; }Elem;typedef struct {int key;//关键字域}ElemType;(3)算法描述int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
若找到,则函数值为//该元素在表中的位置,否则为0int c=1,i;for (i=ST.length; i>=0; --i){printf("第%d次比较元素%d\n",c++,ST.R[i-1].key);if (ST.R[i-1].key==key)//从后往前找return i;}return 0;}// Search_Seqint Search_Bin(SSTable ST,int key){// 在有序表ST中折半查找其关键字等于key的数据元素。
若找到,则函数值为// 该元素在表中的位置,否则为0int low=0,high=ST.length,i=1; //置查找区间初值int mid;while(low<=high){mid=(low+high) / 2;printf("......第%d次比较元素%d\n",i++,ST.R[mid].key);if (key==ST.R[mid].key)return mid; //找到待查元素else if (key<ST.R[mid].key)high = mid -1; //继续在前一子表进行查找else low =mid +1; //继续在后一子表进行查找 }return 0; //表中不存在待查元素}//初始化顺序表void Init(SSTable &W){int i=0,max;W.R=(ElemType *)malloc(100*sizeof(ElemType));printf("有序表3,4,5,7,24,30,42,54,63,72,87,95\n");printf("输入顺序表元素个数:\n");scanf("%d",&max);printf("依次输入顺序表元素\n");while(i!=max){i++;scanf("%d",&W.R[i-1].key);}W.length=max;}//*************************************插入二叉排序树T中void InsertBST(BSTree &T,int e){if(T==NULL){T=new BSTNode;T->data.key=e;T->lchild=NULL;T->rchild=NULL;}else if(T->data.key>e){InsertBST(T->lchild,e);}elseInsertBST(T->rchild,e);}//**********************二叉排序树的创建void CreateBST(BSTree &T ){//依次读入一个关键字为key的结点,将此结点插入二叉排序树T中T=NULL;int e,i=1,max;printf("输入的个数为:");scanf("%d",&max);while(i<=max){printf("输入第%d个数:",i++);scanf("%d" ,&e);InsertBST(T, e); //将此结点插入二叉排序树T中}//while}//CreatBST//*********************二叉排序树的递归查找BSTree SearchBST(BSTree T,char key){//在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素//若查找成功,则返回指向该数据元素结点的指针,否则返回空指针if(T)printf("第%d次查询:%d\n",N++,T->data.key);if((!T)|| key==T->data.key)return T; //查找结束else if(key<T->data.key)return SearchBST(T->lchild,key); //在左子树中继续查找elsereturn SearchBST(T->rchild,key); //在右子树中继续查找}五、调试记录(调试过程中遇到的主要问题,是如何解决的,对设计和编码的回顾讨论和分析;改进设想等)调试中出现了几次程序查找失败的情况,究其原因,是奇数个元素的时候,二分查找未定义好,在后续改进之后,程序能实现预期的效果六、运行说明(列出测试结果,包括输入和输出。
这里的测试数据应该完整和严格,最好多于示例中所列数据)以下附上源代码:#include<stdio.h>#include<stdlib.h>#include<string.h>int N;typedef struct{int key;//关键字域}ElemType;typedef struct Elem{int key;}Elem;typedef struct BSTNode{Elem data; //结点数据域BSTNode *lchild,*rchild; //左右孩子指针}BSTNode,*BSTree;typedef struct{ElemType *R;int length;}SSTable;int Search_Seq(SSTable ST, int key){//在顺序表ST中顺序查找其关键字等于key的数据元素。
若找到,则函数值为//该元素在表中的位置,否则为0int c=1,i;for (i=ST.length; i>=0; --i){printf("第%d次比较元素%d\n",c++,ST.R[i-1].key);if (ST.R[i-1].key==key)//从后往前找return i;}return 0;}// Search_Seqint Search_Bin(SSTable ST,int key){// 在有序表ST中折半查找其关键字等于key的数据元素。
若找到,则函数值为// 该元素在表中的位置,否则为0int low=0,high=ST.length,i=1; //置查找区间初值int mid;while(low<=high){mid=(low+high) / 2;printf("......第%d次比较元素%d\n",i++,ST.R[mid].key);if (key==ST.R[mid].key)return mid; //找到待查元素else if (key<ST.R[mid].key)high = mid -1; //继续在前一子表进行查找else low =mid +1; //继续在后一子表进行查找 }return 0; //表中不存在待查元素}//初始化顺序表void Init(SSTable &W){int i=0,max;W.R=(ElemType *)malloc(100*sizeof(ElemType));printf("有序表3,4,5,7,24,30,42,54,63,72,87,95\n");printf("输入顺序表元素个数:\n");scanf("%d",&max);printf("依次输入顺序表元素\n");while(i!=max){i++;scanf("%d",&W.R[i-1].key);}W.length=max;}//*************************************插入二叉排序树T中void InsertBST(BSTree &T,int e){if(T==NULL){T=new BSTNode;T->data.key=e;T->lchild=NULL;T->rchild=NULL;}else if(T->data.key>e){InsertBST(T->lchild,e);}elseInsertBST(T->rchild,e);}// **********************二叉排序树的创建void CreateBST(BSTree &T ){//依次读入一个关键字为key的结点,将此结点插入二叉排序树T中T=NULL;int e,i=1,max;printf("输入的个数为:");scanf("%d",&max);while(i<=max){printf("输入第%d个数:",i++);scanf("%d" ,&e);InsertBST(T, e); //将此结点插入二叉排序树T中}//while}//CreatBST//*********************二叉排序树的递归查找BSTree SearchBST(BSTree T,char key){//在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素//若查找成功,则返回指向该数据元素结点的指针,否则返回空指针if(T)printf("第%d次查询:%d\n",++N,T->data.key);if((!T)|| key==T->data.key)return T; //查找结束else if(key<T->data.key)return SearchBST(T->lchild,key); //在左子树中继续查找elsereturn SearchBST(T->rchild,key); //在右子树中继续查找}void main(){int N=1;printf("****************查找实验*****************\n");SSTable W;int t,i,a;while(1){printf("*****功能:1--顺序、二分查找 2--二分查找\n");scanf("%d",&a);switch(a){case 1:Init(W);printf("****************有序表的顺序查找*****************\n");printf("请输入查找元素\n");scanf("%d",&t);if(i=Search_Seq(W, t))printf("位置在第 %d位\n",i);elseprintf("不存在\n");printf("****************有序表的二分查找*****************\n");if(i=Search_Bin(W,t)+1)printf("位置在第%d位\n",i);elseprintf("不存在\n");break;case 2:printf("***利用序列(12,7,17,11,16,2,13,9,21,4)建立二叉排序树,并完成指定元素的查询***********\n");BSTree T ;int x;CreateBST(T);printf("输入查询元素:");scanf("%d",&x);if(SearchBST(T,x) )printf("查询成功");else printf("查询失败");break;}}}。