Rotated Sorted Array 大杂烩

https://leetcode.com/problems/search-in-rotated-sorted-array/
给定一个有序数组（数组中无重复数字），数组有一定的翻转，在这个数组中找某一个target
Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

• 解：
  （翻转后，任意找一个mid，mid的左边或者右边一定是有一边是有序的，一定，一定）
  二分，二分，二分，二分的条件：
  当nums[mid] < nums[right] 的时候，默认右边有序，所以当target在nums[mid]和nums[right]之间的时候，就继续在这个区间找,否则就到左边找
  当nums[mid] >= nums[right]的时候，一定是左侧有序了，同理来一遍

    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int mid = 0;

        while (left <= right) {
            mid = (left + right) / 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;
    }

变种题目，Follow Up，如果数组中有重复的数字怎么办

• 解
  请注意，上面的判断有序的条件是否还生效
  当nums[mid] < nums[right] 的时候，默认右边有序 这句话是没问题的，
  当nums[mid] >= nums[right]的时候，一定是左侧有序了 这句话就有问题了，看两个例子
  [3,1,1] ，找3 此时nums[mid] = nums[right] 但是左侧无序，target在mid的左侧
[1,1,3,1],找3，此时mid = 1,right=3 , nums[mid] = nums[right] ,此时左侧有序，但是target在mid的右侧

所以此时的条件是:

1. 当nums[mid] < nums[right] 的时候，默认右边有序，走之前的逻辑没毛病
   2.当nums[mid] > nums[right]的时候，到左边找
   3.当nums[mid] = nums[right]的时候，right--；

 public boolean search2(int[] nums, int target) {
        int i = 0, j = nums.length - 1;
        while (i <= j) {
            int mid = (i + j) / 2;
            if (nums[mid] == target) {
                return true;
            }
            if (nums[mid] < nums[j]) {
                if (nums[mid] < target && nums[j] >= target) {
                    i = mid + 1;
                } else {
                    j = mid - 1;
                }
            } else if (nums[mid] > nums[j]) {
                if (nums[i] <= target && nums[mid] > target) {
                    j = mid - 1;
                } else {
                    i = mid + 1;
                }
            } else {
                j--;
            }
        }
        return false;
    }

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
给定一个有序数组，旋转后，找出这个数组里面的最小值（假定数组里面没有重复的值）
Input: [3,4,5,1,2]
Output: 1

• 解
  二分没毛病，条件怎么取
  当右侧有序的时候，为什么是right=mid,而不是right=mid-1，用一个例子就知道了：nums=[3,1,2]

public int findMin(int[] nums) {
        int n = nums.length;
        int left = 0;
        int right = n - 1;
        while (left < right) {
            int mid = (left + right) / 2;

            //如果右侧有序，则在左边找这个最小值
            if (nums[right] > nums[mid]) {
                right = mid;
            } else {//反之，右侧无序列，在右侧找这个最小值
                left = mid + 1;
            }
        }
        return nums[right];
    }

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/
给定一个有序数组，旋转后，求出这个数组里面的最小值，假定有重复值
Input: [2,2,2,0,1]
Output: 0

  public int findMin(int[] nums) {
         int n = nums.length;
        int left = 0;
        int right = n - 1;
        while (left < right) {
            int mid = (left + right) / 2;

            //如果右侧有序，则在左边找这个最小值
            if (nums[right] > nums[mid]) {
                right = mid;
            } else if (nums[right] < nums[mid]) {//反之，右侧无序列，在右侧找这个最小值
                left = mid + 1;
            } else {
                right--;
            }
        }
        return nums[right];
    }
}