Leetcode: Search in Rotated Sorted Array

最新推荐文章于 2024-05-03 20:14:24 发布

原创最新推荐文章于 2024-05-03 20:14:24 发布 · 515 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

216 篇文章

订阅专栏

本文深入分析了在已知旋转点的情况下，如何优化二分查找算法来高效搜索旋转排序数组中的目标值。通过将数组分为两部分，并利用中间元素与两端元素的关系进行判断，从而减少搜索范围，实现复杂度为O(log(n)log(n))的时间效率。文章还讨论了错误处理情况，即左边界大于右边界时的返回值，并提供了递归和循环两种实现方式的代码对比。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Get idea from Code Ganker′s (优快云) Solution, and Leetcote article

Question

Suppose a sorted array 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.

Analysis

There is a property that we can take advantage of. We divide it as two parts based on the pivot element(assume we know it), part A and B. For instance, in [3,4,5,1,2], part A is [3,4,5], B is [1,2]

If middle one is larger than left most one, we can conclude that the size of part A is greater than B. So elements in range [left, middle] must be in strictly increasing order. And then we can decide which part should be to search according to the target element.

Complexity
Since we reduce the array by half each time, the complexity will be in O( $log(n)$ )

Solution

Mistake Taken

I failed to take into consideration that left is less than right.
In this case, -1 should be returned.

Code

class Solution:
    # @param {integer[]} nums
    # @param {integer} target
    # @return {integer}
    def search(self, nums, target):
        if len(nums)==0 or target==None:
            return -1

        return self.subsearch(nums, target, 0, len(nums)-1 )

    def subsearch(self, nums, target, left, right):
        mid = (left + right)/2
        if nums[mid]==target:
            return mid

        # size of right portion is larger than left portion
        if nums[mid] < nums[right]:
            if target>nums[mid] and target<=nums[right]:
                left = mid + 1
            else:
                right = mid - 1
        else:
            if target>=nums[left] and target<nums[mid]:
                right = mid - 1
            else:
                left = mid + 1

        if left > right:
            return -1
        else:
            return self.subsearch(nums,target,left,right)

Other′s Code (using loop)

public int search(int[] A, int target) {  
    if(A==null || A.length==0)  
        return -1;  
    int l = 0;  
    int r = A.length-1;  
    while(l<=r)  
    {  
        int m = (l+r)/2;  
        if(target == A[m])  
            return m;  
        if(A[m]<A[r])  
        {  
            if(target>A[m] && target<=A[r])  
                l = m+1;  
            else  
                r = m-1;  
        }  
        else  
        {  
            if(target>=A[l] && target<A[m])  
                r = m-1;  
            else  
                l = m+1;                      
        }  
    }  
    return -1;  
}