二分查找

1.二分查找的定义 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。 折半查找要求 线性表必须采用顺序存储结构 ，而且表中元素 按关键字有序排列 。 2.查找的过程 （1）假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功； （2）否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。 （3）重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。 （1）C和C++代码（C和C++的语法基本相同） 循环实现之第一种 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 int int { //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1 int //置当前查找区间上、下界的初值 while (low<=high) { if (R[low].key==K) return low; if (R[high].key==k) return //当前查找区间R[low..high]非空 mid=low+(high-low)/2; /*使用(low+high)/2会有整数溢出的问题 （问题会出现在当low

String[] name = new String[5]; name[0] = "11"; name[1] = "22"; name[2] = "33"; name[3] = "44"; //name[4] = "55"; //数组如果是满的二分查找则不会经过数组中的null值，反之则一定会用null值调方法作比较 String search = "55"; if(Arrays.binarySearch(name, search) >= 0) {　　<――java.lang.NullPointerException 　　for (int j = Arrays.binarySearch(name, search); j < name.length - 1; j++) { 　　name[j] = name[j + 1]; 　　} 　　name[name.length - 1] = null; }else { 　　System.out.println("没找到相应元素"); } private static int binarySearch0(Object[] a, int fromIndex, int toIndex,Object key) { 　　int low = fromIndex; 　　int high = toIndex - 1; 　　while (low <= high)

版权声明：署名，允许他人基于本文进行创作，且必须基于与原先许可协议相同的许可协议分发本文 （ Creative Commons ） 文章目录 1. 求开方 2. 大于给定元素的最小元素 3. 有序数组的 Single Element 4. 第一个错误的版本 5. 旋转数组的最小数字 6. 查找区间 微信公众号 正常实现 Input : [1,2,3,4,5] key : 3 return the index : 2 public int binarySearch ( int [ ] nums , int key ) { int l = 0 , h = nums . length - 1 ; while ( l <= h ) { int m = l + ( h - l ) / 2 ; if ( nums [ m ] == key ) { return m ; } else if ( nums [ m ] > key ) { h = m - 1 ; } else { l = m + 1 ; } } return - 1 ; } 时间复杂度 二分查找也称为折半查找，每次都能将查找区间减半，这种折半特性的算法时间复杂度为 O(logN)。 m 计算 有两种计算中值 m 的方式： m = (l + h) / 2 m = l + (h - l) / 2 l + h 可能出现加法溢出

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u011277745/article/details/91420321 二分查找法是用于查找一个数字在一个有序序列中的位置 public class BinarySearch { public static int bsearch(int[] array,int findData) { int low = 0; int high = array.length-1; while (low<high) { int mid = (low+high)/2; if (findData>array[mid]) { low = mid+1; }else if (findData<array[mid]) { high = mid-1; }else if (findData == array[mid]) { return mid; } } return -1; } public static void main(String[] args) { int[] arr = { 6, 12, 33, 87, 90, 107, 209, 878 }; System.out.println("87的脚标是:" + (bsearch(arr, 87))); } } 结果:87的脚标是:3 文章来源: https:/

//分别找最左边和最右边 class Solution { public int[] searchRange(int[] nums, int target){ if (nums.length == 0) return new int[]{-1, -1}; int left = searchLeft(nums, target); int[] res = new int[2]; if (left == -1){ res[0] = -1; res[1] = -1; return res; } int right = searchRight(nums, target); if (left < right){ res[0] = left; res[1] = right; }else { res[0] = right; res[1] = left; } return res; } public int searchLeft(int[] nums, int target){ int left = 0; int right = nums.length; int mid = 0; while (left < right - 1){ // 左闭右开 // System.out.println(left + " " + right); mid = (left + right) / 2; if

使用条件： 二分查找法适合用于不经常变动而查找频繁的 有序 列表。 1. 递归查找： def binary_search ( alist , item ) : """二分查找法：递归查找""" n = len ( alist ) if n > 0 : mid = n // 2 if alist [ mid ] == item : return True elif item < alist [ mid ] : return binary_search ( alist [ : mid ] , item ) else : return binary_search ( alist [ mid + 1 : ] , item ) return False 2. 非递归查找： first = 0 last = len ( alist ) - 1 mid = ( first + last ) // 2 while first <= last : if alist [ mid ] == item : return True elif item < alist [ mid ] : last = mid - 1 else : first = mid + 1 return False 文章来源: https://blog.csdn.net/weixin_40576010/article/details

题意：找出指定元素出现的范围，Ologn 思路：两次二分 class Solution { public: vector<int> searchRange(vector<int>& nums, int target) { int l = 0, r = nums.size() - 1; int lx = -1, rx = -1; while (l <= r) { int mid = (l + r) >> 1; if (nums[mid] < target) { l = mid + 1; } else if (nums[mid] > target) { r = mid - 1; } else { lx = mid; r = mid - 1; } } l = 0, r = nums.size() - 1; while (l <= r) { int mid = (l + r) >> 1; if (nums[mid] < target) { l = mid + 1; } else if (nums[mid] > target) { r = mid - 1; } else { rx = mid; l = mid + 1; } } vector<int> res; res.push_back(lx); res.push_back(rx); return res; } }; View Code

版权声明：本文博主原创，转载时候请注明。 https://blog.csdn.net/u012336460/article/details/83959457 Ŀ¼ 顺序查找 二分查找（查找有序数列中的某个值） 二分答案（不只是查找值） 二分查找（查找有序数列中的某个值） (05，13，19，21，37，56，64，75，80，88，92) 1 2 3 4 5 6 7 8 9 10 12 二分查找算法分析 代码：binary_research() #include <iostream> using namespace std; const int N =10; int a[12]={0 ,5, 13,19, 21,37,56,64,75,80,88,92}; int my_research(int L, int R, int key){ int first = L, last = R-1; while(first < last){ int middle = (first+last)/2; if( a[middle]==key) return middle; else if( a[middle] < key ) first = middle+1; //这里要注意，不能是middle 若果是middle，[middle, last] 可能与[fist, last]区间一样，将发生死循环

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012736685/article/details/83445234 一、概述 二分查找(Binary Search，也称折半查找)――针对有序数据集合的查找算法 1、基本思想 类似分治思想，每次都通过跟区间的中间元素进行对比，将代查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为0（不存在该元素）。 2、时间复杂度分析――O(logn) 不妨假设数据量为n，每次查找后数据量均为原来的1/2，最坏的情况下，直到查找区间被缩小为空，才停止。设经过k次区间缩小操作区间缩小到1，可得 k=log 2 n 时间复杂度为O(k)，也就是O(logn)。 O(1) 常量级时间复杂度的算法可能还没有O(logn)的算法执行效率高。 因为：大O标记法表示时间复杂度时，会省略掉常数、系数和低阶，O(1)可能表示一个非常大的常量值，eg: O(10000)。 二、简单实现 二分查找最简单的情况：有序数组中不存在重复元素 1、递归方法实现 # include <iostream> using namespace std ; int BinarySearchRecursive ( int * array , int low , int high , int key ) { if ( low

版权声明：。 https://blog.csdn.net/weixin_43778797/article/details/90243202 1. # 一维列表 # 条件：起始位置小于等于结束位置 nums = [4, 1, 5, 10, -1, 9, 3, 2, 13, 7, ] print("原来的列表为：", nums) nums.sort() # 进行排序 print("列表排序后为：", nums) num = int(input("请输入你要查找的数：")) # 需要查找的数 pos = -1 # 默认需要查找的数的位置为-1 start = 0 end = len(nums)-1 while start <= end: mid = (start+end)//2 if num == nums[mid]: # 如果要找的数等于中间的这个数 pos = mid # 那么位置就为中间这个数的位置 break elif num < nums[mid]: # 若要找的数小于中间 end = mid - 1 # 中间减一 else: # 若要找的数大于中间，则中间加一 start = mid + 1 # 判断是否找到 if pos != -1: # 若找到了 print("%d位置是%d" % (num, pos)) else: # 若没找到 print("没找到%d" % num)