Leetcode: Search in Rotated Sorted Array 理解分析

最新推荐文章于 2022-02-06 18:22:23 发布

原创最新推荐文章于 2022-02-06 18:22:23 发布 · 896 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#rotated sorted array #search target #binary search

题目分析理解专栏收录该内容

44 篇文章

订阅专栏

本文介绍了一种在循环有序数组中使用二分搜索查找目标元素的方法。文章提供了两种实现方式，一种是先判断目标与中间元素的关系再确定数组状态，另一种是先判断数组状态再确定目标范围。

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

题目大意：给定一个有序整型数组，数组中没有重复的数字，数组是可循环的，再给一个target，判断target是否在数组中，在则返回下标，否则返回-1。

理解：1）数组可循环就是说，数组可能是分段有序的，即[1,2,3,4,5,6,7]，给的数组也可能是[6,7,1,2,3,4,5]，或是[3,4,5,6,7,1,2]。

2）在一个可能是分段有序的数组中，查找target，同样可以采用二分搜索的方法。我们分析一下，总共会有三种情况：

[1,2,3,4,5,6]——数组是有序的；

[5,6,1,2,3,4]——Middle在后半段有序范围内；

[3,4,5,6,1,2]——Middle在前半段有序范围内；

实现1：先判断target与a[middle]之间的关系，然后判断数组是哪种情况，递归调用。

public class Solution {
    
    public int func(int[] a, int target, int low, int high) {
        int mid = 0;
        if(low <= high) {
            mid = (low + high) >> 1;
            if(a[mid] == target) return mid;
            else if(target > a[mid]) {
                if(target <= a[high]) {
                    return func(a, target, mid + 1, high);
                }
                else if(target >= a[low]) {
                    if(a[mid] >= a[low] && a[mid] > a[high]) {
                        return func(a, target, mid + 1, high);
                    }
                    else if(a[mid] >= a[low] && a[mid] <= a[high]) return func(a, target, mid + 1, high);
                    else if(a[mid] < a[low] && a[mid] <= a[high]) return func(a, target, low, mid - 1);
                    else return func(a, target, mid + 1, high);
                }
                else return -1;
            }
            else {
                if(target >= a[low]) return func(a, target, low, mid - 1);
                else if(target <= a[high]) {
                    if(a[mid] >= a[low] && a[mid] > a[high]) {
                        return func(a, target, mid + 1, high);
                    }
                    else if(a[mid] >= a[low] && a[mid] <= a[high]) return func(a, target, low, mid - 1);
                    else if(a[mid] < a[low] && a[mid] <= a[high]) return func(a, target, low, mid - 1);
                    else return func(a, target, low, mid - 1);
                }
                else return -1;
            }
        }
        return -1;
    }
    
    public int search(int[] A, int target) {
        if(A == null || A.length == 0)   return -1;
        int len = A.length;
        if(len == 1) {
            if(A[0] == target)  return 0;
            else    return -1;
        }

        return func(A, target, 0, len - 1);
    }
}

实现2：先判断是哪种情况，然后再判断target和a[middle]、a[low]或a[high]之间的关系，得出target所在的范围，再递归调用。这种方法思路要清晰，代码也简洁很多。

public class Solution {
    
    public int find(int[] a,int target,int low,int high) {
        if(low > high) return -1;
        int mid = (low + high) >> 1;
        if(a[mid] == target) return mid;
        if(a[mid] >= a[low] && a[mid] >= a[high]) {
            if(target < a[mid] && target >= a[low]) return find(a, target, low, mid - 1);
            else return find(a, target, mid + 1, high);
        }
        else if(a[mid] <= a[low] && a[mid] <= a[high]) {
            if(target > a[mid] && target <= a[high]) return find(a, target, mid + 1, high);
            else return find(a, target, low, mid - 1);
        }
        else {
            if(target > a[mid] && target <= a[high]) return find(a, target, mid + 1, high);
            else return find(a, target, low, mid - 1);
        }
    }
    
    public int search(int[] A, int target) {
        if(A == null || A.length == 0)   return -1;
        int len = A.length;
        if(len == 1) {
            if(A[0] == target)  return 0;
            else    return -1;
        }
        
        return find(A, target, 0, len - 1);
    }
}