leetcode-Search in Rotated Sorted Array -java

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.

编程属于计算机科学，计算机科学的理念有优秀的设计，但是不管是什么，归根结底都是0，1问题，这就是我们的根基。

题目，有问题，原子化，解决～～～

注意：算法题和我们的日常生活一样，应当先归类，再寻找相应的解题思路。比如这个题目，属于查找，你想到了什么？

和其他题目一样，没有时间复杂度的要求，所以o(n)：

    public int search(int[] A, int target) {

        int length = A.length;
        int i = 0;
        int reslut = -1;
        while (i < length) {
            if (A[i] == target) {
                reslut = i;
                break;
            }
            i++;
        }
        return reslut;
    }

查找算法中，以二分查找较为高效，这是我们很自然可以想到的。虽然本题已经不是基本的有序情况，不过依然可以使用二分查找的概念来做这个题，二分查找的理念来源于递归的思路，首先要确定的就是部分与整体的关联性！

以为在本题中你不知道pivot，数组肯定是由2个升序的排列，但是你不知道中间的连接点在哪里，如果将数组一分为二，那么将是一个为升序数组，另一个于初始情况相同。不难理解这样完全可以递归操作了，现在要做的是区分二者。

升序情况A[0]<A[length]；非升序情况（由于前提的循环二字）A[0]>A[length];

当然如果两个都是升序了，那说明我们已经完美的分离了2个升序，更加方便了。

这样算法复杂度就降到了o(logn):

    
    public int search(int[] A, int target) {
        int i = 0;
        int length = A.length;
        return RotatedBinarySearch(A, i, length - 1, target);
    }

    // 普通二分查找
    public int BinarySearch(int[] A, int a, int b, int target) {

        int middle = (a + b) / 2;
        if (A[middle] == target) {
            return middle;
        } else if ((A[middle] < target) && (middle + 1 <= b)) {
            return BinarySearch(A, middle + 1, b, target);
        } else if ((A[middle] > target) && (middle - 1 >= a)) {
            return BinarySearch(A, a, middle - 1, target);
        } else {
            return -1;
        }
    }

    // 循环数组的二分查找
    public int RotatedBinarySearch(int[] A, int a, int b, int target) {

        int middle = (a + b) / 2;
        if (A[middle] == target) {
            return middle;
        } else if (middle + 1 <= b && A[middle + 1] <= A[b]) {
            if ((A[middle + 1] <= target) && (target <= A[b])) {
                return BinarySearch(A, middle + 1, b, target);
            } else if (middle - 1 >= a) {
                return RotatedBinarySearch(A, a, middle - 1, target);
            } else {
                return -1;
            }
        } else if (middle - 1 >= a && A[middle - 1] >= A[a]) {
            if ((A[middle - 1] >= target) && (target >= A[a])) {
                return BinarySearch(A, a, middle - 1, target);
            } else if (middle + 1 <= b) {
                return RotatedBinarySearch(A, middle + 1, b, target);
            } else {
                return -1;
            }

        } else {
            return -1;
        }
    }