旋转排序数组问题---153. 寻找旋转排序数组中的最小值&&33. 搜索旋转排序数组&&81. 搜索旋转排序数组 II

博客主要探讨了LeetCode中的3道旋转排序数组问题，包括153. 寻找旋转排序数组中的最小值、33. 搜索旋转排序数组以及81. 搜索旋转排序数组 II。文章详细分析了解题思路，并提供了Java代码实现，强调了在处理旋转数组时如何利用二分查找优化算法效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

开篇闲话，由于忙于准备找工作，其实我是有每天刷算法题的，但感觉写博客很耗时间，所以一直没有在博客中记录。春招找的让我差点得抑郁症了，贼难受。投了40多家公司了，但目前只有六七家提供了笔试机会，学历以及自己简历的项目经历没有优势，另外互联网寒冬更是雪上加霜。。。
许愿：希望春招能拿个让自己满意的offer！！！哈哈哈，开始迷信一把了！！！

旋转排序数组问题—153. 寻找旋转排序数组中的最小值&&33. 搜索旋转排序数组&&81. 搜索旋转排序数组 II

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

1. 题目
题目链接

2. 题目分析
旋转数组，实际上就是左右整体互换，也就导致出现了两个递增序列。
无重复数组
3. 解题思路
如果直接遍历查找，时间复杂度是O(n)，不符合要求，题目要求O(logn)。部分有序+O(logn)的条件，暗示这个查找可以使用二分查找。
如果这个升序排序的有序数组确实按照某个未知的位置旋转，只有两种可能：

   1.a [mid]  > a [left] || a [mid]> a [right]，所以，mid位于较大的那部分，较小的部分位于mid右边，应该向右走；

   2.a [mid] <a [left] || a [mid] <a [right]，所以，mid位于较小的那部分，为了找到最小的元素，应该向左走；

   如果这个数组没有旋转(或者是循环旋转完)，只需要往左走，a[mid]总是< a[right]；

   结论：mid > right，向右走；mid < right，向左走；

4. 代码实现（java）

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

二、33. 搜索旋转排序数组

1. 题目
题目链接

2. 题目分析
无重复元素。

3. 解题思路
上一道寻找旋转排序数组中最小值的问题，我们当时使用num[left]和num[mid]的大小关系来判断此时mid指向的元素是在数组的前半段还是后半段。这道题和上一道稍微有点不一样。因此，我们可以先判断经过二分之后的两段数组哪个是排好序的，再判断target是否在这段排好序的数组当中，是的话，就简单了，简单二分搜索即可，不在的话，继续分析上回没排好序的数组，递归的按照以上的逻辑继续查找即可。
当我们二分查找时，有两种可能，一种是选择的部分一个递增序列，而另一种可能选择的部分横跨两个递增序列。
我们只要每次处理递增序列那部分就好。

可以分以下三种情况讨论：

num[mid] = target,那么找到了，不用继续找了
num[mid] >= num[left] 那么此时mid左端，一直到left的数组是排好序的。可以继续细分为两种情况：
（1）num[mid] > target && target >= num[left],说明此时target在mid左侧排好序的数组内。用二分查找处理这段数组即可
（2）如果不符合（1）中的条件，处理mid右侧的数组（还是按照先寻找排序数组，再二分查找的逻辑）
第2点中的条件不成立，那么此时mid右端，一直到right的数组是排好序的。可以继续细分为两种情况：
（1）num[mid] < target && target <= num[right],说明此时target在mid右侧排好序的数组内。用二分查找处理这段数组即可
（2）如果不符合（1）中的条件，处理mid左侧的数组（还是按照先寻找排序数组，再二分查找的逻辑）

4. 代码实现（java）

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

三、81. 搜索旋转排序数组 II

1. 题目
题目链接

2. 题目分析
有重复元素。

3. 解题思路
这道题与之前Search in Rotated Sorted Array类似，问题只在于存在重复元素。那么和之前那道题的解法区别就是，不能通过比较A[mid]和边缘值来确定哪边是有序的，会出现A[mid]与边缘值相等的状态。当中间值与边缘值相等时，让指向边缘值的指针分别往前移动，忽略掉这个相同点，再用之前的方法判断即可。
而如果解决掉重复之后，利用一个性质，旋转后两部分一定有一部分有序，那么通过判断左边还是右边有序分为两种情况。然后再判断向左走还是向右走。
这一改变增加了时间复杂度，试想一个数组有同一数字组成{1，1，1，1，1}，target=2, 那么这个算法就会将整个数组遍历，时间复杂度由O(logn)升到O(n)。

4. 代码实现（java）

class Solution {
    /**
    不能通过比较A[mid]和边缘值来确定哪边是有序的，会出现A[mid]与边缘值相等的状态。当中间值与边缘值相等时，让指向边缘值的指针分别往前移动，忽略掉这个相同点，再用之前的方法判断即可。
而如果解决掉重复之后，利用一个性质，旋转后两部分一定有一部分有序，那么通过判断左边还是右边有序分为两种情况。然后再判断向左走还是向右走。
    */
    public boolean search(int[] nums, int target) {
        if(nums == null || nums.length == 0){
            return false;
        }
        int left =0;
        int right = nums.length-1;
        int mid;
        while(left <= right){
            mid= (right + left)>>1;
            if(nums[mid] == target){
                return true;
            }
            if(nums[mid] == nums[left]){
                left++;
            }else if(nums[mid] > nums[left]){
                if(nums[mid] > target && target >= nums[left]){
                    right = mid-1;
                }else{
                    left = mid+1;
                }
            }else{
                if(nums[mid] < target && target <= nums[right]){
                    left = mid+1;
                }else{
                    right = mid-1;
                }
            }
        }
        return false;
    }
}