Search in Rotated Sorted Array

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

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

0 ·

CC 4.0 BY-SA版权

LintCode 专栏收录该内容

38 篇文章

订阅专栏

给定一个已按升序排列且在某个未知点旋转的数组，在数组中搜索目标值。如果找到返回其索引，否则返回 -1。解决方案包括分段和优化的二分查找策略。

Search in Rotated Sorted Array

给定旋转数组，找到目标数字。

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.

Example

For [4, 5, 1, 2, 3] and target=1, return 2

For [4, 5,1, 2, 3] and target=0, return -1

Solution:

分段：

    public int search(int[] A, int target) {
        if (A == null || A.length == 0) {
            return -1;
        }
        int mid = 0;
        for (int i = 0; i < A.length - 1; i++) {
            if (A[i] > A[i + 1]) {
                mid = i;
                break;
            }
        }
        int result ;
        result = bs(A, 0, mid, target);
        if (result != -1) {
            return result;
        }
        result = bs(A, mid + 1, A.length - 1, target);
        return result;
    }
    private int bs(int[] A, int start, int end, int target) {
        int mid;
        while (start + 1 < end) {
            mid = start + ((end - start) >> 1);
            if (A[mid] == target) {
                return mid;
            } else if (A[mid] > target) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        if (A[start] == target) {
            return start;
        }
        if (A[end] == target) {
            return end;
        }
        return -1;
    }

首先用遍历的方法找到分割点，然后在在第一段用二分查找。如果没找到，则在第二段里找。

优化：

public int search(int[] A, int target) {
    if(A == null || A.length == 0) {
        return -1;
    }
    int pivot = A.length - 1;
    for(int i = 0; i < A.length - 1; i++) {
        if(A[i] > A[i + 1]) {
            pivot = i;
            break;
        }
    }
    if(target >= A[0]) {
        return bs(A, target, 0, pivot);
    } else if (pivot + 1 < A.length) {
        return bs(A, target, pivot + 1, A.length - 1);
    } else {
        return -1;
    }
}
   
private int bs(int[] A, int target, int start, int end) {
    int mid;
    while(start + 1 < end) {
        mid = start + ((end - start) >> 1);
        if(target < A[mid]) {
            end = mid - 1;
        } else if(target == A[mid]) {
            return mid;
        } else {
            start = mid + 1;
        }
    }
    if(A[start] == target) {
        return start;
    } else if(A[end] == target) {
        return end;
    } else {
        return -1;
    }
}

首先用遍历的方法找到分割点，然后根据target选择二分查找段。index在加1的时候注意溢出。注意pivot的初始值。

不分段：

    public int search(int[] A, int target) {
        if (A == null || A.length == 0) {
            return -1;
        }
        int start = 0;
        int end = A.length - 1;
        int mid;
        while (start + 1 < end) {
            mid = start + ((end - start) >> 1);
            if (A[mid] == target) {
                return mid;
            }
            if (A[start] < A[mid]) {
                if (A[start] <= target && target < A[mid]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {
                if (A[mid] < target && target <= A[end]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }
        }
        if (A[start] == target) {
            return start;
        }
        if (A[end] == target) {
            return end;
        }
        return -1;
    }

思路：

1. 找到转折点，将原array分成两段，分别进行二分查找。要注意转折点可能在起始点，也可能在最末尾（相当于没有转折）。

2. array的两段，一段的值比另一段的值都大。mid要么落在第一段，要么落在第二段。

如果落在前一段，则判断是否在start到mid之间，排除一半。

如果落在后一段，则判断是否在mid到end之间，排除一半。