二分查找合集

在刷题时经常会用到二分，虽然每次磕磕绊绊的也都能写出来，可是也没去做个总结。今天又遇到了，我就做个总结吧。

在一个有序数组中，查找一个值为key的数，返回它的下标，若存在多个返回任意一个即可，若不存在就返回-1；

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

在一个有序数组中，查找一个值为key的数，返回第一个值大于或等于key的数的下标,若不存在就返回-1；

int FirstGreaterOrEqualNumber(vector<int> a, int key){
    int len = a.size();
    int left = 0, right = len - 1, mid;
    while(left <= right){
        mid = (left + right) / 2;
       if(a[mid] < key){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return left < len ? left : -1;
}

在一个有序数组中，查找第一个值大于key的数的下标,若不存在就返回-1；
与上段代码唯一的不同就是if判断那多了个=。

int FirstGreaterNumber(vector<int> a, int key){
    int len = a.size();
    int left = 0, right = len - 1, mid;
    while(left <= right){
        mid = (left + right) / 2;
       if(a[mid] <= key){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return left < len ? left : -1;
}

在一个有序数组中，查找第一个值小于key的数的下标,若不存在就返回-1；

int FirstLessKeyNumber(vector<int> a, int key){
    int len = a.size();
    int left = 0, right = len - 1, mid;
    while(left <= right){
        mid = (left + right) / 2;
       if(a[mid] < key){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return left - 1 < 0 ? -1 : left - 1;
}

在一个有序数组中，查找一个值为key的数，返回第一个值等于key的数的下标,若不存在就返回-1；

int GetFirstIndexEqualKey(vector<int> a, int key){
    int len = a.size();
    int left = 0, right = len - 1, mid;
    while(left <= right){
        mid = (left + right) / 2;
       if(a[mid] < key){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return (left < len && a[left] == key) ? left : -1;
}

在一个有序数组中，查找一个值为key的数，返回最后一个值等于key的数的下标,若不存在就返回-1；

int GetLastIndexEqualKey(vector<int> a, int key){
    int len = a.size();
    int left = 0, right = len - 1, mid;
    while(left <= right){
        mid = (left + right) / 2;
       if(a[mid] <= key){
            left = mid + 1;
        }else{
            right = mid - 1;
        }
    }
    return (left - 1 >= 0 && a[left - 1] == key) ? left - 1 : -1;
}

在一个有序数组中，查找一个值为key的数出现的次数，若不存在就返回-1；
这个可以结合先查找第一个值为key的数的下标，然后查找第一个大于值key的数的下标，两下标相减即可。