LeetCode.581 Shortest Unsorted Continuous Subarray

最新推荐文章于 2025-02-08 07:15:00 发布

xiakexiaohu

最新推荐文章于 2025-02-08 07:15:00 发布

阅读量84

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode算法编程

本文链接：https://blog.youkuaiyun.com/xiakexiaohu/article/details/78390597

LeetCode算法编程专栏收录该内容

225 篇文章

订阅专栏

本文介绍了一种算法，用于寻找一个整数数组中最短的连续子数组，该子数组若按升序排序，则整个数组也会变为升序。通过实例展示了如何确定需要排序的子数组及其长度。

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

题目：

Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too.

You need to find the shortest such subarray and output its length.

Example 1:

Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.

Note:

Then length of the input array is in range [1, 10,000].
The input array may contain duplicates, so ascending order here means <=.

分析（推荐）：

class Solution {
    public int findUnsortedSubarray(int[] nums) {
         //给定数组，返回使整个数组成为升序的最小字串
        //注意：元素范围在1-10000，可能包含重复元素
        //思路：先找出某段乱序，再乱序中找出最大值和最小值，然后从中间往两头搜索
        //直到找到满足刚好小于乱序的最小值，和大于乱序的最大值即为满足条件
        int low=0,high=nums.length-1,max=Integer.MIN_VALUE,min=Integer.MAX_VALUE;
        
        while(low<high&&nums[low]<=nums[low+1]){
            low++;
        }
        if(low==high){
            //如果一直查找到最后一个元素，说明元数组即为有序的,返回0
            return 0;
        }
        
        while(high>low&&nums[high]>=nums[high-1]){
            high--;
        }
        
        //查找乱序段中最大值和最小值
        for(int i=low;i<=high;i++){
            max=Math.max(max,nums[i]);
            min=Math.min(min,nums[i]);
        }
        
        //往两头搜索，查找满足条件的
        while(low>=0&&nums[low]>min){
            low--;
        }
        while(high<nums.length&&nums[high]<max){
            high++;
        }
        
        return high-low-1;
    }
}

分析（原创-易理解）：

class Solution {
    public int findUnsortedSubarray(int[] nums) {
      //给定数组，返回使整个数组成为升序的最小字串
        //注意：元素范围在1-10000，可能包含重复元素
        //思路：采用与正确的数组进行匹配，匹配到tail和head不一样的长度即为结果。
        int [] dummy=Arrays.copyOf(nums,nums.length);
        Arrays.sort(dummy);
        int head=0,tail=0;
        for(int i=0;i<nums.length;i++){
            if(dummy[i]!=nums[i]){
                head=i;
                break;
            }
        }
        for(int i=nums.length-1;i>head;i--){
            if(dummy[i]!=nums[i]){
                tail=i;
                break;
            }
        }
        return tail==head?0:tail-head+1;
        
    }
}