二分查找
1、工作原理
- 在最简单的形式中,二分查找对具有指定左索引和右索引的连续序列进行操作。这就是所谓的查找空间。二分查找维护查找空间的左、右和中间指示符,并比较查找目标或将查找条件应用于集合的中间值;如果条件不满足或值不相等,则清除目标不可能存在的那一半,并在剩下的一半上继续查找,直到成功为止。如果查以空的一半结束,则无法满足条件,并且无法找到目标。
2、组成部分
-
二分查找一般由三个主要部分组成:
-
预处理 —— 如果集合未排序,则进行排序。
-
二分查找 —— 使用循环或递归在每次比较后将查找空间划分为两半。
-
后处理 —— 在剩余空间中确定可行的候选者。
-
3、两种特殊的思维模型
- 第一种思维模型
- 前面一堆 1 ,后面一堆 0;
- 种思维模型
- 前面一堆 0 ,后面一堆 1;
4、例题
-
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4 -
解题—二分查找(二分查找标准模板)
-
//执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户 //内存消耗:41.8 MB, 在所有 Java 提交中击败了7.88%的用户 //通过测试用例:47 / 47 //二分查找 public static int search(int[] nums, int target) { int left = 0,right = nums.length-1; //左右中 while (left <= right){ //int mid = (left + right) / 2; int mid = left + (right - left) / 2; //推荐这样求中间值 if (target == nums[mid]){ return mid; }else if (target > nums[mid]){ left = mid + 1; }else{ right = mid - 1; } } return -1; }
-
5、三种模板
-
标准模板
-
初始条件:left = 0, right = length-1
-
终止:left > right
-
向左查找:right = mid-1
-
向右查找:left = mid+1
-
力扣–>69、x 的平方根
-
//执行用时:1 ms, 在所有 Java 提交中击败了96.24%的用户 //内存消耗:38.8 MB, 在所有 Java 提交中击败了5.05%的用户 //通过测试用例:1017 / 1017 //二分查找 public static int mySqrt(int x) { int left = 0,right = x - 1; int ans = -1; while (left <= right){ int mid = left + (right - left)/2; if ((long)mid * mid <= x){ //测试的范围大于int ans = mid; left = mid +1; }else{ right = mid -1; } } return ans; }
-
-
力扣–>374. 猜数字大小
-
//执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户 // 内存消耗:38.2 MB, 在所有 Java 提交中击败了5.60%的用户 //通过测试用例:25 / 25 //二分查找 public int guessNumber(int n) { int left = 1,right = n; while (left <= right){ int mid = left + (right - left)/2; if (guess(mid) == 0){ return mid; }else if (guess(mid) > 0){ //当guess返回 1 时是 查找的数大于中间的数--所以左边界移动 left = mid + 1; }else{ right = mid -1; } } return -1; }
-
-
力扣–>33. 搜索旋转排序数组
-
这题有被笑到(哈哈哈哈哈哈)
-
解法一
-
class Solution { public int search(int[] nums, int target) { for (int i = 0;i<nums.length;i++){ if (nums[i] == target){ return i; } } return -1; } }
-
-
解法二(二分法)
-
//执行用时:1 ms, 在所有 Java 提交中击败了100.00%的用户 //内存消耗:41.1 MB, 在所有 Java 提交中击败了5.04%的用户 //通过测试用例:195 / 195 //二分查找 public static int search(int[] nums, int target) { int k = 0; int left = 0,right = nums.length-1; for (int i = 0;i<nums.length;i++){ //确认k值---被翻转后首元素的下标 if (nums[i] < nums[0]){ k = i; break; } } int[] nums1 = Arrays.copyOf(nums,nums.length); Arrays.sort(nums1); while (left <= right){ int mid = left + (right - left)/2; if (nums1[mid] == target){ if (target < nums[0] && k !=0){ //k值不为0则被翻转了---进行处理 return mid + k; }else if (k !=0){ return mid - (nums.length - k); }else{ return mid; //这里不用做处理因为k == 0; } }else if (nums1[mid] > target){ right = mid -1; }else { left = mid +1; } } return -1; }
-
-
-
-
模板二、
-
区分语法
- 初始条件:left = 0, right = length
- 终止:left == right
- 向左查找:right = mid
- 向右查找:left = mid + 1
-
关键属性
- 一种实现二分查找的高级方法。
- 查找条件需要访问元素的直接右邻居。
- 使用元素的右邻居来确定是否满足条件,并决定是向左还是向右。
- 保证查找空间在每一步中至少有 2 个元素。
- 需要进行后处理。 当你剩下 1 个元素时,循环 / 递归结束。 需要评估剩余元素是否符合条件。、
-
力扣–>153. 寻找旋转排序数组中的最小值
-
//执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户 //内存消耗:41.2 MB, 在所有 Java 提交中击败了5.08%的用户 //通过测试用例:150 / 150 //二分模板二 public static int findMin(int[] nums) { int left = 0,right = nums.length -1; while (left < right){ int mid = left + (right - left)/2; if (nums[mid] >= nums[nums.length -1]){ //当中间值大于最后一个值时说明:最小值在左边 left = mid +1; }else { right = mid; } } return nums[left]; }
-
-
力扣–>162. 寻找峰值
-
//执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户 //内存消耗:40.4 MB, 在所有 Java 提交中击败了13.16%的用户 //通过测试用例:63 / 63 //二分模型二 public static int findPeakElement(int[] nums) { int left = 0,right = nums.length - 1; while (left < right){ int mid = left + (right - left)/2; if (nums[mid] < nums[mid + 1]){ //暴力将相邻的两个值比较 left = mid + 1; }else { right = mid; } } return left; }
-
-
力扣–>278. 第一个错误的版本
-
/执行用时:11 ms, 在所有 Java 提交中击败了99.95%的用户 //内存消耗:37.9 MB, 在所有 Java 提交中击败了26.87%的用户 //通过测试用例:22 / 22 //二分法-->模板二 public int firstBadVersion(int n) { int left = 0,right = n; while (left < right){ //left == right 时循环退出 int mid = left + (right - left)/2; if (isBadVersion(mid)){ //当mid >= 想要寻找的值时---都会返回true right = mid; }else { left = mid + 1; } } return left; }
-
-
-
模板三、
-
关键属性
- 实现二分查找的另一种方法。
- 搜索条件需要访问元素的直接左右邻居。
- 使用元素的邻居来确定它是向右还是向左。
- 保证查找空间在每个步骤中至少有 3 个元素。
- 需要进行后处理。 当剩下 2 个元素时,循环 / 递归结束。 需要评估其余元素是否符合条件。
-
区分语法
- 初始条件:left = 0, right = length-1
- 终止:left + 1 == right
- 向左查找:right = mid
- 向右查找:left = mid
-
力扣–>34. 在排序数组中查找元素的第一个和最后一个位置
-
//执行用时:0 ms, 在所有 Java 提交中击败了100.00%的用户 //内存消耗:44.7 MB, 在所有 Java 提交中击败了5.07%的用户 //通过测试用例:88 / 88 //二分查找-->模板三 public int left(int[] nums, int target){ int left = 0,right = nums.length -1; int[] n = new int[]{-1,-1}; if (nums.length == 0){ return -1; } while (left + 1 < right){ int mid = left + (right - left)/2; if (target > nums[mid]){ left = mid; }else { right= mid; } } if(nums[left] == target){ return left; } if(nums[right]== target){ return right; } return -1; } public int right(int[] nums, int target){ int left = 0,right = nums.length -1; int[] n = new int[]{-1,-1}; if (nums.length == 0){ return -1; } while (left + 1 < right){ int mid = left + (right - left)/2; if (target >= nums[mid]){ left = mid; }else { right= mid; } } if(nums[right] == target){ return right; } if(nums[left] == target){ return left; } return -1; } public int[] searchRange(int[] nums, int target) { int[] n = new int[2]; n[0] = left(nums,target); n[1] = right(nums,target); return n; }
-
-
力扣–>658. 找到 K 个最接近的元素
-
//执行用时:4 ms, 在所有 Java 提交中击败了79.65%的用户 //内存消耗:43.1 MB, 在所有 Java 提交中击败了11.06%的用户 //通过测试用例:63 / 63 //双指针排除-------------------- public static List<Integer> findClosestElements(int[] arr, int k, int x) { int start = 0, end = arr.length - 1; int remove = arr.length - k; //删除的个数 while (remove > 0) { if (Math.abs(x - arr[start]) > Math.abs(arr[end] - x)) { //只有当左边大于右边的时候才会删去 //当两边相同或者小于时都是删除右边 start++; } else { end--; } remove--; //删除的数目-1 } List<Integer> list = new ArrayList<>(); for (int i = start; i <= end; i++) { list.add(arr[i]); } return list; } //执行用时:4 ms, 在所有 Java 提交中击败了79.65%的用户 //内存消耗:42.7 MB, 在所有 Java 提交中击败了16.15%的用户 //通过测试用例:63 / 63 //二分法---神奇啊这 public static List<Integer> findClosestElements1(int[] nums, int k, int x) { int left = 0, right = nums.length - k; while (left < right) { int mid = left + (right - left)/2; if (x - nums[mid] > nums[mid + k] - x) { // 如果左边界点与x的差值 > 右边界点与x的差值 —> 向右侧靠近 left = mid + 1; } else { right = mid; } } List<Integer> list = new ArrayList<>(); for (int i = left; i < left+k; i++) { list.add(nums[i]); } return list; }
-
-