LeetCode4道搜索旋转数组题—33、81、153、154

LeetCode有4道搜索旋转数组的题目，这里一起说了。

33. 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
———————————————————————————————————————————————
看到log n就知道要用二分法，我先把最常见的二分法放进来：

public static int binarySort(int[] nums,int t){
        int i=0,j=nums.length-1;
        int mid=i+(j-i)/2;
        while(i<=j){
            if(nums[mid]==target){
                return mid;
            }
            if(nums[mid]>target){
                j=mid-1;
            }else{
                i=mid+1;
            }
            mid=i+(j-i)/2;
        }
        return -1;
    }

常见的二分法是完全有序，这题虽然旋转了，但是不影响有序性，只是选择区间的方式不同。
选择区间的方式是：
1.首先比较nums[i]和nums[mid]的大小关系
2.如果nums[i]>nums[mid]，则说明拐点一定在i和mid之间

这时如果
（1）target>=nums[i]，则target一定在i~mid这段范围内
（2）targer<nums[mid]，则targer也一定在i~mid这段范围内
（3）nums[mid]<targer<nums[i]，则target一定在mid~j这段范围内

3.如果nums[i]<nums[mid]，则说明从i到mid这段区域一定是升序的

这时如果
（1）target>nums[mid]，则target一定在mid~j这段范围内
（2）targer<nums[i]，则targer也一定在mid~j这段范围内
（3）nums[i]<=targer<nums[mid]，则target一定在i~mid这段范围内

总结上述的原理，对二分查找进行改造：

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

81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:
输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
———————————————————————————————————————————————
81题跟33题的差别在于数组内可以有重复的数字，但是主题思想还是用二分查找，只是根据实际情况有所调整。
选择区间的方式是：
1.首先比较nums[i]和nums[mid]的大小关系
2.如果nums[i]>nums[mid]，则说明拐点一定在i和mid之间，因此决策策略和之间是完全一模一样的

这时如果
（1）target>=nums[i]，则target一定在i~mid这段范围内
（2）targer<nums[mid]，则targer也一定在i~mid这段范围内
（3）nums[mid]<targer<nums[i]，则target一定在mid~j这段范围内

3.如果nums[i]<nums[mid]，则说明从i到mid这段区域一定是升序的，决策策略也和之前是一模一样的

这时如果
（1）target>nums[mid]，则target一定在mid~j这段范围内
（2）targer<nums[i]，则targer也一定在mid~j这段范围内
（3）nums[i]<=targer<nums[mid]，则target一定在i~mid这段范围内

4.特殊的情况是如果nums[i]=nums[mid]，这时我们无法判断该往哪边选区间



这时我们只需要舍弃掉i这个点即可，也就是直接i++
因为既然nums[i]=nums[mid]≠target，那i点对我们来说就无用了，直接舍弃掉i，直到i和mid有大小关系时就可以用前2个方法来判断。
修改一下上题的代码：

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

153. 寻找旋转排序数组中的最小值

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
示例 1:
输入: [3,4,5,1,2]
输出: 1
示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0
———————————————————————————————————————————————
这时33题的变种，其实按照前2题的思路，就大概可以知道，把最小值当做一次targer查找，只是这个target永远比我们找到的数还要小而已。

选择区间的方式是：
1.首先比较nums[i]和nums[mid]的大小关系
2.如果nums[i]>nums[mid]，记录此时获得的最小数nums[mid]
如果还存在更小值，那只能在i~mid这段区间内

3.如果nums[i]<nums[mid]，记录此时的最小数nums[i]，如果还存在更小值，则只能在mid~j这段区间内

这时如果
（1）target>nums[mid]，则target一定在mid~j这段范围内
（2）targer<nums[i]，则targer也一定在mid~j这段范围内
（3）nums[i]<=targer<nums[mid]，则target一定在i~mid这段范围内

4.如果nums[i]=nums[mid]，这是一个特殊情况，因为不存在重复的数，所以如果i和mid相等的话，只能说明只剩两个数了，这时可以直接让i++，让i和j都变成j对应的位置，这样就可以把i和j都比较一遍，不然会错过j这个数。
改造一下代码：

public int findMin(int[] nums) {
		int i=0,j=nums.length-1;
        int mid=i+(j-i)/2;
        int min=nums[0];
        while(i<=j){
            if(nums[i]<nums[mid]){
                min=Math.min(min,nums[i]);
                i=mid+1;
            }else if(nums[i]>nums[mid]){
                min=Math.min(min,nums[mid]);
                j=mid-1;
            }else{
                min=Math.min(min,nums[mid]);
                i++;
            }
            mid=i+(j-i)/2;
        }
        return min;
    }

154. 寻找旋转排序数组中的最小值 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
注意数组中可能存在重复的元素。
示例 1：
输入: [1,3,5]
输出: 1
示例 2：
输入: [2,2,2,0,1]
输出: 0
———————————————————————————————————————————————
先说结论，这题的代码和上一题一模一样，完全一模一样。
选择区间的方式是：
1.首先比较nums[i]和nums[mid]的大小关系
2.如果nums[i]>nums[mid]，记录此时的最小值nums[mid]，此时若存在更小值，则一定在i~mid之间

3.如果nums[i]<nums[mid]，记录此时的最小值nums[i]，若存在更小值，则只能在mid~j这段区间
4.特殊的情况是如果nums[i]=nums[mid]，首先记录下此时的最小值nums[i]，这时我们无法判断最小值到底该往哪边选区间



这时我们只需要舍弃掉i这个点即可，也就是仍然直接i++，在剩下的区间中再去找最小值。