算法（三）数组之二分法

leetcode

[hot] 33. 搜索旋转排序数组

题目

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的索引，否则返回 -1 。

示例 1：

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

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
示例 3：

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

题解

通过二分法解决问题，首先确定搜索范围，之后l和r指针不断缩小范围，从而找到最终结果，示例代码如下所示：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int length = nums.size();
        if (length == 0) {
            return -1;
        }

        int l = 0;
        int r = length - 1;

        // 必须有等号，否则会有元素被漏查
        while (l <= r) {
            int mid = (l + r) / 2;
            if (target == nums[mid]) {
                return mid;
            }

            // 左半边有序
            if (nums[l] <= nums[mid]) {
                // 左闭右开: 左->有机会左越界，右->有机会直接抵达mid
                if (nums[l] <= target && target < nums[mid]) {
                    r = mid - 1; // mid依然不符合要求，r要越过mid
                } else {
                    l = mid + 1; // nums[l] > target or target > nums[mid]， l要越过mid
                }
            } else {
                // 左开右闭: 左->有机会直接抵达mid， 右->有机会越界
                if (nums[mid] < target && target <= nums[r]) {
                    l = mid + 1; // mid依然不符合要求，l要越过mid
                } else {
                    r = mid - 1; // nums[mid] > target or target > nums[r]， r要越过mid
                }
            }
        }

        return -1;
    }
};

复杂度

时间复杂度：$O(logn)$，二分查找时间复杂度
空间复杂度：$O(1)$，二分查找空间复杂度

关键点

理解旋转数组的核心特点，有两种类型：

1. 前半段有序 -> nums[l] <= nums[mid]， 例如2,3,4,5,6,7,1 这种，如果target落在前半段（判断条件是num[l] <= target < nums[mid]），可以在前半段找，否则可以在后半段找。
2. 后半段有序 -> nums[l] > nums[mid]，例如 6,7,1,2,3,4,5 这种，如果target落在前半段（判断条件是num[mid] < target <= nums[r]），可以在前半段找，否则可以在后半段找。

[hot] 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]

题解

二分法探索左右边界，找到第一个大于等于target的位置和第一个大于target的位置，并解决问题。示例代码如下所示：

class Solution {
public:
    int bi_search(bool lower, vector<int>& nums, int target) {
        if(nums.empty()){
			return -1;
        }
        int lo = 0;
        int hi = nums.size() - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            bool control = nums[mid] <= target;
            if (lower) {
                control = nums[mid] < target;
            }
            if (control) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
        
        return lo;

    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int l = bi_search(true, nums, target);
        int r = bi_search(false, nums, target) - 1;
        if (l >= 0 && r < nums.size() && l <= r && nums[l] == nums[r]) {
            return {l, r};
        }

        return {-1, -1};
    }
};

复杂度

时间复杂度：$O(logn)$
空间复杂度：$O(1)$

[hot] 35. 搜索插入位置

题目

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

请必须使用时间复杂度为 O(log n) 的算法。

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

题解

其实本身就是要找到数组中第一个大于等于target的位置，示例代码如下所示：

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int l = 0;
        int r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] < target) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }

        return l;
    }
};

复杂度

时间复杂度：$O(logn)$
空间复杂度：$O(1)$

[hot] 153. 寻找旋转排序数组中的最小值

题目

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组 {3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。

题解

由于数组有序，则可以通过二分法解决问题，因为即便是数组的一部分旋转到后面，两段内的数据依然是有序的。这里沿用leetcode官方网站上的题解思路，示例代码如下：

class Solution {
public:
    int findMin(vector<int>& numbers) {
        int length = numbers.size();
        int low = 0;
        int high = length - 1;

        while (low < high) {
            int m = (low + high) / 2;
            // 不能让high = m - 1，因为有可能会错过最小值
            if (numbers[m] < numbers[high]) {
                high = m;
            } else {
                low = m + 1;
            }
        }

        return numbers[low];
    }
};

复杂度

时间复杂度：$O(logn)$，二分查找时间复杂度
空间复杂度：$O(1)$，二分查找空间复杂度

剑指offer

53 II. 0～n-1中缺失的数字

题目

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2
示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

题解

数组有序的情况下寻找指定元素，多用二分法，套用二分法的惯用思路，分如下五步走：

1. while循环结束条件 -> low <= high or low < high，因为这里需要考虑到low == high时函数的返回值，因而这里while循环结束的条件是low <= high(demo case: [0, 1, 3])
2. 循环中mid的取值 -> mid = (low + high) / 2。
3. 缩减范围时low的取值 -> 当nums[mid] == mid时，mid以左包含mid在内都是符合要求元素，因而这时low需要等于mid + 1。
4. 缩减范围时high的取值 -> 当nums[mid] != mid时，mid以右包含mid在内都是不符合要求元素，但如果mid == 0 or nums[mid - 1] == mid - 1，这时mid就是target，直接返回即可。
5. return时返回值 -> mid or 0 or nums.size()。

示例代码如下：

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int low = 0;
        int high = nums.size() - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (nums[mid] != mid) {
                if (mid == 0 || nums[mid - 1] == mid - 1) {
                    return mid;
                }
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        if (low == nums.size()) {
            return low;
        }

        return -1;
    }
};

复杂度

时间复杂度：$O(logn)$，二分查找时间复杂度
空间复杂度：$O(1)$，二分查找空间复杂度

57. 数组中数值和下标相等的元素

题目

假设一个单调递增的数组里的每个元素都是整数并且是唯一的。请编程实现一个函数找出数组中任意一个数值等于其下标的元素。例如，在数组{-3, -1, 1, 3, 5}中，数字3和它的下标相等。

题解

常规二分查找解决问题。示例代码如下：

class Solution {
public:
    int findNumber(vector<int>& nums) {
        int length = nums.size();
        if (length == 0) {
            return -1;
        }

        int low = 0;
        int high = length - 1;
        while (low <= high) { // 等号是核心
            int mid = (low + high) / 2;
            if (nums[mid] > mid) {
                high = mid - 1;
            } else if (nums[mid] < mid) {
                low = mid + 1;
            } else {
                return mid;
            }
        }

        return -1;
    }
};

复杂度

时间复杂度：$O(logn)$，二分查找时间复杂度
空间复杂度：$O(1)$，二分查找空间复杂度