「力扣」第 581 題：最短無序連續子數組（棧、單調棧）

方法一：暴力解法

• 要歸納出：
  • 找到每個數左邊第 1 個嚴格大於它的值的下標（構成逆序關係）；
  • 找到每個數右邊第 1 個嚴格小於它的值的下標（也構成逆序關係）。
    二者之差就是題目要找的「最短無序連續子數組」。
    

Java 代碼：

public class Solution {

    public int findUnsortedSubarray(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return 0;
        }

        // 從左到右找出最後一個單調不減的下標
        // 從右到左找出最後一個單調不增的下標
        int max = nums[0];
        int right = 0;
        for (int i = 1; i < len; i++) {
            max = Math.max(max, nums[i]);
            if (nums[i] < max) {
                right = i;
            }
        }
        // System.out.println(right);
        int left = len - 1;
        int min = nums[len - 1];
        for (int i = len - 2; i >= 0; i--) {
            min = Math.min(min, nums[i]);
            if (nums[i] > min) {
                left = i;
            }
        }
        // System.out.println(left);
        if (right > left) {
            return right - left + 1;
        }
        return 0;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {2, 6, 4, 8, 10, 9, 15};
        int res = solution.findUnsortedSubarray(nums);
        System.out.println(res);
    }
}

方法二：棧（單調棧）

Java 代碼：

import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {

    public int findUnsortedSubarray(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return 0;
        }

        int leftBound = len - 1;
        int rightBound = 0;

        Deque<Integer> stack = new ArrayDeque<>(len);
        for (int i = 0; i < len; i++) {
            // 這裏的 while 不要忘記
            while (!stack.isEmpty() && nums[i] < nums[stack.peekLast()]) {
                leftBound = Math.min(leftBound, stack.removeLast());
            }
            stack.addLast(i);
        }
        
        stack.clear();

        for (int i = len - 1; i >= 0; i--) {
            while (!stack.isEmpty() && nums[i] > nums[stack.peekLast()]) {
                rightBound = Math.max(rightBound, stack.removeLast());
            }
            stack.addLast(i);
        }

        if (rightBound > leftBound) {
            return rightBound - leftBound + 1;
        }
        return 0;
    }
}