LeetCode练习题33、153

33. 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -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

搜索旋转排序数组

方法一：暴力法

int search(int* nums, int numsSize, int target){
    for(int i = 0; i < numsSize; i++) {
        if(nums[i] == target) {
            return i;
        }
    }
    return -1;
}

时间复杂度为O(n) 不符合题意

方法二：二分查找

如果 target 在[mid+1,high] 序列中，则low = mid+1,否则 high = mid,关键是如何判断 target在[mid+1,high]序列中,具体判断如下：
当[0, mid] 序列是升序: nums[0] <= nums[mid], 当target > nums[mid] || target < nums[0] ,则向后规约
当[0, mid] 序列存在旋转位: nums[0] > nums[mid],当nums[0] > target > nums[mid],则向后规约
当然其他其他情况就是向前规约了

int search(int* nums, int numsSize, int target){
    int low = 0;
    int high = numsSize-1;
    while(low < high) {
        int mid = (low + high) / 2;
        if(nums[0] <= nums[mid] && (target > nums[mid] || target < nums[0])) {
            low = mid + 1;
        }    // 当[0,mid]有序时,向后规约条件
        else if(nums[0] > nums[mid] && (target > nums[mid] && target < nums[0])) {
            low = mid + 1;
        }    // 当[0,mid]发生旋转时，向后规约条件
        else {
            high = mid;
        }
    }
    if(low == high && nums[low] == target) {
        return low;
    }
    else {
        return -1;
    }
}

153. 寻找旋转排序数组中的最小值

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。

示例 1:
输入: [3,4,5,1,2]
输出: 1

示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0

寻找旋转排序数组中的最小值

方法一：快排

void QuickSort(int *a, int low, int high) {
    if(low < high) {
        int i = low;
        int j = high;
        int t = a[low];
        while(i < j) {
            while(i < j && a[j] >= t) {j--;}
            if(i < j) {a[i] = a[j];}
            while(i < j && a[i] <= t) {i++;}
            if(i < j) {a[j] = a[i];}
        }
        a[i] = t;
        QuickSort(a, low, i-1);
        QuickSort(a, i+1, high);
    }
}
int findMin(int* nums, int numsSize){
    QuickSort(nums, 0, numsSize-1);
    return nums[0];
}

方法二：二分法

1. 左值 < 中值< 右值 ：没有旋转，最小值在最左边
2. 若 nums[low] <= nums[mid]，说明区间 [low,mid] 连续递增，则最小元素一定不在这个区间里，可以直接排除。因此，在 [mid+1,high] 继续查找
3. 若 nums[low] > nums[mid]，说明区间 [low,mid] 不连续，则最小元素一定在这个区间里。因此，在 [low,mid] 继续查找
   [left,right] 表示当前搜索的区间。

int findMin(int* nums, int numsSize){
    int low = 0;
    int high = numsSize-1;
    while(low <= high) {
        if(nums[low] <= nums[high]) {
            return nums[low];
        }  //递增直接返回最小值
        int mid = (low + high) /2;
        if(nums[low] <= nums[mid]) {
            low = mid+1;
        }    //连续区间
        else {
            high = mid;
        }   //不连续区间
    }
    return -1;
}