二分查找法（C++篇）

二分查找法

正常实现

设计一个二分查找函数，传入一个升序的vector容器和一个keys，返回keys唯一对应的下标。

Input : [1,2,3,4,5]

key : 3

return the index : 2

public int binarySearch(vector<int> nums, int keys)
{
	# 从两端向中间走
    int l = 0, h = nums.length - 1;
    while(l <= h)
    {
        int m = l + (h - l) / 2; 	// 查找范围内的中间下标
        if(nums[m] == key)			// 找到key对应的下标
            return m;
        else if(nums[m] > key)
            h = m - 1;
        else
            l = m + 1;
    }
    return -1;
}

个人解读：从两端往中间走，通过一个循环，即判断查找范围的左端是否<=右端，当左端=右端时，并且nums[m]==keys时，即找到并返回该下标，否则该vector中不存在keys这个元素，返回-1。

m 计算

有两种计算中值 m 的方式：

• m = (l + h) / 2
• m = l + (h - l) / 2

l + h 可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。

但是 l 和 h 都为正数，因此 h - l 不会出现加法溢出问题。所以，最好使用第二种计算法方法。

变种

public int binarySearch(vector<int> nums, int key) 
{
    int l = 0, h = nums.length - 1;
    while (l < h) 
    {
        int m = l + (h - l) / 2;
        if (nums[m] >= key) 
            h = m;
        else 
            l = m + 1;
    }
    return l;
}

该实现和正常实现有以下不同：

• h 的赋值表达式为 h = m

• 循环条件为 l < h

• 最后返回 l 而不是 -1

  在 nums[m] >= key 的情况下，可以推导出最左 key 位于 [l, m] 区间中，这是一个闭区间。

  h 的赋值表达式为 h = m，因为 m 位置也可能是解。

  在 h 的赋值表达式为 h = m 的情况下，如果循环条件为 l <= h，那么会出现循环无法退出的情况，因此循环条件只能是 l < h。以下演示了循环条件为 l <= h 时循环无法退出的情况：

  nums = {0, 1, 2}, key = 1
  l   m   h
  0   1   2  nums[m] >= key
  0   0   1  nums[m] < key
  1   1   1  nums[m] >= key
  1   1   1  nums[m] >= key
  ...
  

总结：正常实现和对应的变种的原理是相同的，区别仅仅是每次循环的时候，左端和右端的偏移情况，正常实现对应的是在中间下标基础上，左端右移一位，右端左移一位；变种对应的是在中间下标基础上，左端右移一位，右端不移动。这就造成了循环条件的不同（是否带上=），至于使用时的选择，看您的喜好了，我个人更偏向于第一种。

下面直接上两道题目实战一波：

1、给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:

输入: [3,3,7,7,10,11,11]
输出: 10

注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行，考虑二分查找法。

(来源于leetcode第540题)

class Solution 
{
public:
    int singleNonDuplicate(vector<int>& nums) 
    {
        int l = 0;
        int h = nums.size() - 1;
        //二分查找
        while(l < h)
        {
            int mid = l + (h - l)/2;
            if(mid % 2 == 1)               //防止mid是奇数，是的话则左移一位，为确保mid是偶数
                mid--;
            if(nums[mid] == nums[mid+1])   //说明目标数在[mid+2,h]
                l = mid + 2;
            else                           //否则目标数在[l,mid]
                h = mid;
        } 
        return nums[l];   
    }
};

2、给定一个按照升序排列的整数数组 nums，和一个目标值 target。

找出给定目标值在数组中的开始位置和结束位置。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

class Solution 
{
public:
    vector<int> searchRange(vector<int>& nums, int target) 
    {
        if(nums.empty())  return {-1,-1};
        int l = 0, h = nums.size() - 1;
        int ans1, ans2;   
        //找左端
        while(l < h)
        {
            int mid = l + (h - l)/2;
            if(nums[mid] >= target)  
                h = mid;
            else
                l = mid + 1;
        }
        if(nums[l] != target)
            return {-1,-1};
        ans1 = l;
        //找右端
        h = nums.size();
        while(l < h)
        {
            int mid = l + (h - l)/2;
            if(nums[mid] <= target) 
                l = mid + 1;
            else
                h = mid;
        }
        ans2 = l - 1;
        return {ans1,ans2};
    }
};