LeetCode#33. Search in Rotated Sorted Array

• 题目：给定一个升序数组，将该数组从某个位置旋转，得到新的数组，求一个int类型的target在旋转后的数组中的位置
• 难度：Medium
• 思路：一个有序数组在某个位置旋转后，使得数组分成两部分（每一部分自身是有序的），所以同样可以采用二分查找的思想.
  
  • 定义两个指针left，right，初始值分别为0和nums.length-1;
  • 定义mid=(left+right)/2
  • 如果nums[mid] > nums[low],说明数组的前半部分是有序，通过比较target和nums[low],nums[mid]的大小，调整left和low的位置
  • 如果nums[mid] < nums[high],说明数组的后半部分是有序，通过比较target和nums[mid],nums[high]，调整left和low的位置
• 代码：

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

方法二：先找到数组中最小元素的下标

public class Solution {    public int search(int[] nums, int target) {        if(nums == null || nums.length == 0){            return -1;        }        int minIndex = findMin(nums);        if(target == nums[minIndex]){            return minIndex;        }        int len = nums.length;        int left = (target <= nums[len-1]) ? minIndex:0;        int right = (target > nums[len-1]) ? minIndex:len-1;        System.out.println(left + "-" + right);        while(left <= right){            int mid = left + (right-left)/2;            if(target == nums[mid]){                return mid;            }else if(target < nums[mid]){                right = mid-1;            }else{                left = mid+1;            }        }        return -1;    }    private int findMin(int[] nums){        int left = 0;        int right = nums.length-1;        while(left < right){            int mid = left + (right-left)/2;            if(nums[mid] < nums[right]){                right = mid;//此处end不是等于mid+1，是因为nums[mid]可能就是最小值            }else{                left = mid+1;            }        }        System.out.println(left);        return left;    }}

方法三：

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