4.23算法题（二分查找）

今天的算法题以二分查找为主。

力扣33.搜索旋转排序数组

33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• nums 中的每个值都 独一无二
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -104 <= target <= 104

题目分析

升序数列，查找一个target，时间复杂度为 O(log n) ，我们使用二分法解答。

解题思路

这道题与经典二分法不同的地方在于，这个数组将后面部分的元素旋转到前面来了，导致整个数组并不是标准的升序数组。但其实对我们使用二分法的影响不大，我们只需要分清楚target在数组中的位置分几种情况就可以。我们先将二分法的开头打出来（定义left，right，while循环，定义mid），我们这里使用闭区间做法。接下来我们开始分析target在数组中的几种情况：

1. nums[mid]==target：直接返回mid。
2. **数组的left小于mid：**我们首先可以确定mid及其以前的数组肯定是升序的，是旋转得来的，因为未旋转的数组部分都会小于旋转数组的第一个元素。如数组[4,5,6,7,0,1]，此时mid（=2，为6）及其以前的数组元素全是旋转得来的。因此我们可以列出nums[mid]>target&&nums[left]<=target的情况：在这个情况下的target位于升序数组中，正常二分法操作让right=mid-1;即可。如果target不在这个情况内，我们就移动left=mid+1，接下来就会转到第3种的情况中。
3. **数组的left大于mid：**与上一种情况类似的推理，我们可以确定mid及其以后的数组肯定是升序的，是未旋转的部分。如数组[4,5,-2,-1,0,1,2]，此时mid（=3，为-1）及其以后的数组全是未旋转的。因此我们可以列出nums[mid]<target&&nums[right]>=target的情况：在这个情况下的target位于升序数组中，正常二分法操作让left=mid+1;即可。如果target不在这个情况内，我们就移动left=mid+1，接下来就会转到第2种的情况中。

情况分完了，依次用if判断填入循环中即可。while循环结束后，如果没有找到target，就返回-1。

代码实现

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

力扣34.在排序数组中查找元素的第一个和最后一个位置

34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

题目分析

数组中有重复元素，因此这道题需要使用两次二分法，用来确定左边界和右边界。

解题思路

这道题也不像传统二分查找一样只查找一个target元素，而是要查找到target元素开始出现的地址和最后出现的地址。并且这道题里面的数组元素会重复，这也是不能直接使用二分法的原因之一，因为如果查找的target出现了两次及以上，二分法便没法传出一个准确的地址。因此我们需要在使用二分法时，添加对重复元素开始出现和最后出现的位置进行判断。

因为要使用两次二分法，所以我们列两个函数，分别求出左边界和右边界。二分法的开头还是不变，定义完mid后，我们就要对重复元素位置进行判断。以searchLeftBorder为例，当出现nums[mid]==target的情况时，我们一定要判断此时的mid是不是target第一次出现的位置。我们的判断方式为：先将mid的值赋给LeftBorder，**然后移动right到mid的前一位。**如果mid的前一位元素值不是target，那么前面对LeftBorder的赋值就是正确的，等循环结束返回LeftBorder即可；如果mid的前一位元素值还是target，那么此时nums[right]的值就还为target，不会漏掉target先前出现的地址，接着进行循环，直到mid的前一位元素值不是target为止。

searchRightBorder的情况与上面类似。列完两个函数后，在主函数中引用得到左右边界的地址，再创建一个新的两位元素的数组，将左右边界赋值给新数组，输出即可。

代码实现

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int searchLeftBorder(int *nums, int numsSize, int target){
    int left=0,right=numsSize-1;
    int LeftBorder=-1;
    while(left<=right){
        int mid=left+(right-left)/2;
        if(nums[mid]==target){
            LeftBorder=mid;
            right=mid-1;
        }else if(nums[mid]<target){
            left=mid+1;
        }
        else right=mid-1;
    }
    return LeftBorder;
}

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

int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
    int* returnNums=(int*)malloc(sizeof(int)*2);
    int RightBorder=searchRightBorder(nums, numsSize, target);
    int LeftBorder=searchLeftBorder(nums, numsSize, target);
    *returnSize=2;
    returnNums[0]=LeftBorder;
    returnNums[1]=RightBorder;
    return returnNums;
}