力扣581 最短无序连续子数组

方法一：动态规划 

 

public int findUnsortedSubarray(int[] nums){
        int max=nums[0];
        int min=nums[nums.length-1];
        int res;
        int start=0;
        int end=-1;
        for(int i=0;i<nums.length;i++){
            if(nums[i]<max){
                end=i;
            }
            else {
                max=nums[i];
            }
            if(nums[nums.length-1-i]>min){
                start=nums.length-1-i;
            }
            else{
                min=nums[nums.length-1-i];
            }
        }
        return end-start+1;
    }

方法二：单调栈

思路：仍然是寻找中段的两端，start和end：

从左到右遍历，比栈顶元素大就入栈，入栈元素越来越大，直到遍历到比栈顶元素小的数值，表示当前下标对应的数值位置不对，于是开始出栈所有比该数大的数，出栈元素中下标最小的记为start。

public int findUnsortedSubarray(int[] nums){
        Stack<Integer> stack=new Stack<>();
        int start=nums.length;
        int end=-1;
        for(int i=0;i<nums.length;i++){
            while(!stack.isEmpty()&&nums[i]<nums[stack.peek()]){
                start=Math.min(start,stack.pop());
            }
            stack.push(i);
        }
        stack.clear();
        for(int i=nums.length-1;i>=0;i--){
            while(!stack.isEmpty()&&nums[i]>nums[stack.peek()]){
                end=Math.max(end,stack.pop());
            }
            stack.push(i);
        }
        return end-start>0?end-start+1:0;
    }

方法三：排序+双指针

public int findUnsortedSubarray(int[] nums){
        int[] newNums=nums.clone();
        Arrays.sort(newNums);
        int left=0;
        int right=nums.length-1;
        while(left<=right&&newNums[left]==nums[left]) left++;
        while(left<=right&&newNums[right]==nums[right]) right--;
        return right-left+1;
    }