二分查找

一、二分查找核心思想： 定中位，得中值。 中值和查找词比较 查找词大于中值，在右边再次递归查找low变为mid+1; 查找词小于中值， 在左边再次递归查找high变为mid-1; 查找词等于中值，返回中值。 public class BinarySearch { public static void main(String[] args) { int[]arr=new int[10000*10000]; for(int i=0;i<arr.length;i++) { arr[i]=i+1; } int target=10000*10000; long now=System.currentTimeMillis();//系统当前时间（游戏开始时间） int index=binarySearch(arr,0,arr.length-1,target);//开始查找元素所在下标（游戏开始） //运行时间（游戏时间=游戏结束时间-游戏开始时间） System.out.println(System.currentTimeMillis()-now+"ms"); System.out.println("二分查找:"+target+"所在位置为："+index); } //二分查找　low-起点 high-终点 key-关键词 public static int binarySearch(int [

本文用python3实现了二分查找算法，分别使用递归方法和非递归方法。 （一）递归实现 def binarySearch(s, k): return binarySearch_c(s, 0, len(s) - 1, k) def binarySearch_c(s, low, high, k): if low > high: return -1 mid = low + (high - low) // 2 if s[mid] == k: return mid elif s[mid] > k: return binarySearch_c(s, low, mid - 1, k) else: return binarySearch_c(s, mid + 1, high, k) for _ in range(int(input())): s = list(map(int, input().split())) k = int(input()) print(binarySearch(s, k)) （二）非递归实现 def binarySearch(s, k): low = 0 high = len(s) - 1 while low <= high: mid = low + (high - low) // 2 if s[mid] == k: return mid elif s[mid] > k:

我们在写程序的时候，经常会遇到这样一类问题：在一个数组中查找一个数是不是存在。比如在下图的数组中，查找8是不是存在： 如果不要求效率，我们最一般的查找方法就是顺序查找，依次查看a[0], a[1], …, a[n-1]，检查是不是等于8。这样对于长度为n的数组，平均查找长度是n/2。 如果数组是有序的，比如是递增的，就像上图[1, 2, 3, 4, 5, 7, 8, 10, 11, 13]一样的话。我们就有效率更高的查找算法，叫做二分查找。例如还是在上面数组中查找8： 二分查找会这么进行：我们面对的数组是a[0]-a[9]，第一步：我们直接找位于中间的数a[4]，发现a[4]=5。我们要找的数是8，比5大，所以我们知道如果8在数组里，那它肯定在a[5]~a[9]这几个数的范围里。 第二步：我们找a[5]-a[9]这个范围里位于中间的数a[7]，发现a[7]=10，比我们要找的8大。所以我们知道如果8在数组里，那它肯定在a[5]~a[6]这几个数的范围里。 第三步：我们找到a[5]-a[6]这个范围里位于中间的数a[5]，发现a[5]=7，比我们要找的8小。所以我们知道如果8在数组里，那它肯定是a[6]这个数。 第四步也是最后一步。我们查看a[6]的值，发现a[6]=8，于是我们找到了8的位置。假如我们这时发现a[6]不是8，则说明8没有在这个数组里。 二分查找又叫“折半查找”

思路1：遍历，既然给定的数组是递增序列， 那么只要确定从那个数字开始后一位小于自己即可。然后再搬运回去输出0号下标即可。 时间复杂度 O（n）； 空间复杂度O（1）； 效率相对低下。 public int minNumberInRotateArray ( int [ ] array ) { if ( array . length == 0 || array == null ) return 0 ; for ( int i = 0 ; i < array . length - 1 ; i ++ ) { if ( array [ i ] > array [ i + 1 ] ) { return array [ i + 1 ] ; } } return array [ 0 ] ; } 思路二：二分查找，给定的数组是一个相对有序的序列，我们要找的数字是一个比前一个数字小的数字，那么我们使用二分查找效率会高很多。 那么如何进行二分查找呢？ 定义三个指针，确定一个范围，分别是 index1 ，mid，index2，分别指向前，中，后三个下标， 如果 arr[mid] 大于等于 arr[index1] ,那么就说明 index1 到 mid 是一个递增数组， 那么要找的数字就mid后面，所以让 index1 指向 mid； 如果 arr[mid] 小于等于 arr[index2]，那么mid 到

二分查找（BinarySearch）：又叫折半查找，从有序列表的初始候选区li[0：n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半。 PS：二分查找只针对有序的列表 //只针对有序的列表 public int BinarySearch(List<int> li, int value) { int left = 0; int right = li.Count - 1; int mid = (left + right) / 2; while (left<right) { mid = (left + right) / 2; if (li[mid] == value) return mid; if (li[mid] > value) right = mid - 1; else left = mid + 1; } return -1; } 来源： CSDN 作者： lvcoc 链接： https://blog.csdn.net/lvcoc/article/details/104130640

二分查找算法： 用于在有序数组中快速查找所需要的值，前提是数组已经排序 python代码实现： def binary_search ( thelist , item ) : low = 0 high = len ( thelist ) - 1 while low <= high : mid = int ( ( low + high ) / 2 ) if thelist [ mid ] == item : return mid elif thelist [ mid ] < item : low = mid + 1 else : high = mid - 1 return None 验证算法： l = [ 1 , 2 , 4 , 8 , 9 , 10 ] print ( "the index of result: " + str ( binary_search ( l , 8 ) ) ) l = [ 1 , 2 , 4 , 8 , 9 , 10 ] print ( "the index of result: " + str ( binary_search ( l , 12 ) ) ) 来源： CSDN 作者： Robot647 链接： https://blog.csdn.net/m0_46245938/article/details/104133746

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。 二分查找法是已经排好顺序的集合，要从集合的中间开始查找，如果这个项小于我们要查找的数，则这个项前边的所有数都小于我们要查找的对象 就无需再浪费时间去查在前边的数查找;如果搜寻的数天于我们要查找的对象那么这个数的后边的数都大于我们要查找的对象，则后边的数我们也不用再去查找了。 下边我会用c#和c++两种语言给出代码 c#二分查找代码 static void Main(string[] args) { int[] _array={ 1,3,5,6,10,14,16,20,21,23,28}; int _findValue = BinSearch(_array, 0, _array.Length, 3); if (_findValue == -1) { Console.WriteLine("not find"); } else { Console.WriteLine("find the value at " + _findValue); } Console.ReadLine(); } static int BinSearch(int[] _array, int start, int end, int key) { int

二分查找（非递归） 基本介绍 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表 必须采用顺序存储结构 ，而且表中元素按关键字 有序排列 。 首先，假设表中元素是按 升序排列 ，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。 比较次数 a<log 2 n<b 算发时间复杂度 O(n)=O(log 2 n) 代码实现 以arr = { 1, 3, 8, 10, 11, 67, 100 }为例 public class BinarySerch { public static void main ( String [ ] args ) { int [ ] arr = { 1 , 3 , 8 , 10 , 11 , 67 , 100 } ; // 测试二分查找 int index = binarySearch ( arr , 1 ) ; System . out . println ( "index=" + index + " 值【" + arr [ index ] + "】" ) ; } /** *

本题要求实现二分查找算法。 函数接口定义： Position BinarySearch ( List L , ElementType X ) ; 其中List结构定义如下： typedef int Position ; typedef struct LNode * List ; struct LNode { ElementType Data [ MAXSIZE ] ; Position Last ; /* 保存线性表中最后一个元素的位置 */ } ; L是用户传入的一个线性表，其中ElementType元素可以通过 > 、 == 、 < 进行比较， 并且题目保证传入的数据是递增有序的。函数BinarySearch要查找X在Data中的位置， 即数组下标（注意：元素从下标 1 开始存储）。找到则返回下标， 否则返回一个特殊的失败标记NotFound。 裁判测试程序样例： # include <stdio.h> # include <stdlib.h> # define MAXSIZE 10 # define NotFound 0 typedef int ElementType ; typedef int Position ; typedef struct LNode * List ; struct LNode { ElementType Data [ MAXSIZE ] ;

二分查找 二分查找，它适用于有序的顺序表。思路是：首先将给定值与表中中间位置元素的关键字进行比较，若相 等，则查找成功，返回该元素的存储位置；若不等，则所需查找的元素只能在中间元素以外的前半部分或者后 半部分中。然后再缩小的范围内继续进行相同的查找，如此重复直到找到为止。如果确认表中没有所需查找的 元素，则返回查找失败的信息 代码: // 二分查找（非递归） int binary_Search ( int value , int [ ] a , int left , int right ) { while ( left <= right ) { int mid = ( left + right ) / 2 ; //取中间位置 if ( value > a [ mid ] ) { //从后半部分继续查找 left = mid + 1 ; } else if ( value < a [ mid ] ) { //从前半部分继续查找 right = mid - 1 ; } else if ( value == a [ mid ] ) { return mid ; // 查找成功，则返回所在位置 } } return - 1 ; //查找元素不存在，返回-1 } // 二分查找（递归） int binary_Search ( int value , int * a , int left ,