力扣热题 100：二分查找专题经典题解析_力扣二分查找的题-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_72686196/article/details/146112240

系列文章目录

文章目录

在力扣（LeetCode）平台上，二分查找相关的题目是算法面试和练习中的重要部分。今天，我们就来详细解析二分查找专题中的几道经典题目，帮助大家更好地理解解题思路和技巧。

一、搜索插入位置（题目 35）

1. 题目描述

给定一个排序数组和一个目标值，找到目标值在数组中的索引。如果目标值不存在，返回它应该插入的位置。

2. 示例

示例 1：

输入：nums = [1, 3, 5, 6], target = 5

输出：2

示例 2：

输入：nums = [1, 3, 5, 6], target = 2

输出：1

3. 解题思路

这道题主要考察二分查找的应用。我们可以使用二分查找来找到目标值的位置，如果目标值不存在，则返回插入位置。具体步骤如下：

初始化两个指针 left 和 right，分别指向数组的起始和末尾。
计算中间位置 mid，比较 nums[mid] 和 target 的大小。
如果 nums[mid] 等于 target，返回 mid。
如果 nums[mid] 小于 target，则将 left 指针移动到 mid + 1。
如果 nums[mid] 大于 target，则将 right 指针移动到 mid - 1。
遍历结束后，返回 left 指针的位置，即为插入位置。

4. 代码实现（Java）

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

5. 复杂度分析

时间复杂度 ：O(log n)，其中 n 是数组的长度。二分查找的时间复杂度为对数级别。
空间复杂度 ：O(1)，只使用了常数级别的额外空间。

二、搜索二维矩阵（题目 74）

1. 题目描述

给定一个二维矩阵，每行和每列都按升序排列。判断目标值是否存在于矩阵中。

2. 示例

示例 1：

输入：matrix = [[1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 60]], target = 3

输出：true

3. 解题思路

这道题主要考察二分查找的应用。我们可以将二维矩阵视为一个一维数组，然后使用二分查找来判断目标值是否存在。具体步骤如下：

计算矩阵的行数和列数。
初始化两个指针 left 和 right，分别指向一维数组的起始和末尾。
计算中间位置 mid，将其转换为矩阵中的行和列索引。
比较 matrix[midRow][midCol] 和 target 的大小，调整 left 和 right 指针。
遍历结束后，判断是否找到目标值。

4. 代码实现（Java）

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int rows = matrix.length;
        if (rows == 0) {
            return false;
        }
        int cols = matrix[0].length;
        int left = 0, right = rows * cols - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            int midRow = mid / cols;
            int midCol = mid % cols;
            if (matrix[midRow][midCol] == target) {
                return true;
            } else if (matrix[midRow][midCol] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return false;
    }
}

5. 复杂度分析

时间复杂度 ：O(log(m * n))，其中 m 和 n 分别是矩阵的行数和列数。二分查找的时间复杂度为对数级别。
空间复杂度 ：O(1)，只使用了常数级别的额外空间。

三、在排序数组中查找元素的第一个和最后一个位置（题目 34）

1. 题目描述

给定一个按非递减顺序排列的整数数组 nums 和一个目标值 target，找出目标值在数组中的第一个和最后一个位置。如果目标值不存在，返回 [-1, -1]。

2. 示例

示例 1：

输入：nums = [5, 7, 7, 8, 8, 10], target = 8

输出：[3, 4]

3. 解题思路

这道题主要考察二分查找的应用。我们需要分别找到目标值的第一个和最后一个位置。具体步骤如下：

使用二分查找找到目标值的左边界（第一个位置）。
使用二分查找找到目标值的右边界（最后一个位置）。
如果左边界和右边界都存在，则返回 [left, right]；否则，返回 [-1, -1]。

4. 代码实现（Java）

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = new int[]{-1, -1};
        result[0] = findFirst(nums, target);
        result[1] = findLast(nums, target);
        return result;
    }

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

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

5. 复杂度分析

时间复杂度 ：O(log n)，其中 n 是数组的长度。二分查找的时间复杂度为对数级别。
空间复杂度 ：O(1)，只使用了常数级别的额外空间。

四、搜索旋转排序数组（题目 33）

1. 题目描述

给定一个旋转排序数组，在其中查找一个目标值。如果存在，返回其索引；否则，返回 -1。

2. 示例

示例 1：

输入：nums = [4, 5, 6, 7, 0, 1, 2], target = 0

输出：4

3. 解题思路

这道题主要考察二分查找的应用。旋转排序数组可以分为两部分有序的子数组。我们可以利用这一特性，通过二分查找来判断目标值所在的区间。具体步骤如下：

初始化两个指针 left 和 right，分别指向数组的起始和末尾。
计算中间位置 mid，比较 nums[mid] 和 target 的大小。
如果 nums[mid] 等于 target，返回 mid。
如果 nums[left] 到 nums[mid] 是有序的，判断 target 是否在该区间内，调整 left 和 right 指针。
否则，调整 left 和 right 指针到另一部分区间。
遍历结束后，返回 -1。

4. 代码实现（Java）

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

5. 复杂度分析

时间复杂度 ：O(log n)，其中 n 是数组的长度。二分查找的时间复杂度为对数级别。
空间复杂度 ：O(1)，只使用了常数级别的额外空间。

五、寻找旋转排序数组中的最小值（题目 153）

1. 题目描述

给定一个旋转排序数组，找到其中的最小值。

2. 示例

示例 1：

输入：nums = [3, 4, 5, 1, 2]

输出：1

3. 解题思路

这道题主要考察二分查找的应用。旋转排序数组的最小值是数组中的旋转点。我们可以使用二分查找来找到这个旋转点。具体步骤如下：

初始化两个指针 left 和 right，分别指向数组的起始和末尾。
计算中间位置 mid，比较 nums[mid] 和 nums[right] 的大小。
如果 nums[mid] 大于 nums[right]，说明最小值在右半部分，调整 left 指针到 mid + 1。
否则，调整 right 指针到 mid。
遍历结束后，nums[left] 即为最小值。

4. 代码实现（Java）

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

5. 复杂度分析

时间复杂度 ：O(log n)，其中 n 是数组的长度。二分查找的时间复杂度为对数级别。
空间复杂度 ：O(1)，只使用了常数级别的额外空间。

六、寻找两个正序数组的中位数（题目 4）

1. 题目描述

给定两个正序数组 nums1 和 nums2，找到它们的中位数。

2. 示例

示例 1：

输入：nums1 = [1, 3], nums2 = [2]

输出：2.00000

示例 2：

输入：nums1 = [1, 2], nums2 = [3, 4]

输出：2.50000

3. 解题思路

这道题主要考察二分查找的应用。我们需要找到两个数组的中位数，可以通过将两个数组合并为一个有序数组，然后找到中位数。但这种方法的时间复杂度较高。更高效的方法是使用二分查找来找到中位数的位置。具体步骤如下：

确保较短的数组作为第一个数组，较长的数组作为第二个数组。
使用二分查找在较短的数组上进行查找，找到合适的分割点。
计算两个数组的分割点，并比较左右部分的大小，调整二分查找的范围。
当找到合适的分割点时，计算中位数。

4. 代码实现（Java）

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length) {
            int[] temp = nums1;
            nums1 = nums2;
            nums2 = temp;
        }
        int m = nums1.length;
        int n = nums2.length;
        int left = 0, right = m;
        while (left <= right) {
            int i = left + (right - left) / 2;
            int j = (m + n + 1) / 2 - i;
            int maxLeft1 = (i == 0) ? Integer.MIN_VALUE : nums1[i - 1];
            int minRight1 = (i == m) ? Integer.MAX_VALUE : nums1[i];
            int maxLeft2 = (j == 0) ? Integer.MIN_VALUE : nums2[j - 1];
            int minRight2 = (j == n) ? Integer.MAX_VALUE : nums2[j];
            if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
                if ((m + n) % 2 == 1) {
                    return Math.max(maxLeft1, maxLeft2);
                } else {
                    return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0;
                }
            } else if (maxLeft1 > minRight2) {
                right = i - 1;
            } else {
                left = i + 1;
            }
        }
        return 0.0;
    }
}