leetcode 腾讯精选练习（50 题）33.搜索旋转排序数组

原题目

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm’s runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

思路

第一遍解法

网上好的解法

class Solution {
public:
    int search(int A[], int n, int target) {
        int lo=0,hi=n-1;
        // find the index of the smallest value using binary search.
        // Loop will terminate since mid < hi, and lo or hi will shrink by at least 1.
        // Proof by contradiction that mid < hi: if mid==hi, then lo==hi and loop would have been terminated.
        while(lo<hi){ 
            int mid=(lo+hi)/2;
            if(A[mid]>A[hi]) lo=mid+1;
            else hi=mid;
        }
        // lo==hi is the index of the smallest value and also the number of places rotated.
        int rot=lo;
        lo=0;hi=n-1;
        // The usual binary search and accounting for rotation.
        while(lo<=hi){
            int mid=(lo+hi)/2;
            int realmid=(mid+rot)%n;  //○的思想，数组转了几个位置 mid 跟着转几个位置
            if(A[realmid]==target)return realmid;
            if(A[realmid]<target)lo=mid+1;
            else hi=mid-1;
        }
        return -1;
    }
};

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int hi = nums.size();
        int lo = 0;

        while(lo < hi){
             const int mid = lo + hi >> 1; 
            
            bool section_start = nums[0] > nums[mid];
            bool target_section = nums[0] > target;
            if(section_start == target_section){
                
            if( nums[mid] > target ) hi = mid;
                else  lo = mid + 1;    
                
            }else if( target_section ) lo = mid + 1; 
                else hi = mid;
                
             if ( target == nums[mid] ) return mid;
        }
        return -1;
    };
};

class Solution:
    def search(self, nums, target):
        if nums == None or len(nums) == 0:
            return -1
        low, high = 0, len(nums)-1
        while low + 1 < high:
            mid = (low + high) // 2
            if target == nums[mid]:
                return mid
            if nums[low] < nums[mid]:  # 前半段递增有序
                if nums[low] <= target <= nums[mid]:  # 传统二分查找
                    high = mid
                else:  # target 小于 nums[low] 或者大于 nums[mid]
                    low = mid
            else:  # 后半段递增有序 
                if nums[mid] <= target <= nums[high]:  # 传统二分查找
                    low = mid
                else:  # target 小于 nums[mid] 或者大于 nums[high]
                    high = mid
        if nums[low] == target: 
            return low
        if nums[high] == target:
            return high
        return -1

class Solution:
    def search(self, nums, target):
        return -1 if target not in nums else nums.index(target)

自己可以改进的地方

最简代码

获得的思考