LeetCode每日一题打卡001——搜索旋转排序数组

1. 二分法

二分法的常见应用是在有序数组中搜索给定的某个目标值的索引，比起使用暴力搜索的方法，它能提供O(logn)的复杂度

二分查找框架1

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

上面这种情况，对于数组中包含有重复的数值的情况就不太方便了，例如给定数组为[3,4,5,5,5,6,6,7]，当然可以先找到第一个符合条件索引，然后向左向右在搜索，但是这样的话，在极端情况下，搜索的时间复杂度就达不到对数级别的了。

对此可以衍生出二分查找的框架2和框架3

二分查找框架2-寻找左侧边界的二分搜索

    int leftBound(vector<int>& nums, int target) {
        if (nums.size() == 0) return -1;
        int left = 0;
        int right = nums.size() - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] == target) {
                right = mid - 1;	//与前面一个不同，这里需要将区间缩小至左半部分，因为要求的是左侧边界
            }
        }
        //target比所有数都大
        if (left == nums.size()) return -1;
        return nums[left] == target ? left : -1;	
    }

二分查找框架3-寻找右侧边界的二分搜索

    int rightBound(vector<int>& nums, int target) {
        if (nums.size() == 0) return -1;
        int left = 0;
        int right = nums.size(); 
        
        while (left < right) {	//左闭右开
            int mid = left + (right - left) / 2;
            if (nums[mid] > target) {
                right = mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else { //nums[mid] == target
                left = mid + 1;
            }
        }
        //return left - 1;	//减一很关键
        if (left == 0) return -1;
        return nums[left -1] == target ? (left - 1) : -1;
    }

LeetCode 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 。
示例 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
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题

对于这样一个数组，一分为二，由此划分两个区间[left, mid]和[mid+1,right]，其中必定有一个区间的有序的，另外一个可能有序，也可能部分有序，有序部分二分查找，无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样一直循环下去。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        if (n == 0) return -1;
        //对数组大小为0和1的情况直接做相应的处理
        if (n == 1) return nums[0] == target ? 0 : -1;
        
        int left = 0, right = n - 1;
        while (left <= right) {	//左闭右闭的区间
            //等价于mid = (left + right) / 2
            //这样写可以防止数值越界
            //假设left和right都是INT_MAX，那么left+right则会发生数值越界的情况
            int mid = left + (right - left) / 2;
            
            if (nums[mid] == target) return mid;

            if (nums[left] <= nums[mid]) { //左边有序
                //判断target是否在[left, mid]区间中
                //因为是闭区间所以下面left和right变化时需要加一或者减一
                if (nums[left] <= target && target < nums[mid]) {
                    right = mid - 1;	//在区间中，则缩小范围
                } else {
                    left = mid + 1;		//不在区间中，则对另外的区间重复前面过程
                }
            } else {    //右边有序	
                //处理过程与左边类似，只是区间缩小的方向不同
                if (nums[mid] < target && target <=nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            
        }
        //没有找到target则返回-1
        return -1;
    }
};