二分查找（java）

念言-ny

已于 2022-02-27 18:53:28 修改

阅读量408

点赞数

文章标签： java 算法 leetcode

于 2022-02-09 23:08:31 首次发布

本文链接：https://blog.csdn.net/weixin_51713937/article/details/122851646

版权

二分查找

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;
}

念言-ny

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
二分查找（java）

二分查找1、工作原理在最简单的形式中，二分查找对具有指定左索引和右索引的连续序列进行操作。这就是所谓的查找空间。二分查找维护查找空间的左、右和中间指示符，并比较查找目标或将查找条件应用于集合的中间值；如果条件不满足或值不相等，则清除目标不可能存在的那一半，并在剩下的一半上继续查找，直到成功为止。如果查以空的一半结束，则无法满足条件，并且无法找到目标。2、组成部分二分查找一般由三个主要部分组成：预处理 —— 如果集合未排序，则进行排序。二分查找 —— 使用循环或递归在每次比较后将查
复制链接

扫一扫