在翻转数组中查找给定值 Search in Rotated Sorted Array

为什么80%的码农都做不了架构师？>>>   

问题：

Suppose an array sorted in ascending order 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.

解决：

① http://www.cnblogs.com/grandyang/p/4325648.html

这道题让在旋转数组中搜索一个给定值，若存在返回坐标，若不存在返回- 1。使用二分搜索法，但是这道题的难点在于我们不知道原数组在哪旋转了，我们还是用题目中给的例子来分析，对于数组[0 1 2 4 5 6 7] 共有下列七种旋转方法：

0　　1　　2　　 4　　5　　6　　7
7　　0　　1　　 2　　4　　5　　6
6　　7　　0　　 1　　2　　4　　5
5　　6　　7　　 0　　1　　2　　4
4　　5　　6　　 7　　0　　1　　2
2　　4　　5　　 6　　7　　0　　1
1　　2　　4　　 5　　6　　7　　0

二分搜索法的关键在于获得了中间数后，判断下面要搜索左半段还是右半段，我们观察上面红色的数字都是升序的，由此我们可以观察出规律，如果中间的数小于最右边的数，则右半段是有序的，若中间数大于最右边数，则左半段是有序的，我们只要在有序的半段里用首尾两个数组来判断目标值是否在这一区域内，这样就可以确定保留哪半边了。

class Solution {//16ms
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
            if(nums[mid] < nums[right]){//右半段是递增的，一定要先判断右半段，考虑3，2，1这样的情况
                if(nums[mid] < target && nums[right] >= target) left = mid + 1;//目标在右半段
                else right = mid - 1;//在左半段
            }else{//左半段是递增的
                if(nums[left] <= target && nums[mid] > target) right = mid - 1;
                else left = mid + 1;
            }
        }
        return -1;
    }
}

② 括号还是挺重要的，可以提高效率。

class Solution {//14ms
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
            if(nums[mid] < nums[right]){//右半段是递增的
                if(nums[mid] < target && nums[right] >= target) {
                    left = mid + 1;//目标在右半段
                }else {
                    right = mid - 1;//在左半段
                }
            }else{//左半段是递增的
                if(nums[left] <= target && nums[mid] > target){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }
        }
        return -1;
    }
}

【注】输入为[3,2,1]，3时，折半查找时结果错误会输出-1。

③ 所以对判断条件进行了修改。

class Solution{
    public static int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left) / 2 + left;
            if (nums[mid] == target){
                return mid;
            }
            if (nums[mid] < nums[right]){
                if (mid + 1 < nums.length && nums[mid + 1] <= target && target <= nums[right]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }else{
                if (mid - 1 >= 0 && nums[left] <= target && target <= nums[mid - 1]){
                    right = mid - 1;
                }else {
                    left = mid + 1;
                }
            }
        }
        return -1;
    }
}

④ 直接扫描数组查找。

class Solution {//15ms
    public int search(int[] nums, int target) {     
        for(int i = 0; i < nums.length; i++) {
            if (nums[i] == target)
                return i;
        }
        return -1;
    }
}

 

转载于:https://my.oschina.net/liyurong/blog/1527929