【多种解法+详细注释】力扣算法带刷——二分查找法

爱写代码的July

已于 2024-08-27 23:52:24 修改

阅读量699

点赞数 25

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

于 2023-11-26 15:05:18 首次发布

本文链接：https://blog.csdn.net/Liu_y_xin/article/details/134627550

版权

算法练习专栏收录该内容

30 篇文章 0 订阅

订阅专栏

二分查找法思想

1）首先选择数组中间的数字和需要查找的目标值比较

2）如果相等直接返回答案

3）如果不相等，则：

a.如果中间的数字大于目标值，在中间数字左侧进行查找

b.如果中间的数字小于目标值，在中间数字右侧进行查找

二分查找法核心代码

// 写法一：
public int search(int[] nums, int target) {
        // 定义两个游标(左闭右闭）
        int left = 0; // 指向数组中首个元素
        int right = nums.length-1; // 指向数组中最后一个元素，length-1
        while(left <= right) { 
        // 终止循环判断条件：两者相遇
            int mid = (left+right)/2; // 从中间值开始查找
            if(target>nums[mid]) { // 目标值大于中间值，往右半部分查找，右游标不动，   
                left=mid+1; // 左游标指向mid+1（mid值已经比较过了，不用重复比较）
            }else if(target < nums[mid]){ // 目标值小于中间值，往左半部分查找，左游标不动，
                right = mid-1;// 右游标指向mid-1（mid值已经比较过了，不用重复比较）
            }else // 目标值等于该值，返回游标mid
                return mid;
        }
        return -1;
    }
// 写法二：
public int search(int[] nums, int target) {
        // 定义两个游标(左闭右开）
        int left = 0; // 指向数组中首个元素
        int right = nums.length;  // 指向数组最后一个元素的下一个值length（取不到）
        while(left < right) { 
        // 终止循环判断条件：两者相遇（此时左右游标不能相等）
            int mid = (left+right)/2;
            if(target>nums[mid]) {
                left=mid+1;
            }else if(target < nums[mid]){
                right = mid;// 这里与上面一种情况不同，因为右边为开区间取不到，所以应该在原基础上+1
            }else
                return mid;
        }
        return -1;
    }

力扣704.二分查找

题目链接：704. 二分查找 - 力扣（LeetCode）

题目描述：给定一个 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

解法一）区间边界为左闭右闭

public int search(int[] nums, int target) {
        // 定义两个游标(左闭右闭）
        int left = 0; // 指向数组中首个元素
        int right = nums.length-1; // 指向数组中最后一个元素，length-1
        while(left <= right) { 
        // 终止循环判断条件：两者相遇
            int mid = (left+right)/2; // 从中间值开始查找
            if(target>nums[mid]) { // 目标值大于中间值，往右半部分查找，右游标不动，   
                left=mid+1; // 左游标指向mid+1（mid值已经比较过了，不用重复比较）
            }else if(target < nums[mid]){ // 目标值小于中间值，往左半部分查找，左游标不动，
                right = mid-1;// 右游标指向mid-1（mid值已经比较过了，不用重复比较）
            }else // 目标值等于该值，返回游标mid
                return mid;
        }
        return -1;
    }

解法二）区间边界为左闭右开

public int search(int[] nums, int target) {
        // 定义两个游标(左闭右开）
        int left = 0; // 指向数组中首个元素
        int right = nums.length;  // 指向数组最后一个元素的下一个值length（取不到）
        while(left < right) { 
        // 终止循环判断条件：两者相遇（此时左右游标不能相等）
            int mid = (left+right)/2;
            if(target>nums[mid]) {
                left=mid+1;
            }else if(target < nums[mid]){
                right = mid;// 这里与上面一种情况不同，因为右边为开区间取不到，所以应该在原基础上+1
            }else
                return mid;
        }
        return -1;
    }

力扣35.搜索插入位置

题目链接：35. 搜索插入位置 - 力扣（LeetCode）

题目描述：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。

示例 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的区别在于如果未找到该值，需要在合适的位置进行插入，而此时注定已经跳出循环，即left>=right，故返回left即可

public int searchInsert(int[] nums, int target) {

        // 定义两个游标(左闭右开）
        int left = 0;
        int right = nums.length;
        while(left < right) { 
        // 终止循环判断条件：两者相遇
            int mid = (left+right)/2;
            if(target>nums[mid]) {
                left=mid+1;
            }else if(target < nums[mid]){
                right = mid;
            }else
                return mid;
        }
        return left;// 和704区别在于返回值不同，返回左游标
    }

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

题目链接：34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

题目描述：给你一个按照非递减顺序排列的整数数组 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]

暴力解法（直接遍历数组找目标值）：

public static int[] searchRange(int[] nums, int target) {
        int[] arr=new int[2]; // 存放结果
        arr[0] = -1; // 默认开始和结束位置都为-1
        arr[1] = -1;
        for(int i =0;i<nums.length;i++) { // 遍历数组
            if(nums[i]==target) { // 找到目标值
                if(arr[0]==-1) { // 如果开始位置为默认值，说明目标值第一次出现，将索引赋给开始位置
                    arr[0] =i;
                }else { // 若开始位置已经有值，则赋给结束值，每次遇到目标值会覆盖，直至最后一次
                    arr[1] =i;
                }
            }
        }
        
        
        return arr;
    }

二分查找法：

使用两次二分查找，分别查找左边界和右边界，每个边界的查找方法都是基础的二分查找，区别在于在找到对应索引后，要继续向两侧查找是否有其他目标值存在，如果存在则覆盖

public int[] searchRange3(int[] nums, int target) {
        int leftRange = -1;  // 左边界
        int rightRange = -1;  // 右边界
        leftRange = searchLeft(nums, target, leftRange);  // 查找左边界
        rightRange = searchRight(nums, target, rightRange);  // 查找右边界
        return new int[]{leftRange, rightRange};  // 返回左右边界数组
    }
    // 查找右边界
    private int searchRight(int[] nums, int target, int rightRange) {
        int left = 0;  // 左边界（左闭右闭)
        int right = nums.length - 1;  // 右边界
        int mid = 0;  // 中间位置

        while (left <= right) {
            mid =(left+right)/2;  // 计算中间位置，避免溢出
            if (nums[mid] == target) {
                rightRange = mid;  // 更新右边界为当前位置
                left = mid + 1;  // 继续向右搜索
            } else if (nums[mid] > target) {
                right = mid - 1;  // 目标值在左半部分，更新右边界
            } else {
                left = mid + 1;  // 目标值在右半部分，更新左边界
            }
        }
        return rightRange;  // 返回右边界
    }
 // 查找左边界
    private int searchLeft(int[] nums, int target, int leftRange) {
        int left = 0;  // 左边界
        int right = nums.length - 1;  // 右边界
        int mid = 0;  // 中间位置

        while (left <= right) {
            mid = (left+right)/2;  // 计算中间位置，避免溢出
            if (nums[mid] == target) {
                leftRange = mid;  // 更新左边界为当前位置
                right = mid - 1;  // 继续向左搜索
            } else if (nums[mid] > target) {
                right = mid - 1;  // 目标值在左半部分，更新右边界
            } else {
                left = mid + 1;  // 目标值在右半部分，更新左边界
            }
        }
        return leftRange;  // 返回左边界
    }

力扣69.x的算术平方根

题目链接：69. x 的平方根 - 力扣（LeetCode）

题目描述：给你一个非负整数 x ，计算并返回 x 的算术平方根。由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4

输出：2

示例 2：

输入：x = 8

输出：2

解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

暴力解法（遍历数组）

public int mySqrt(int x) {
        for(int i =0;i<=x;i++) { // 遍历从1-x
            if(i*i==x) { // 如果存在i^2==x,返回i
                return i;
            }else if(i*i>x) { // 找到第一个使i^2>x的值，返回i-1
                 return i-1;
   
            }

二分查找法：

public int mySqrt(int x) {
         if (x == 0) { // 首先考虑x=0或x=1的特殊情况
                return 0;
            }
            if (x == 1) {
                return 1;
            }
            // 左闭右闭
            int left = 1;
            int right = x / 2; //简化写法，在x>1时，x的算术平方根一定小于x/2，可以少比较一半的量
            while (left <= right) {
                int mid = (left + right)/ 2;
                if (mid*mid > x ) { // 找左半边
                    right = mid - 1;
                } else if (mid*mid == x) {// 找到，返回mid
                    return mid;
                } else {// 找右半边
                    left = mid+1;
                }
            }
            return left-1; //同理，需要left-1，或者返回right
    }

代码改进——使用除法运算代替乘法运算：在x的数值较大时，乘法运算mid*mid会产生溢出，导致结果错误

class Solution {
    public int mySqrt(int x) {
        // 特殊值判断
        if (x == 0) {
            return 0;
        }
        if(x == 1) {
            return 1;
        }
        if(x < 0) {
            return -1;
        }
        int left = 0; 
        int right = x / 2; 
        while(left <= right) {
            int mid = left + (right - left + 1) / 2; // 这里使用除法来代替乘法
            if (mid == x / mid) { // 这里使用除法来代替乘法
                return mid;
            } else if(mid > x / mid){ // 这里使用除法来代替乘法
                right = mid - 1;
            } else { 
                left = mid + 1; 
            }
        }
        return left - 1;
    }
}

力扣367.有效的完全平方数

题目链接：367. 有效的完全平方数 - 力扣（LeetCode）

题目描述：给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。完全平方数是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。不能使用任何内置的库函数，如 sqrt 。

示例 1：

输入：num = 16

输出：true

解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。

示例 2：

输入：num = 14

输出：false

解释：返回 false ，因为 3.742 * 3.742 = 14 但 3.742 不是一个整数

改题目是69题的变形，如果找到对应索引值则返回true，否则返回false

 public static boolean isPerfectSquare(int num) {
         if (num == 0) {
                return true;
            }
            if (num == 1) {
                return true;
            }
           
            // 左闭右闭
            int left = 1;
            int right = num / 2;
            while (left <= right) {
                int mid = (left + right)/ 2;
                if (mid*mid > num ) { // 找左半边
                    right = mid - 1;
                } else if (mid*mid == num ) {
                    return true;
                } else {
                    left = mid+1;
                }
            }
         return false;
        }