二分查找(java)

二分查找

1、工作原理

  • 在最简单的形式中,二分查找对具有指定左索引和右索引的连续序列进行操作。这就是所谓的查找空间。二分查找维护查找空间的左、右和中间指示符,并比较查找目标或将查找条件应用于集合的中间值;如果条件不满足或值不相等,则清除目标不可能存在的那一半,并在剩下的一半上继续查找,直到成功为止。如果查以空的一半结束,则无法满足条件,并且无法找到目标。

2、组成部分

  • 二分查找一般由三个主要部分组成:

    • 预处理 —— 如果集合未排序,则进行排序。

    • 二分查找 —— 使用循环或递归在每次比较后将查找空间划分为两半。

    • 后处理 —— 在剩余空间中确定可行的候选者。

3、两种特殊的思维模型

  1. 第一种思维模型
    • 前面一堆 1 ,后面一堆 0;
    • image-20220209162838808
  2. 种思维模型
    • 前面一堆 0 ,后面一堆 1;
    • image-20220209162902043

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、三种模板

  1. 标准模板

    • 初始条件: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;
              }
          
  2. 模板二、

    • 区分语法

      • 初始条件: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. 模板三、

    • 关键属性

      • 实现二分查找的另一种方法。
      • 搜索条件需要访问元素的直接左右邻居。
      • 使用元素的邻居来确定它是向右还是向左。
      • 保证查找空间在每个步骤中至少有 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;
        }
        
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值