二分查找

基本上是这三种模板
总结下给自己备用

具体看这个:https://leetcode-cn.com/leetbook/read/binary-search/xewjg7/

基础版

int search(int* nums, int numsSize, int target){
    int left = 0,right = numsSize-1,mid;
    while(left <= right)
    {
        mid = left+(right-left)/2;
        if(nums[mid]==target)
            return mid;
        else if(nums[mid]<target)
            left = mid+1;
        else
            right = mid-1;
    }
    return -1;
}

二分查找的最基础和最基本的形式。
查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。
不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素.

进阶版

它用于查找需要访问数组中当前索引及其直接右邻居索引的元素或条件。

int search(int* nums, int numsSize, int target){
    int left = 0,right = numsSize-1,mid;
    while(left<right)
    {
        mid = left+(right-left)/2;
        if(nums[mid]==target)
            return mid;
        else if(nums[mid]<target)
            left = mid+1;
        else
            right = mid;
    }
    if(nums[left]==target)
        return left;
    return -1;
}

一种实现二分查找的高级方法。
查找条件需要访问元素的直接右邻居。
使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。
保证查找空间在每一步中至少有 2 个元素。
需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件.

例子:

int findPeakElement(int* nums, int numsSize){
    int left = 0,right = numsSize-1,mid;
    while(left<right)
    {
        mid = left+(right-left)/2;
        if(nums[mid]<nums[mid+1])
            left = mid+1;
        else
            right = mid;
    }
    return left;
}

具体看这里:https://leetcode-cn.com/problems/find-peak-element/solution/xun-zhao-feng-zhi-by-leetcode/

int findMin(int* nums, int numsSize){
    int left = 0,right = numsSize-1,mid;
    while(left<right)
    {
        mid = left+(right-left)/2;
        if(nums[left]<nums[right])//说明是递增的
            return nums[left];
        else if(nums[mid]>nums[right])
            left = mid+1;//向右找
        else
            right = mid;//向左找
    }
    return nums[left];
}

特殊版

模板 3 是二分查找的另一种独特形式。 它用于搜索需要访问当前索引及其在数组中的直接左右邻居索引的元素或条件。

int search(int* nums, int numsSize, int target){
    int left = 0,right = numsSize-1,mid;
    while(left+1<right)
    {
        mid = left+(right-left)/2;
        if(nums[mid]==target)
            return mid;
        else if(nums[mid]<target)
            left = mid;
        else
            right = mid;
    }
    if(nums[left]==target)
        return left;
    if(nums[right] == target)
        return right;
    return -1;
}

一种实现二分查找的高级方法。
查找条件需要访问元素的直接右邻居。
使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。
保证查找空间在每一步中至少有 2 个元素。
需要进行后处理。 当你剩下 1 个元素时，循环 / 递归结束。 需要评估剩余元素是否符合条件。

例子:

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* searchRange(int* nums, int numsSize, int target, int* returnSize){
    *returnSize = 2;
    int *res = (int*)malloc(sizeof(int)*2);
    res[0] = res[1] = -1;
    if(numsSize==0)
        return res;
    int left = 0,right = numsSize-1,mid;
    while(left+1<right)//找左边的第一个值
    {
        mid = left+(right-left)/2;
        if(nums[mid]>=target)
            right = mid;
        else
            left = mid;
    }
    if(nums[left]==target||nums[right]==target)//在最后两个里面找靠左边的
        res[0] = nums[left]==target?left:right;
    left = 0;
    right = numsSize-1;
    while(left+1<right)//找右边的第一个值
    {
        mid = left+(right-left)/2;
        if(nums[mid]>target)
            right = mid;
        else
            left = mid;
    }
    if(nums[left]==target||nums[right]==target)//同理找靠右边的
        res[1] = nums[right]==target?right:left;
    return res;
}