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

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

目录

    • 33. 搜索旋转排序数组
    • 81. 搜索旋转排序数组 II
    • 153. 寻找旋转排序数组中的最小值
    • 154. 寻找旋转排序数组中的最小值 II

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之间
LeetCode4道搜索旋转数组题—33、81、153、154_第1张图片
这时如果
(1)target>=nums[i],则target一定在i~mid这段范围内
(2)targer (3)nums[mid]

3.如果nums[i] LeetCode4道搜索旋转数组题—33、81、153、154_第2张图片
这时如果
(1)target>nums[mid],则target一定在mid~j这段范围内
(2)targer (3)nums[i]<=targer

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

 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之间,因此决策策略和之间是完全一模一样的
LeetCode4道搜索旋转数组题—33、81、153、154_第3张图片
这时如果
(1)target>=nums[i],则target一定在i~mid这段范围内
(2)targer (3)nums[mid]

3.如果nums[i] LeetCode4道搜索旋转数组题—33、81、153、154_第4张图片
这时如果
(1)target>nums[mid],则target一定在mid~j这段范围内
(2)targer (3)nums[i]<=targer

4.特殊的情况是如果nums[i]=nums[mid],这时我们无法判断该往哪边选区间
LeetCode4道搜索旋转数组题—33、81、153、154_第5张图片
LeetCode4道搜索旋转数组题—33、81、153、154_第6张图片
LeetCode4道搜索旋转数组题—33、81、153、154_第7张图片
这时我们只需要舍弃掉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这段区间内
LeetCode4道搜索旋转数组题—33、81、153、154_第8张图片

3.如果nums[i] LeetCode4道搜索旋转数组题—33、81、153、154_第9张图片
这时如果
(1)target>nums[mid],则target一定在mid~j这段范围内
(2)targer (3)nums[i]<=targer

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之间
LeetCode4道搜索旋转数组题—33、81、153、154_第10张图片
3.如果nums[i]LeetCode4道搜索旋转数组题—33、81、153、154_第11张图片
4.特殊的情况是如果nums[i]=nums[mid],首先记录下此时的最小值nums[i],这时我们无法判断最小值到底该往哪边选区间
LeetCode4道搜索旋转数组题—33、81、153、154_第12张图片
LeetCode4道搜索旋转数组题—33、81、153、154_第13张图片
LeetCode4道搜索旋转数组题—33、81、153、154_第14张图片
这时我们只需要舍弃掉i这个点即可,也就是仍然直接i++,在剩下的区间中再去找最小值。

你可能感兴趣的:(LeetCode,算法)