一起玩转 LeetCode 704.二分查找

704.二分查找

力扣题目链接：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

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

思路

这道题目是要在有序数组 nums 中找到目标值 target，符合二分查找的前提条件（线性表必须是有序的，且采用顺序存储）。同时题目还强调数组中无重复元素（若有重复元素，则使用二分查找法返回的元素下标可能不唯一）。

基于上述条件，这道题可以使用二分查找寻找目标值。 二分查找的做法是，定义查找的范围 [left, right]，初始查找范围是整个数组，每次取查找范围的中点 middle，比较 nums[middle] 和 target 的大小，如果相等，则 middle 就是要寻找的下标，如果 nums[middle] > target，则 taget 只可能在 middle 的左侧，如果 nums[middle] < target，则 taget 在 middle 的右侧。

这样每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是 O(logn)，其中 n 是数组的长度。

二分查找的条件是查找范围不为空，如果 target 在数组中，二分查找可以保证找到 target，返回 target 在数组中的下标。如果 target 不在数组中，则返回 -1。

二分法（左闭右闭区间）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // 避免当 target 小于 nums[0] 或者 target 大于 nums[nums.size() - 1]时多次循环运算
        if(nums[0] > target || nums[nums.size() - 1] < target) {
            return -1;
        }
 
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
 
        while(left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) >> 1); // 防止溢出 等同于(left + right)/2
            if(nums[middle] == target) { // 找到目标值，直接返回下标
                return middle;
            }else if(nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            }else { // nums[middle] > target
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            }
        }
        return -1; // 未找到目标值
    }
};

• 时间复杂度：O(log n)
• 空间复杂度：O(1)

二分法（左闭右开区间）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // 避免当 target 小于 nums[0] 或者 target 大于 nums[nums.size() - 1]时多次循环运算
        if(nums[0] > target || nums[nums.size() - 1] < target) {
            return -1;
        }
 
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，[left, right)
 
        while(left < right) { // 当left==right时，在区间[left, right)是无效的，所以用 <
            int middle = left + ((right - left) >> 1); // 防止溢出 等同于(left + right)/2
            if(nums[middle] == target) { // 找到目标值，直接返回下标
                return middle;
            }else if(nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right)
            }else { // nums[middle] > target
                right = middle; // target 在左区间，所以[left, middle)
            }
        }
        return -1; // 未找到目标值
    }
};

• 时间复杂度：O(log n)
• 空间复杂度：O(1)

二分法（递归）(左闭右闭区间)

class Solution {
public:
    int binary(vector<int>& nums, int left, int right, int target) {
        if (nums[0] > target || nums[nums.size() - 1] < target) {
            return -1;
        }

        if (left > right) {
            return -1;
        }

        int middle = left + ((right - left) >> 1);
        if (nums[middle] == target) {
            return middle;
        } else if(nums[middle] < target) {
            return binary(nums, middle + 1, right, target);
        } else {
            return binary(nums, left, middle - 1, target);
        }
    }

    int search(vector<int>& nums, int target) {
        return binary(nums, 0, nums.size() - 1, target);
    }
};

• 时间复杂度：O(log n)
• 空间复杂度：O(log n)

二分法（递归）(左闭右开区间)

class Solution {
public:
    int binary(vector<int>& nums, int left, int right, int target) {
        if (nums[0] > target || nums[nums.size() - 1] < target) {
            return -1;
        }
 
        if (left >= right) {
            return -1;
        }
 
        int middle = left + ((right - left) >> 1);
 
        if (nums[middle] == target) {
            return middle;
        } else if (nums[middle] < target) {
            return binary(nums, middle + 1, right, target);
        } else {
            return binary(nums, left, middle, target);
        }
    }

    int search(vector<int>& nums, int target) {
        return binary(nums, 0, nums.size(), target);
    }
  
};

• 时间复杂度：O(log n)
• 空间复杂度：O(log n)

总结

二分查找有点类似分治思想。即每次都通过跟区间中的中间元素对比，将待查找的区间缩小为一半，直到找到要查找的元素，或者区间被缩小为 0。

二分查找的代码实现容易写错。需要注意三个容易出错的地方：

1. 循环退出条件；
2. middle 的取值；
3. left 和 right 的更新。

二分查找虽然性能比较优秀，但应用场景也比较有限。底层必须依赖数组，并且还要求数据是有序的。如果数据未排序，则必须进行排序才能够使用。

对于其他的数据结构，例如链表，如果使用二分查找，每次比较都必须遍历链表寻找中间节点，时间复杂度会很高。

二分查找更适合处理静态数据，也就是没有频繁的数据插入、删除操作。而且，它更适合用在数据量较大的场景，如果数据量太小，直接顺序遍历即可。