LeetCode 704.二分查找

LeetCode 704.二分查找

1、题目

题目链接：704. 二分查找

2、思路

这道题目是要在有序数组 nums 中找到目标值 target，符合二分查找的前提条件（线性表必须是有序的，且采用顺序存储）。同时题目还强调数组中无重复元素（若有重复元素，则使用二分查找法返回的元素下标可能不唯一）。
基于上述条件，这道题可以使用二分查找寻找目标值。
二分查找的做法是，定义查找的范围 [left, right]，初始查找范围是整个数组，每次取查找范围的中点 middle，比较 nums[middle] 和 target 的大小，如果相等，则 middle 就是要寻找的下标，如果 nums[middle] > target，则 target 只可能在 middle 的左侧，如果 nums[middle] < target，则 target 在 middle 的右侧。
这样每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是 O(logn)，其中 n 是数组的长度。
二分查找的条件是查找范围不为空，如果 target 在数组中，二分查找可以保证找到 target，返回 target 在数组中的下标。如果 target 不在数组中，则返回 -1。

3、二分法（左闭右闭区间）

代码：

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 的更新。

二分查找虽然性能比较优秀，但应用场景也比较有限。底层必须依赖数组，并且还要求数据是有序的。如果数据未排序，则必须进行排序才能够使用。
对于其他的数据结构，例如链表，如果使用二分查找，每次比较都必须遍历链表寻找中间节点，时间复杂度会很高。
二分查找更适合处理静态数据，也就是没有频繁的数据插入、删除操作。而且，它更适合用在数据量较大的场景，如果数据量太小，直接顺序遍历即可。