581. 最短无序连续子数组

581. 最短无序连续子数组

给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

请你找出符合题意的 最短 子数组，并输出它的长度。

示例 1：

输入：nums = [2,6,4,8,10,9,15]
输出：5
解释：你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

示例 2：

输入：nums = [1,2,3,4]
输出：0

示例 3：

输入：nums = [1]
输出：0

提示：

• 1 <= nums.length <= 10^4
• -10^5 <= nums[i] <= 10^5

进阶：你可以设计一个时间复杂度为 O(n) 的解决方案吗？

对副本排序，O(n log n)

假设输入数组 nums 为 [2, 6, 4, 8, 10, 9, 15]。

1. 创建数组的副本并对其进行排序。

原始数组:      nums = [2, 6, 4, 8, 10, 9, 15]
排序后的数组:  temp = [2, 4, 6, 8,  9, 10, 15]

2. 初始化左右边界 left 和 right。

left  = Integer.MAX_VALUE
right = Integer.MIN_VALUE

3. 从左到右遍历数组，找到第一个不同的元素索引并将其赋值给 left。

索引:    0    1    2    3     4    5    6
nums:   [2,   6,   4,   8,   10,   9,  15]
temp:   [2,   4,   6,   8,    9,  10,  15]
         |    |    |    |     |    |    |
         |    |    |    |     |    |    |
是否相等: Y    N    N    Y     N    N    Y
         	  ↑
        	left = 1  （在索引1处，第一个不同的元素）

nums[1] = 6 和 temp[1] = 4 不同，更新 left = 1。

4. 从右到左遍历数组，找到第一个不同的元素索引并将其赋值给 right。

索引:    0    1    2    3     4    5    6
nums:   [2,   6,   4,   8,   10,   9,  15]
temp:   [2,   4,   6,   8,    9,  10,  15]
         |    |    |    |     |    |    |
         |    |    |    |     |    |    |
是否相等: Y    N    N    Y     N    N    Y
                                   ↑
                                 right = 5 （在索引5处，最后一个不同的元素）

nums[5] = 9 和 temp[5] = 10 不同，更新 right = 5。

5. 计算无序子数组的长度。

left  = 1
right = 5

无序子数组长度 = right - left + 1 = 5 - 1 + 1 = 5

最终结果: 无序子数组长度为 5

无序子数组为 nums[1:6] = [6, 4, 8, 10, 9]，其长度为 5。

class Solution {
    /**
     * 找到数组中最短的无序连续子数组，使得排序该子数组后整个数组变为有序
     *
     * @param nums 输入的整数数组
     * @return 最短的无序连续子数组的长度
     */
    public int findUnsortedSubarray(int[] nums) {
        // 创建数组的副本，并对副本进行排序
        int[] temp = Arrays.copyOf(nums, nums.length);
        Arrays.sort(temp);
        
        // 初始化左右边界
        int left = Integer.MAX_VALUE, right = Integer.MIN_VALUE;
        
        // 找到从左到右第一个不同的元素索引
        for (int i = 0; i < nums.length; i++) {
            if (temp[i] != nums[i]) {
                left = i;
                break;
            }
        }
        
        // 找到从右到左第一个不同的元素索引
        for (int i = nums.length - 1; i >= 0; i--) {
            if (temp[i] != nums[i]) {
                right = i;
                break;
            }
        }
        
        // 如果数组本来就是有序的，返回0
        if (left == Integer.MAX_VALUE && right == Integer.MIN_VALUE) {
            return 0;
        }
        
        // 返回无序子数组的长度
        return right - left + 1;
    }
}

• 时间复杂度: $O(n\log n)$ ，其中 $n$ 为给定数组的长度。我们需要 $O(n\log n)$ 的时间进行排序，以及 $O(n)$ 的时间遍历数组，因此总时间复杂度为 $O(n)$ 。
• 空间复杂度: $O(n)$ ，其中 $n$ 为给定数组的长度。我们需要额外的一个数组保存排序后的数组 numsSorted。

两次遍历，O(n)

假设输入数组 nums 为 [2, 6, 4, 8, 10, 9, 15]。

1. 初始化变量

• maxn：遍历时从左到右更新的最大值，初始值为 Integer.MIN_VALUE。
• right：表示无序子数组的右边界，右边界即从左到右遍历时小于已遍历元素的最大值的最后一个元素。初始值为 -1。
• minn：遍历时从右到左更新的最小值，初始值为 Integer.MAX_VALUE。
• left：表示无序子数组的左边界，左边界即从右到左遍历时大于已遍历元素的最小值的最后一个元素，初始值为 -1。

2. 遍历数组

2.1 从左到右遍历，寻找 right 边界。

索引:     0     1     2     3     4     5     6
nums:   [ 2,    6,    4,    8,   10,    9,   15]
maxn:    2     6     6     8    10    10    15
right:   -1    -1     2    2     2     5     5

2.2 从右到左遍历，寻找 left 边界。

索引:     6     5     4     3     2     1     0
nums:   [ 2,    6,    4,    8,   10,    9,   15]
minn:   15     9     9     8     4     4     2
left:   -1     4     4     2     2    -1    -1

3. 计算无序子数组的长度

最终结果:
left = 1
right = 5
无序子数组长度 = right - left + 1 = 5 - 1 + 1 = 5

class Solution {
    /**
     * 找到数组中最短的无序连续子数组，使得排序该子数组后整个数组变为有序
     *
     * @param nums 输入的整数数组
     * @return 最短的无序连续子数组的长度
     */
    public int findUnsortedSubarray(int[] nums) {
        int n = nums.length;
        int maxn = Integer.MIN_VALUE, right = -1; // 初始化最大值和右边界
        int minn = Integer.MAX_VALUE, left = -1;  // 初始化最小值和左边界

        // 从左到右遍历数组，找到右边界。右边界即小于已遍历元素的最大值的最后一个元素，即图中的F
        for (int i = 0; i < n; i++) {
            if (maxn > nums[i]) {
                right = i; // 如果新元素小于最大值（最大值是旧元素），更新右边界
            } else { // 遍历时不断更新最大值。
                maxn = nums[i]; // 否则更新最大值
            }

            // 从右到左遍历数组，找到左边界。左边界即大于已遍历元素的最小值的最后一个元素，即图中的B。
            if (minn < nums[n - i - 1]) {
                left = n - i - 1; // 如果新元素大于最小值，说明最小值前面还有元素，此时要更新左边界。
            } else {
                minn = nums[n - i - 1]; // 更新最小值
            }
        }

        // 如果数组本来就是有序的，返回0；否则返回无序子数组的长度
        return right == -1 ? 0 : right - left + 1;
    }
}

• 时间复杂度：O(n)，其中 n 是给定数组的长度，我们仅需要遍历该数组一次。
• 空间复杂度：O(1)。我们只需要常数的空间保存若干变量。