折半查找法

合集下载

折半查找程序

先看看这个，下面有例子折半查找：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。

重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

算法要求算法复杂度下面提供一段二分查找实现的伪代码:BinarySearch(max,min,des)mid-<(max+min)/2while(min<=max)mid=(min+max)/2if mid=des thenreturn midelseif mid >des thenmax=mid-1elsemin=mid+1return max折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。

它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。

如果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。

如果x>a[n/2]，则我们只要在数组a的右半部继续搜索x。

二分查找法一般都存在一个临界值的BUG，即查找不到最后一个或第一个值。

可以在比较到最后两个数时，再次判断到底是哪个值和查找的值相等。

C语言代码int BinSearch(SeqList * R，int n , KeyType K ){ //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1int low=0，high=n-1，mid；//置当前查找区间上、下界的初值if(R[low].key==K){return low ;}if(R[high].key==k)return high;while(low<=high){ //当前查找区间R[low..high]非空mid=low+((high-low)/2)；//使用(low + high) / 2 会有整数溢出的问题（问题会出现在当low + high的结果大于表达式结果类型所能表示的最大值时，这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题if(R[mid].key==K){return mid；//查找成功返回}if(R[mid].key>K)high=mid-1; //继续在R[low..mid-1]中查找elselow=mid+1；//继续在R[mid+1..high]中查找}if(low>high)return -1；//当low>high时表示查找区间为空，查找失败} //BinSeareh折半查找程序举例程序要求：1.在main函数中定义一个20个元素的int数组，完成初始化和显示操作。

折半查找法c语言

折半查找法c语言折半查找法，又称二分查找法，是一种在有序数据集（顺序表/列表、数组等）中，快速查找指定值的高效算法。

折半查找法的思想是基于二分法思想，用“分而治之”的思想来快速查找指定值。

折半查找法是一种最常用的查找方法，它也被称为是一种“有序”查找，因为要查找的数据必须是已经排好序的。

实际上，折半查找法的实现只要将有序的数据列折半，一次比较即可将待查找的值与被折半的数据列比较，这样查找的过程会比较快捷。

下面就来介绍折半查找法的具体实现方式：折半查找法假设要查找的数据是一个有序数列，在这里以升序数列为例：（1）先定义一个指向待查找序列低位的索引，称之为low；（2）定义另一个指向待查找序列高位的索引，称之为high；（3）首先用low与high计算中位索引 mid，将这个中位索引处的值与要查找的数据进行比较，如果相等，则搜索成功；（4）如果不等，则根据要查找的数据与中位索引处的值的比较结果，将待查找的序列分为两部分，下次查找只要在其中一部分序列中继续进行折半查找即可。

有了上面的思路，我们就可以用c语言来实现折半查找法了。

代码如下：#include<stdio.h>int binary_search(int arr[], int n, int key){int low, mid, high;low = 0;high = n-1;while(low <= high){mid = (low + high) / 2;if(arr[mid] == key)return mid;else if(arr[mid] > key)high = mid - 1;elselow = mid + 1;}return -1;}int main(){int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int res = binary_search(arr, 10, 7);printf(res = %d res);return 0;}以上就是一个最基本的折半查找法的实现，通过定义一个low、high和mid三个索引，在计算中位索引mid时，low和high 分别指向有序数列的低位和高位，根据判断条件，如果要查找的值等于中位索引处的数据，则查找成功，否则就用待查找的数据与中位索引处的数据进行比较，来确定下一次查找的范围。

折半查找法

二分查找是在我们整个数据结构当中一个比较重要的算法，它的思想在我们的实际开发过程当中应用得非常广泛。

在实际应用中，有些数据序列是已经经过排序的，或者可以将数据进行排序，排序后的数据我们可以通过某种高效的查找方式来进行查找，今天要讲的就是折半查找法(二分查找)，它的时间复杂度为O(logn)，将以下几个方面进行概述了解二分查找的原理与思想分析二分查找的时间复杂度掌握二分查找的实现方法了解二分查找的使用条件和场景1 二分查找的原理与思想在上一个章节当中，我们学习了各种各样的排序的算法，接下来我们就讲解一下针对有序集合的查找的算法—二分查找（Binary Search、折半查找）算法，二分查找呢，是一种非常容易懂的查找算法，它的思想在我们的生活中随处可见，比如说：同学聚会的时候喜欢玩一个游戏——猜数字游戏，比如在1-100以内的数字，让别人来猜从，猜的过程当中会被提示是猜大了还是猜小了，直到猜中为止。

这个过程其实就是二分查找的思想的体现，这是个生活中的例子，在我们现实开发过程当中也有很多应用到二分查找思想的场景。

比如说仙现在有10个订单，它的金额分别是6、12 、15、19、24、26、29、35、46、67 请从中找出订单金额为15的订单，利用二分查找的思想，那我们每一次都会与中间的数据进行比较来缩小我们查找的范围，下面这幅图代表了查找的过程，其中low，high代表了待查找的区间的下标范围，mid表示待查找区间中间元素的下标（如果范围区间是偶数个导致中间的数有两个就选择较小的那个）第一次二分查找第二次二分查找第三次二分查找通过这个查找过程我们可以对二分查找的思想做一个汇总：二分查找针对的是一个有序的数据集合，查找思想有点类似于分治思想。

每次都通过跟区间的中间元素对比，将待查找的区间范围缩小为原来的一半，直到找到要查找的元素，或者区间被缩小为0。

一：查找的数据有序二：每次查找，数据的范围都在缩小，直到找到或找不到为止。

折半查找的判定树的构造方法

折半查找的判定树的构造方法折半查找，也被称为二分查找，是一种在有序数组中查找特定元素的算法。

构造折半查找的判定树可以帮助理解算法的执行过程。

下面是关于构造折半查找判定树的50条方法，并且会对每一条进行详细描述。

1. 在有序数组中选择中间元素作为根节点。

构造方法详解：我们在有序数组中选择中间元素作为根节点。

这个中间元素是数组中间位置的值。

这一步是构造判定树的第一步，因为它将分割数组成左右两个子数组。

2. 在根节点的左侧选择一个中间元素作为左子树的根节点。

构造方法详解：在根节点的左侧选择一个中间元素，作为左子树的根节点。

这个中间元素是根节点左侧子数组的中间位置的值。

这一步扩展了判定树，使得左侧的子数组也可以进行折半查找。

3. 在根节点的右侧选择一个中间元素作为右子树的根节点。

构造方法详解：同样地，在根节点的右侧选择一个中间元素，作为右子树的根节点。

这个中间元素是根节点右侧子数组的中间位置的值。

这一步扩展了判定树，使得右侧的子数组也可以进行折半查找。

4. 重复以上过程，依次构造左右子树。

构造方法详解：依次对左右子树进行重复的选择中间元素作为子树的根节点的过程。

这样不断地构造子树，直到数组中的每个元素都被考虑到。

5. 当子数组中只剩下一个元素时，将其作为叶子节点添加到判定树中。

构造方法详解：当子数组中只剩下一个元素时，将其作为叶子节点添加到判定树中。

这表示整个有序数组的判定树构造完成。

因为此时的子数组不再能够被分割，所以将其作为叶子节点。

6. 对每个子数组的根节点和叶子节点进行连接，构成完整的判定树结构。

构造方法详解：对每个子数组的根节点和叶子节点进行连接，构成完整的判定树结构。

这意味着将每个子数组的根节点和叶子节点沿着判定树的路径连接起来，形成一棵完整的树结构。

7. 确定根节点、左右子树的取值范围，并进行标记。

构造方法详解：对于每个节点，包括根节点和叶子节点，需要确定其对应的子数组的取值范围，并进行标记。

c语言折半查找法代码

c语言折半查找法代码折半查找法，也称二分查找法，是一种高效的查找算法。

它的基本思想是将有序数组分成两部分，通过比较中间元素和目标元素的大小关系，来确定目标元素在哪一部分中，然后再在该部分中继续进行查找，直到找到目标元素或者确定目标元素不存在为止。

下面是C语言实现折半查找法的代码：```#include <stdio.h>int binarySearch(int arr[], int left, int right, int target) {while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {return mid;} else if (arr[mid] < target) {left = mid + 1;} else {right = mid - 1;}}return -1;}int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13, 15};int n = sizeof(arr) / sizeof(arr[0]);int target = 7;int index = binarySearch(arr, 0, n - 1, target);if (index == -1) {printf("目标元素不存在\n");} else {printf("目标元素在数组中的下标为：%d\n", index);}return 0;}```在上面的代码中，binarySearch函数接收四个参数：数组arr、左边界left、右边界right和目标元素target。

它通过while循环不断缩小查找范围，直到找到目标元素或者确定目标元素不存在为止。

其中，mid表示当前查找范围的中间位置，通过比较arr[mid]和target的大小关系来确定目标元素在哪一部分中。

具有12个关键字的有序表,折半查找的平均查找长度

具有12个关键字的有序表,折半查找的平均查
找长度
折半查找是一种在有序序列中查找某个给定值的方法，它是一种加速搜索的算法，并且有着高效、可靠的特点，在每次搜索次数减半的情况下，无论序列的长度多大，其查找代价是固定的，能大大减少存储器和 CPU 占用，节省时间和空间。

折半查找时，先取出中间位置记录，将查找值和中间位置记录进行比较，子表长度缩小，重复上述查找操作，直到找到等于查找值的记录，或子表不存在为止。

如果有12个关键字的有序表，用折半查找方法来查找，那么平均查找长度(ASL)是[log2(n)]+1=4。

从0开始计数，折半查找找到元素最多需要3步：第一步，查找中间位置的元素；第二步，比较查找元素与中间位置的元素的大小，如果查找元素小于中间位
置的元素，就在中间位置的左半边的子序列中继续查找；如果查找元素大于中间位置的元素，就在中间位置的右半边的子序列中继续查找；第三步，不断进行折半查找，直到找到查找元素，或者查找范围为空，则查找失败，结束。

总的来说，折半查找是一种非常有效的搜索算法
它可以在有序表中大大加快搜索速度，在12个关键字有序表中，折半查找的平均查找长度是4，在节省时间和空间的同时，能够很好地用于搜索、匹配等需要的操作中。

二分法的算法描述

二分法的算法描述
二分法算法描述
二分法是一种常用的算法，也称为折半查找法。

它的基本思想是将一个有序的数组分成两个部分，然后判断目标值在哪个部分，再在该部分中继续进行查找，直到找到目标值或者确定目标值不存在为止。

二分法的算法描述如下：
1. 首先，确定数组的左右边界，即左边界为0，右边界为数组长度减1。

2. 然后，计算出数组的中间位置，即中间位置为左右边界之和除以2。

3. 接着，判断目标值与中间位置的值的大小关系，如果目标值小于中间位置的值，则在左半部分继续查找，否则在右半部分继续查找。

4. 如果目标值等于中间位置的值，则直接返回中间位置。

5. 如果左右边界相遇，但是目标值仍未找到，则说明目标值不存在，返回-1。

6. 如果目标值在左半部分，则将右边界设为中间位置减1，继续执行步骤2。

7. 如果目标值在右半部分，则将左边界设为中间位置加1，继续执行步骤2。

二分法的时间复杂度为O(log n)，比线性查找的时间复杂度O(n)要快得多。

因此，在需要查找有序数组中的元素时，二分法是一种非常高效的算法。

二分法的应用场景很多，例如在搜索引擎中，可以使用二分法来查找关键词在文档中的位置；在游戏中，可以使用二分法来查找玩家的位置等等。

二分法是一种非常实用的算法，可以大大提高查找效率，值得我们在编程中多加应用。

二分查找算法(折半查找算法)

二分查找算法（折半查找算法）
二分查找算法也称折半查找算法，是在有序数组中查询其中一特定元
素的算法。

它的基本思想是：将数组中间位置的元素与要查找的元素比较，如果两者相等，则查找成功；如果要查找的元素小于中间位置元素，则在
数组的前半部分查找；如果要查找的元素大于中间位置元素，则在数组的
后半部分查找。

它采用分而治之的思想，基于这个思想，将一个庞大的问题划分成规
模较小的子问题分别解决，然后将子问题的解组合起来构成原问题的解。

具体而言，就是将要查找的元素(也就是目标值)与数组的元素对比，每次
都只比较一部分，直到确定位置，也就是找到目标值，此时查询结束。

实现二分查找算法的基本步骤如下：
（1）首先，从有序数组的中间元素开始，将中间元素与要查找的元
素进行比较；
（2）如果查找的元素正好是中间元素，则查找成功；
（3）如果查找的元素小于中间元素，则在数组的前半部分查找；
（4）如果查找的元素大于中间元素，则在数组的后半部分查找；
（5）重复上面的步骤，直到查找到指定的元素或者查找范围为空为止。

二分查找法的要求

二分查找法，也称为折半查找法，是一种在有序数组中查找特定元素的算法。

它的要求如下：
1. 数组必须是有序的：二分查找法只能在有序数组中进行查找，如果数组无序，需要先进行排序。

2. 数组必须是静态的：二分查找法适用于静态数组，即不会频繁插入或删除元素的数组。

如果数组需要频繁修改，建议使用其他数据结构。

3. 数组元素必须可比较：二分查找法依赖于元素之间的比较操作，因此数组元素必须支持比较操作。

对于自定义类型的元素，需要实现比较操作符。

4. 查找范围必须确定：二分查找法需要明确查找范围的起始和结束位置，通常使用两个指针来表示。

5. 查找范围必须缩小：二分查找法通过不断缩小查找范围来逼近目标元素，直到找到目标元素或确定目标元素不存在。

总结起来，二分查找法的要求是有序数组、静态数组、可比较元素、确定查找范围和缩小查找范围。

折半查找

折半查找算法思想：将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。

通过一次比较，将查找区间缩小一半。

折半查找是一种高效的查找方法。

它可以明显减少比较次数，提高查找效率。

但是，折半查找的先决条件是查找表中的数据元素必须有序。

算法步骤描述：step1 首先确定整个查找区间的中间位置mid = （left + right ）/ 2step2 用待查关键字值与中间位置的关键字值进行比较；若相等，则查找成功若大于，则在后（右）半个区域继续进行折半查找若小于，则在前（左）半个区域继续进行折半查找Step3 对确定的缩小区域再按折半公式，重复上述步骤。

最后，得到结果：要么查找成功，要么查找失败。

折半查找的存储结构采用一维数组存放。

折半查找算法举例对给定数列（有序）{ 3，5，11，17，21，23，28，30，32，50}，按折半查找算法，查找关键字值为30的数据元素。

折半查找的算法讨论：优点: ASL≤log2n，即每经过一次比较,查找范围就缩小一半。

经log2n 次计较就可以完成查找过程。

缺点：因要求有序，所以要求查找数列必须有序，而对所有数据元素按大小排序是非常费时的操作。

另外，顺序存储结构的插入、删除操作不便利。

#include <iostream>using namespace std;int Find_Half_Line(int low,int high,int Find_Name,int a[])...{while(low <= high)...{int mid = (low + high)/2;if(a[mid] == Find_Name) //如果相等则返回return mid;elseif(Find_Name > a[mid]) //大于查找值最低的值变为折半中间的值low =mid+1;else high=mid-1; //小于最大值变为中间值}return -1;}int main()...{int Find_Name;int low=0,high=9;int a[10]=...{2,3,5,8,10,12,15,17,19,20};cin >> Find_Name;cout <<Find_Half_Line(low,high,Find_Name,a);return 0;}插入排序插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。

c语言使用折半查找法的示例代码

c语言使用折半查找法的示例代码C语言使用折半查找法的示例代码1. 引言折半查找法（Binary Search）是一种常用的查找算法，它通过将有序数组分成两半的方式快速定位要查找的元素。

在本文中，我们将探讨C语言中如何实现折半查找的算法，并提供一个示例代码来演示其实际应用。

2. 算法思路折半查找法的基本思路是不断将查找范围缩小为一半，直到找到目标元素或者确认目标元素不存在。

以下是该算法的详细步骤：- 确定查找范围的起始位置（通常是数组的起始位置）和结束位置（通常是数组的末尾位置）。

- 计算查找范围的中间位置，并取得该位置上的元素。

- 如果中间元素等于目标元素，则查找成功，并返回该元素的位置。

- 如果中间元素大于目标元素，则将查找范围缩小为数组起始位置到中间位置-1的一半。

- 如果中间元素小于目标元素，则将查找范围缩小为中间位置+1到数组末尾位置的一半。

- 重复以上步骤，直到找到目标元素或者确认目标元素不存在。

3. 示例代码下面是一个使用C语言实现折半查找法的示例代码：```c#include <stdio.h>int binarySearch(int arr[], int low, int high, int target) { while (low <= high) {int mid = low + (high - low) / 2;if (arr[mid] == target) {return mid;}else if (arr[mid] < target) {low = mid + 1;}else {high = mid - 1;}}return -1; // 目标元素不存在的情况int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13};int size = sizeof(arr) / sizeof(arr[0]);int target = 9;int result = binarySearch(arr, 0, size - 1, target);if (result == -1) {printf("目标元素不存在\n");}else {printf("目标元素在数组中的位置为：%d\n", result);}return 0;}```4. 代码解析上述示例代码中，我们首先定义了一个名为`binarySearch`的函数，该函数接受一个有序数组`arr`、查找范围的起始位置`low`、结束位置`high`和目标元素`target`作为参数。

查找-静态查找表-折半查找（有序表）

查找-静态查找表-折半查找（有序表）⽂字描述以有序表表⽰静态查找表时，可⽤折半查找算法查找指定元素。

折半查找过程是以处于区间中间位置记录的关键字和给定值⽐较，若相等，则查找成功，若不等，则缩⼩范围，直⾄新的区间中间位置记录的关键字等于给定值或者查找区间的⼤⼩⼩于零时(表明查找不成功)为⽌。

⽰意图算法分析折半查找过程可以⽤⼀颗⼆叉判定树来表⽰，⽽具有n个结点的判定树的深度为[log2n]+1，所以折半查找法在查找成功和不成功时，与给定值进⾏⽐较的关键字个数都不会超过[log2n]+1. 现讨论折半查找算法的平均查找长度。

为讨论⽅便，假设有序表长度为n=2h-1，则描述折半查找的判定树是深度为h的满⼆叉树。

假设每个记录的查找概率相等Pi = 1/n, 则折半查找查找成功的平均查找长度当n⾜够⼤时，平均查找长度约为log2(n+1)-1 可见，折半查找的效率⽐顺序查找要⾼，但是折半查找只适⽤于有序表，且限于顺序存储结构，对线性链表⽆法有效地进⾏折半查找。

代码实现1/*2 ./a.out 5 13 19 21 37 56 64 75 80 88 923*/4 #include <stdio.h>5 #include <stdlib.h>67#define EQ(a, b) ((a) == (b))8#define LT(a, b) ((a) < (b))9#define LQ(a, b) ((a) <= (b))10#define MAX_SIZE 5011#define DEBUG1213 typedef int KeyType;14 typedef char InfoType;15/*数据元素类型定义*/16 typedef struct{17//关键字域18 KeyType key;19//其他域20 InfoType otherinfo;21 }ElemType;22/*静态查找表的顺序存储结构*/23 typedef struct{24//数据元素存储空间基址，建表时按实际长度分配，0号单元留空25 ElemType *elem;26//表长度27int length;28 }SSTable;2930/*折半查找算法31 *32 *顺序表中的元素应该按照由⼩到⼤顺序排列.33 *34 *在顺序表ST中顺序查找其关键字等于key的数据元素。

降序存储的一组整数(10个),任意输入一个数,用折半查找法找出该数的位置。

降序存储的一组整数(10个),任意输入一个数,用折半查找法找出该数的
位置。

折半查找法是一种有效的查找算法，能够实现快速且精准的查找指定元素的位置。

它的基本规则就是：将查找区间的中间元素的值和要查找的关键字比较，如果相等，则查找成功；若小于要查找的关键字，则将查找区间缩小为原来的左半部分；若大于关键字，则将查找区间缩小为原来的右半部分。

这种方式可使查找区间每次减少二分之一，同时也将查找元素的位置困难度降低，从而达到较高效率并快速找到元素，而无需遍历整个数组。

假设现在我们有一个降序排列的数组（10个元素），任意输入一个数，我们可以使用折半查找法来快速查找到该数字在数组中的位置。

首先，我们需要找到数组中间的位置，即索引号为5，当输入的数小于或等
于数组索引号5的元素时，我们可以将查找区间缩小为原来数组的左半部分，否则将查找区间缩小为原来数组的右半部分。

然后，重复上述操作，直到找到要查找的数字，从而确定数字在数组中的位置。

由于折半查找法每次剔除大量无效的查找元素，因此经过几次查找可以较快的找到目标数字的位置，大大提高了查找的工作效率。

折半查找法算法

折半查找法算法
折半查找法是一种在有序数组中查找某一特定元素的搜索算法。

它的基本思想是：首先，将数组的中间位置的元素与要查找的元素进行比较，如果相等，则查找成功；如果比要查找的元素大，则在数组的前半部分继续查找；如果比要查找的元素小，则在数组的后半部分继续查找。

这种方法可以大大减少查找的次数，提高查找的效率。

折半查找法的步骤如下：
1. 首先，从有序数组的中间位置开始查找，将中间位置处的元素与要查找的元素进行比较。

2. 如果相等，则查找成功；
3. 如果比要查找的元素大，则在数组的前半部分继续查找；
4. 如果比要查找的元素小，则在数组的后半部分继续查找；
5. 重复上述步骤，直到找到要查找的元素，或者查找范围为空。

折半查找法的时间复杂度为O(log2n)，其中n为数组的长度。

它的优点是查找速度快，比
顺序查找要快得多，而且它只需要对数组进行一次排序，就可以多次使用。

但是，它的缺点是只能用于有序数组，如果数组无序，则必须先进行排序，才能使用折半查找法。

总之，折半查找法是一种高效的查找算法，它可以大大减少查找的次数，提高查找的效率。

但是，它只能用于有序数组，如果数组无序，则必须先进行排序，才能使用折半查找法。

折半查找的递归算法

折半查找的递归算法1. 介绍折半查找，也称为二分查找，是一种在有序数组中查找目标值的常用算法。

它的时间复杂度为O(logN)，相比于线性查找的O(N)效率更高。

折半查找的核心思想是每次将查找范围缩小一半，直到找到目标值或者确认目标值不存在。

2. 算法原理折半查找算法的原理非常简单，基本思路如下： 1. 确定查找范围的起始位置（一般为数组的首尾元素）。

2. 计算范围的中间位置。

3. 判断中间位置的元素与目标值的关系： - 如果中间元素等于目标值，查找成功。

- 如果中间元素大于目标值，缩小查找范围至左侧一半，回到第2步。

- 如果中间元素小于目标值，缩小查找范围至右侧一半，回到第2步。

4. 重复步骤2和3，直到找到目标值或者确认目标值不存在。

3. 递归实现折半查找可以使用递归的方式实现，递归版本的算法如下：def binary_search_recursive(arr, target, left, right):if left > right:return -1mid = (left + right) // 2if arr[mid] == target:return midif arr[mid] > target:return binary_search_recursive(arr, target, left, mid - 1) else:return binary_search_recursive(arr, target, mid + 1, right)在递归版本的算法中，参数arr是要进行查找的有序数组，target是目标值，left和right分别表示当前查找范围的左右边界。

算法的停止条件是左边界大于右边界，表示无法再缩小查找范围。

4. 算法分析接下来我们来分析折半查找的递归算法的时间复杂度和空间复杂度。

时间复杂度每次递归时，查找范围缩小一半，因此递归的层数最多为log2(N)。

《折半查找法》课件

实际应用广泛
在数据库、搜索引擎、物流配送等领域，快速准确的查找是实现高效服务的关键。
折半查找法的概念
• 定义：折半查找法，又称二分查找法，是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。
感谢观看
与线性查找法相比，折半查找法在数据量大的情况下具有明显优势。
需要快速查找的场景
在某些对时间要求较高的场景中，如实时交易系统、在线游戏等
，需要快速查找数据。
折半查找法能够在较短时间内找到目标数据，满足快速查找的需
求。
与其他查找算法相比，折半查找法具有较高的查找速度。
二分搜索的应用场景
二分搜索是折半查找法的另一种表述方式，适用于有序数组的查找。
线性二分查找的变种
在有序数组中，从中间元素开始，如果中间元素正好是目标值，则搜索过程结束；如果目标值大于或小于中间元素，则在数组大于或小于中间元素的那一半中查找，但这一次从那一半的起始位置开始比较。
多重二分查找
多重二分查找是指在一次二分查找过程中，对多个有序数组进行查找的方法。通过将多个有序数组按照某种规则进行组合，可以大大提高查找效率。
在需要频繁进行查找操作的场景中，如搜索引擎、数据分析等，二分搜索能够提高查找效率。
二分搜索适用于任何有序数据集，只要能够确定数据集的左边界和右边界即可。
05
折半查找法的优化与改进
二分查找的变种
线性二分查找

数据结构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 的位置。

折半查找描述的算法

折半查找描述的算法
折半查找（Binary Search）是一种查找算法，适用于已排序数组或列表。

其算法步骤如下：
1. 初始化一个左指针left和一个右指针right。

left指向数组的起始位置，right 指向数组的末尾位置。

2. 计算中间位置mid = (left+right) / 2。

如果数组的大小为奇数，则mid是中间元素的索引；如果数组的大小为偶数，则mid是中间两个元素中的较小索引。

3. 比较中间元素[mid]和目标值target的大小。

- 如果[mid] == target，则找到目标值，返回mid。

- 如果[mid] < target，则目标值可能在[mid+1, right]之间，更新left = mid + 1，重复步骤2。

- 如果[mid] > target，则目标值可能在[left, mid-1]之间，更新right = mid - 1，重复步骤2。

4. 重复步骤2和步骤3，直到left > right或者找到目标值。

如果找到目标值，则返回其索引；如果找不到目标值，则返回-1。

折半查找的时间复杂度为O(log n)，其中n是数组的大小。

由于每次都将搜索区间缩小一半，因此它是一种高效的查找算法。

折半查找算法的原理

折半查找算法的原理
折半查找算法（Binary Search），也称为二分查找算法，是一
种常用的查找算法。

该算法可以在一个已排序的列表中查找任意元素
的位置。

假设列表中有 N 个元素，折半查找算法的时间复杂度为
O(log N)。

折半查找算法的原理是将待查找的元素与列表的中间元素进行比较，如果待查找的元素小于中间元素，则在中间元素的左侧继续查找；如果待查找的元素大于中间元素，则在中间元素的右侧继续查找。

重
复执行以上步骤，直到找到目标元素或者列表中不存在该元素。

具体实现折半查找算法时，可以采用以下步骤：
1.设定左右边界，初始时左边界为第一个元素的下标，右边界为
最后一个元素的下标；
2.计算中间元素的下标（中间元素下标等于左边界和右边界之和除以2），并将其与目标元素进行比较；
3.如果目标元素等于中间元素，则返回中间元素的下标；
4.如果目标元素小于中间元素，则将右边界移动到中间元素的左侧；
5.如果目标元素大于中间元素，则将左边界移动到中间元素的右侧；
6.重复执行步骤2~5，直到找到目标元素或者列表中不存在该元素。

折半查找算法可以快速地查找大型、已排序的数据集合中的元素。

但是，该算法需要将数据集合先进行排序，因此在某些情况下可能会
影响算法的效率。

折半查找——精选推荐

折半查找折半查找1. 算法思想2. 算法实现3. 查找判定树4. 折半查找效率折半查找的算法思想折半查找，⼜称“⼆分查找”，仅适⽤于有序的顺序表33>mid，往右查右指针到⼀个位置就-1，左指针到⼀个位置就+1low>high，查找失败折半查找的实现typedef struct{ElemType *elem;int TableLen;}SSTable;//折半查找（升序）int Binary_Search(SSTable L,ElemType key){int low = 0,high = L.TableLen-1,mid;while(low<=high){mid = (low+high)/2; //取中间位置if(L.elem[mid] == key)return mid; //查找成功则返回所在位置else if(L.elem(mid)>key)high = mid -1; //从前半部分继续查找elselow = mid +1; //从后半部分继续查找}return -1; //查找失败，返回-1}顺序表拥有随机访问的特性，链表没有查找效率复分析查找判定树的构造如果当前low和high之间有奇数个元素，则mid分隔后，左右两个部分元素个数相等如果当前low和high之间有偶数个元素，则mid分隔后，左半部分⽐右半部分少⼀个元素折半查找的判定树中，若 mid=向下取整(low+high)/2，对于任何⼀个结点，必有：右⼦树结点-左⼦树结点=0或1⾃⼰过⼀遍顺序，1个元素，2个元素，。

折半查找的判定树⼀定是平衡⼆叉树因此，元素个数为n时树⾼h=⌈log2(n+1)⌉计算完全⼆叉树也相同满⾜⼆叉排序树的定义失败节点：n+1个，等于成功结点的空链域数量知识回顾⼤部分情况下折半查找速度都⽐顺序查找快。

但是不⼀定哦从上去整，不⼀样哦，左边的⽐较多Processing math: 100%。