剑指offer1

剑指offer1

1. 153. 寻找旋转排序数组中的最小值（中等）

https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/

二分

class Solution {
public:
    int findMin(vector<int>& nums) {
         int len = nums.size();
        int l = 0,r = len-1;
        int mid = 0;
        while(nums[l] > nums[r]){
            if(r - l == 1){
                mid = r;
            }
            mid = (l+r)/2;
            if(nums[mid]>nums[l]) l = mid;
            else r = mid;
        }
        return nums[mid];
    }
};

2. 旋转数组的最小数字

https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int len = numbers.size();
        int l = 0,r = len-1;
        int mid = 0;
        while(numbers[l] >= numbers[r]){
            if(r-l == 1){
                mid = r;
                break;
            }
            mid = (l+r)/2;
            //三个数相等，采用顺序查找
            if(numbers[l] == numbers[r] && numbers[mid] == numbers[l]){
                return help(numbers,l,r);
            }
            if(numbers[mid]>=numbers[l]) l = mid;
            else if(numbers[mid]<=numbers[r]) r = mid;
        }
        return numbers[mid];
    }
    int help(vector<int>& numbers,int l,int r){
        int res = numbers[l];
        for(int i=l;i<=r;i++){
            if(numbers[i]<res){
                res = numbers[i];
            }
        }
        return res;
    }
};

3. 搜索旋转排序数组

https://leetcode-cn.com/problems/search-in-rotated-sorted-array/

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        if(len==0) return -1;
        if(len==1 && nums[0]!=target) return -1;
        int l = 0,r = len-1;
        int mid;
        while(l<=r){
            mid = (l+r)/2;
            if(nums[mid] == target){
                return mid;
            }
            //左边有序
            if(nums[mid]>=nums[0]){
                if(nums[0]<=target && target<nums[mid]){
                    r = mid-1;
                }else{
                    l = mid+1;
                }
            }else{
                if(nums[mid]<target && target<=nums[len-1]){
                    l = mid+1;
                }else{
                    r = mid-1;
                }
            }
        }
        return -1;
    }
};

4.搜索旋转排序数组||

https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int len = nums.size();
        if(len==0) return false;
        if(len==1 && nums[0]!=target) return false;
        int l = 0,r = len-1;
        int mid = 0;
        while(l<=r){
            mid = (l+r)/2;
            if(nums[mid]==target) return true;
            if(nums[l]==nums[mid] && nums[mid]==nums[r]){
                l++;
                r--;
            }
            //左边有序
            else if(nums[mid]>=nums[l]){
                if(target>=nums[l] && target<nums[mid]){
                    r = mid-1;
                }else{
                    l = mid+1;
                }
            }else{
                if(target>nums[mid] && target<=nums[r]){
                    l = mid+1;
                }else{
                    r = mid-1;
                }
            }
        }
        return false;
    }
};

5. 搜索旋转数组

https://leetcode-cn.com/problems/search-rotate-array-lcci/

class Solution {
public:
    int search(vector<int>& arr, int target) {
        int len = arr.size();
        if(len==0) return -1;
        if(len==1 && target!=arr[0]) return -1;
        int l = 0,r = len-1;
        int mid;
        while(l<=r){
            if(arr[l]==target) return l;
            mid = (l+r)/2;
            if(arr[mid]==target){
                r = mid;
            }
            else if(arr[0]<arr[mid]){
                if(arr[0]<=target && target<arr[mid]){
                    r = mid-1;
                }else{
                    l = mid+1;
                }
            }
            else if(arr[0]>arr[mid]){
                if(arr[mid]<target && target<=arr[r]){
                    l = mid+1;
                }else{
                    r = mid-1;
                }
            }
            else if(arr[l]==arr[mid]) l++;
        }
        return -1;
    }
};