二分查找

#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;

int binary_search(vector<int>& num, int val){
    int left = 0, right = num.size();
    int mid = 0;
    while(left < right){
        mid = left + (right - left) / 2;
        if(num[mid] == val)
            return mid;
        if(num[mid] < val)
            left = mid + 1;
        else
            right = mid;
    }
    return -1;
}

int binary_search_recursive(vector<int>& num, int left, int right, int val){
    if(left > right)
        return -1;
    int mid = left + (right - left) / 2;
    if(num[mid] == val)
        return mid;
    if(num[mid] < val)
        binary_search_recursive(num, mid + 1, right, val);
    else
        binary_search_recursive(num, left, mid, val);
}
int main(){
    vector<int> num = {1,2,3,4,5,6,7};
    cout << binary_search(num, 5) << endl;
    cout << binary_search_recursive(num, 0, num.size(), 7) << endl;
}

递归复杂度：

递归的次数和深度都是log2 n,每次所需要的辅助空间都是常数级别的： 
时间复杂度 ： O(log2 n) 
空间复杂度：O(log2 n)

迭代复杂度：

循环的基本次数是log2 n，所以:时间复杂度是O(log2 n); 
由于辅助空间是常数级别的所以：空间复杂度是O(1);

 

#include <iostream>
#include <vector>
using namespace std;
//寻找第一个不小于(大于等于)给定值的数
//返回 right - 1，就是最后一个小于目标值的数
int find1(vector<int>& num,int val){
    int left = 0, right = num.size();
    while(left < right){
        int mid = left + (right - left) / 2;
        if(num[mid] < val)
            left = mid + 1;
        else
            right = mid;
    }
    return right;
}
//寻找第一个大于给定值的数
//返回 right - 1，就是最后一个不大于目标值的数
int find2(vector<int>& num,int val){
    int left = 0, right = num.size();
    while(left < right){
        int mid = left + (right - left) / 2;
        if(num[mid] <= val)
            left = mid + 1;
        else
            right = mid;
    }
    return right;
}
int main(){
    vector<int> num1 = {1,2,3,4,5};
    vector<int> num2 = {1,2,2,2,5,6};
    cout << find1(num1, 3) << endl;
    cout << find2(num2, 2) << endl;
}

参考：

https://www.cnblogs.com/grandyang/p/6854825.html