搜索旋转数组

需求：

    假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。假设，数组中没有重复数字。

分析：

    按照二分法进行求解。定义min、max、mid分别代表开始、结束、中间元素角标，和传统的二分法不同的是，每次求完mid值之后，需要判断mid位于左子数组还是右子数组，进而和目标值比较，更新min和max。

代码：

public class Solution {
    /*
     * @param A: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    public int search(int[] A, int target) {
        // write your code here
        /*
        //思路一：使用集合
        if(A == null || A.length == 0){
            return -1;
        }
        
        ArrayList<Integer> al = new ArrayList<Integer>();
        
        for(int i = 0; i < A.length; i++){
            al.add(A[i]);
        }
        
        return al.indexOf(target);
        */
        //二分法
        if(A == null || A.length < 0){
            throw new IllegalArgumentException("invalid parameters");
        }
        
        //数组长度是0，不包含目标值，返回-1
        if(A.length == 0){
            return -1;
        }
        //长度是1，将目标值和0角标元素比较，相同返回0，不相同返回-1
        if(A.length == 1){
            return A[0] == target? 0: -1;
        }
        
        int min = 0, max = A.length-1, mid = 0;
        while(min <= max){
            mid = (min + max) / 2;
            
            if(A[mid] == target){
                return mid;
            }
            
            //当中间值在左边子数组中
            if(A[mid] > A[min]){
                if(A[min] <= target && target < A[mid]){
                    max = mid-1;
                }
                else{
                    min = mid+1;
                }
            }
            else{
                //中间值在右边子数组中
                if(A[mid] < target && target <= A[max]){
                    min = mid+1;
                }
                else{
                    max = mid-1;
                }
            }
        }
        
        return -1;
    }
}

拓展：

如果上述数组中有重复元素，该如何处理？

分析：

目前只想到了一种方法，借鉴求旋转数组中的最小值方法。在没有重复元素时，很容易判断mid在左子数组中还是右子数组中，如果有重复元素，就不容易判断mid属于哪个子数组，因此当mid、min、max三个元素重复的时候，需要进行顺序查找。

代码：

public class Solution {
    /*
     * @param A: an integer ratated sorted array and duplicates are allowed
     * @param target: An integer
     * @return: a boolean 
     */
    public boolean search(int[] A, int target) {
        // write your code here
        //如果有重复元素，会影响复杂度，会变大。
        if(A == null || A.length < 0){
            throw new IllegalArgumentException("invalid parameters");
        }
        
        if(A.length == 0){
            return false;
        }
        if(A.length == 1){
            return A[0]==target? true: false;
        }
        
        int min = 0, max = A.length-1, mid = 0;
        while(min <= max){
            mid = (min+max)/2;
            
            if(A[mid] == target){
                return true;
            }
            
            //如果三个值相同，无法判断mid在左右子数组中，需要顺序查找
            if(A[mid] == A[min] && A[min] == A[max]){
                return find(A, target);
            }
            
            if(A[mid] >= A[min]){
                if(A[min] <= target && target < A[mid]){
                    max = mid-1;
                }
                else{
                    min = mid+1;
                }
            }
            else{
                if(A[mid] < target && target <= A[max]){
                    min = mid+1;
                }
                else{
                    max = mid-1;
                }
            }
        }
        return false;
    }
    
    public boolean find(int[] arr, int target){
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == target){
                return true;
            }
        }
        
        return false;
    }
}