二分查找

二分查找

方法：不断二分查找空间，直到空间缩小为0或找到目标值。

时间复杂度：n = 2^k->O(logn)
n为数据量，k为查找次数，故时间复杂度为logn。对数时间复杂度非常高效，如2^32的数据规模，最多只需查找32次即可找到目标值，在某些情况下比O（1）时间复杂度效率更高，如O（1）的常系数较大时，效率可能会较低。

实现：非递归&递归

public:
int bsearch(vector<int>& a, int n, int value) 
{ 
	int low = 0; int high = n - 1; 
	while (low <= high) 
	{ 
		int mid = (low + high) / 2; 
		if (a[mid] == value) { return mid; } 
		else if (a[mid] < value) { low = mid + 1; } 
		else { high = mid - 1; }
	} 
	return -1; //没有找到目标值
}

注意:
(1)while中的条件为low <= high不是low < high。
(2)mid = (low + high) / 2，当low和high比较大时可能会溢出，用mid = low + (high-low)/2比较好（或mid = low + ((high-low)>>1)。PS：注意加法运算符优先级高于右移运算符，记得加括号。
(3)low = mid + 1和high = mid - 1如果写成low = mid和high = mid当low == high时会出现死循环。

适用场合：
二分查找适用条件：
（1）有序数据。
（2）支持随机访问访问的顺式结构（数组）。
故以下场合不适用：
（1）数据频繁增删。需不断排序进行查找，维护有序数据成本较大，二分查找更适用于静态数据。
（2）数据量太小。当数据量较小时直接遍历，二分查找优势不明显（当比较过程较为耗时，如超长字符串比较，需要减少比较次数时还是二分查找比较好）。
（3）数据量太大。当数据量太大时，由于二分查找只适用于顺式结构，需要连续的空间，故不适合使用二分查找。

四种常见的二分查找变形问题

有序数据集合中存在重复的数据
（1）查找第一个值等于给定值的元素

int bsearch(vector<int>& nums,int value)
    {
        int low = 0,high = nums.size() - 1;
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(nums[mid] < value) low = mid+1;
            else if(nums[mid] > value) high = mid - 1;
            else{
                if((mid == 0) || (nums[mid - 1] != value)) return mid;
                else high = mid - 1;
            }
        }
        return -1;
    }

（2）查找最后一个值等于给定值的元素

int bsearch(vector<int>& nums,int value)
    {
        int low = 0,high = nums.size() - 1;
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(nums[mid] < value) low = mid+1;
            else if(nums[mid] > value) high = mid - 1;
            else{
                if((mid == nums.size() - 1) || (nums[mid + 1] != value)) return mid;
                else low = mid + 1;
            }
        }
        return -1;
    }

（3）查找第一个大于等于给定值的元素

int bsearch(vector<int>& nums,int value)
    {
        int low = 0,high = nums.size() - 1;
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(nums[mid] < value) low = mid+1;
            else 
            {
            	if((mid == 0)||(nums[mid - 1] < value)) return mid;
            	else high = mid - 1;
            }
        }
        return -1;
    }

（4）查找最后一个小于等于给定值的元素

int bsearch(vector<int>& nums,int value)
    {
        int low = 0,high = nums.size() - 1;
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(nums[mid] < value)
            {
            	if((mid == nums.size() - 1) || (nums[mid+1] > value)) return mid;
            	else low = mid + 1;
            }
            else high = mid - 1;
        }
        return -1;
    }

剑指 Offer 57. 和为s的两个数字
题目描述：
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

限制：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6

解：
1> 暴力遍历
2> 哈希表
3> 双指针

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {

        int left = 0;
        int right = nums.size() - 1;

        //二分查找target附近的数，缩小数组范围
        int midIndex;
        while(left <= right)
        {
            midIndex = (left+right)/2;
            if(nums[midIndex] >= target) right = midIndex-1;
            else left = midIndex+1;
        }
        
        left=0;

        //双指针遍历求和
        int sum;
        while(left < right)
        {
            sum = nums[left] + nums[right];
            if(sum < target) left++;
            else if (sum > target) right--;
            else return {nums[left],nums[right]};
        }
        return {}; //未找到目标值
    }
};