Leetcode 34 二分或者lower_bound / upper_bound用法

思路1：线性检索

思路2：利用上下界函数，写法简洁较快

思路3：在时间复杂度log n内的二分法【也是本题目的要求】，解释一下，正常用二分是可以查找到相等，就返回了，但是本题中先查找左边界，就是说当我用二分查找到了与target值一样的数字后，不停止，用 left 临时保存下标，继续向左部分二分查找target，直至搜索结束，这时候的left一定是左边界，因为只要查找到了新的值与target一致，left一定会被跟新，所以left被跟新说明此题有边界，若left是初始的-1，说明此题没有与target一致的值，返回{-1，-1}，左边界好了，继续进行右边界，相当于用了两次二分查找，两次二分的区别在于查找到了mid与target相等，一个继续向左找（左边界），一个继续向右找（右边界）

思路1：
class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(!nums.size())return { -1,-1 };
        vector<int>::iterator p = find(nums.begin(), nums.end(), target);//获取第一个元素
        if (p == nums.end())return { -1,-1 };
        pair<int, int>res;
        res.first = p - nums.begin();
        while (p != nums.end()&&*p==target)p++;
        res.second = (--p) - nums.begin();
        return { res.first,res.second };
    }
};

思路2：
class Solution {
public:

    vector<int> searchRange(vector<int>& nums, int target) {
        if(!nums.size())return { -1,-1 };
        vector<int>::iterator begin = lower_bound(nums.begin(), nums.end(), target);//获取上界
        vector<int>::iterator end =upper_bound(nums.begin(), nums.end(), target);//获取下界
        if (begin==end)return { -1,-1 };//要清楚为啥相等是搜索不到的情形
            return { (int)(begin - nums.begin()),(int)(end - nums.begin()) - 1 };
     }
};

对于begin==end解释：

// lower_bound/upper_bound example
#include <iostream>     // std::cout
#include <algorithm>    // std::lower_bound, std::upper_bound, std::sort
#include <vector>       // std::vector

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};
  std::vector<int> v(myints,myints+8);           // 10 20 30 30 20 10 10 20
  std::sort (v.begin(), v.end());                // 10 10 10 20 20 20 30 30  std::vector<int>::iterator low,up;
  low=std::lower_bound (v.begin(), v.end(), 20); //          
  up= std::upper_bound (v.begin(), v.end(), 20); //      std::cout << "lower_bound at position " << (low- v.begin()) << '\n';
  std::cout << "upper_bound at position " << (up - v.begin()) << '\n';

  return 0;
}

lower_bound在位置3 upper_bound在位置6 边界都是[ ) 左闭右开

思路3：

# include<iostream>
# include<vector>
# include<string>
# include<algorithm>
# include<math.h>
# include<climits>
# include<stack>
# include<queue>
using namespace std;

vector<int> searchRange(vector<int>& nums, int target) {
	if(!nums.size())return { -1,-1 };
	//思路：两次二分，第一次找左边，第二次找右边
	int i, j, mid,l,r;
	i = 0; j = nums.size();//左闭右开
	l = -1; r = -1;
	while (i < j) {//找左边 
		mid = (i + j) / 2;
		while (i < j && nums[mid] != target) {//一次二分找到第一个数字，确定非左边		
			if (nums[mid] > target) {//中位数比目标大，目标在左边，向左搜索
				j = mid;
				mid = (i + j) / 2;
			}
			else {//向右边搜索
				i = mid + 1;
				mid = (i + j) / 2;
			}
		}
		if (i < j) {//说明是mid位置等于target出来的
			l = mid;//暂时保存
			//继续向左搜索
			j = mid;
		}
	}
	//没有搜索到的情况
	if (l == -1) return { -1,-1 };
	//搜索到了左边最小的位置就是l
	i = 0; j = nums.size();//左闭右开
	while (i < j) {//找右边
		mid = (i + j) / 2;
		while (i < j && nums[mid] != target) {//一次二分找到第一个数字，确定非左边
			if (nums[mid] > target) {//中位数比目标大，目标在左边，向左搜索
				j = mid;
				mid = (i + j) / 2;
			}
			else {//向右边搜索
				i = mid + 1;
				mid = (i + j) / 2;
			}
		}
		if (i < j) {//说明是mid位置等于target出来的
			r = mid;//暂时保存
			//继续向右搜索
			i = mid + 1;
		}
	}
	return { l,r };
}
int main(void) {
	vector<int>nums;
	nums.push_back(2);
	nums.push_back(2);
	nums.push_back(3);
	vector<int> v = searchRange(nums, 3);
	cout << v[0]<<v[1];
	system("pause");
	return  0;
}