JAVA数组篇之二分查找

ls07

已于 2022-11-01 11:03:39 修改

阅读量817

点赞数 2

分类专栏：数据结构与算法文章标签：算法 leetcode 数据结构 java

于 2022-10-31 21:17:33 首次发布

本文链接：https://blog.csdn.net/ls199848/article/details/127622365

版权

数据结构与算法专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

二分查找

核心思想
- 左边界不动，右边界减小，中间数往左移
- 右边界不动，左边界减小，中间数往右移

要查找的条件，要么是确定的等于某个值，要么是最左或者最右边界。

最重要的是掌握循环不变量原则：

二分查找涉及的很多的边界条件，逻辑比较简单，但就是写不好。例如到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？

大家写二分法经常写乱，主要是因为对区间的定义没有想清楚，区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

下面是两种不同的二分写法。

二分法第一种写法

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] 。

区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

二分法第二种写法

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。

有如下两点：

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

相关例题

704.二分查找

题目描述：

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例：

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

有序，无重复，查找：已经在提示使用二分查找了

写法一：
左闭右闭区间 left <= right，right的初始化为nums.length - 1，if (nums[index] > target)，right需要更新为index - 1。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while(left <= right && left >= 0 && right < nums.length){
            int index = (left + right) / 2;
            if(nums[index] == target){
                return index;
            } else if(nums[index] < target){
                left = index + 1;
            } else{
                right = index - 1;
            }
        }

        return -1;
    }
}

写法二：
左闭右开区间，left<right，right的初始化为nums.length，且if (nums[index] > target)时，right需要更新为index。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else if (nums[mid] > target)
                right = mid;
        }
        return -1;
    }
}

35. 搜索插入位置

题目描述：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。
如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
nums 为 无重复元素 的升序排列数组

示例：

示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4

在这道题目与704题区别不大，一个是找不到直接返回-1，而本题是要求即使找不到相应的元素，返回的也是它按顺序插入的位置。

插入值的情况也就三种，最前面，最后面以及中间某个[left,right]之间
直接最后找不到返回left就是对应的最左边界，也即需要插入的位置。

本题对边界处理的判断要求更加明确。

写法一：
左闭右开写法

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == target){
                return mid;
            } 
            if(nums[mid] < target){
                left = mid + 1;
            }
            if(nums[mid] > target){
                right = mid - 1;
            } 
        }
        return left;
    }
}

写法二：
左闭右开写法

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        
        while(left < right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == target){
                return mid;
            } 
            if(nums[mid] < target){
                left = mid + 1;
            }
            if(nums[mid] > target){
                right = mid;
            } 
        }
        return left;
    }
}

34. 在排序数组中查找元素的第一个和最后一个位置

题目描述：

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。
请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例：

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

解法：
首先通过二分查找的方法，去定位数组中有没有目标数，没有返回-1，有则返回当前下标

再通过返回值判断，是-1就直接返回数组[-1,-1]

不是-1就说明有目标值，又因为目标值可能由多个且连续排列在一起，所以可以通过左右滑动去找目标值的边界即可。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int index =  binarySearch(nums,target);
        if(index == -1){
            return new int[] {-1,-1};
        }
        int left = index;
        int right = index;
        while(left - 1 >= 0 && nums[left - 1] == target){
            left--;
        }
        while(right + 1 < nums.length && nums[right + 1] == target){
            right++;
        }
        return new int[] {left,right};
    }

    public int binarySearch(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        return -1;
    }
}

69. x 的平方根

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：
输入：x = 4
输出：2

示例 2：
输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

以0为左边界，x为右边界

只要(long)mid * mid <= x，就使L增加，使中间数往右移，一直找到(long)mid * mid <= x的最左边界

注意mid * mid 要转换为long类型，防止溢出。

class Solution {
    public int mySqrt(int x) {
        int l = 0;
        int r = x;
        int ans = -1;
        while(l <= r){
            int mid = l + ((r - l) >> 1);
            if((long)mid * mid <= x){
                ans = mid;
                l = mid + 1;
            }else{
                r = mid - 1;
            }
        }
        return ans;   
    }
}