581. 最短无序连续子数组

581. 最短无序连续子数组

题目：

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

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

示例：

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 1 <= nums.length <= 104
• -105 <= nums[i] <= 105

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

解题：

方法一：排序比较

从示例1可以得知，数组可以分为三部分，nums1部分，nums2部分，nums3部分。当进行升序排序之后发现nums1部分和nums3部分不会发生变化，因此只要nums1+nums3部分求出最大，则可以得到nums2部分最短。

基本思路是：把原来的数组复制到另一个数组中进行排序，然后两个数组进行比较，然后我们从左向右找到第一个两数组不同的位置，即为 nums2 的左边界。同理也可以找到 nums2 的右边界。最后我们输出 nums2 的长度即可。

class Solution {
public:
    int findUnsortedSubarray(vector& nums) {
        if(is_sorted(nums.begin(),nums.end())) {
            // 如果数组已经是升序排序，返回0
            return 0;
        }
        vector numsSorted(nums);
        sort(numsSorted.begin(), numsSorted.end());
        int left = 0;
        while(nums[left] == numsSorted[left]) {
            left++;
        }
        int right = nums.size()-1;
        while(nums[right] == numsSorted[right]) {
            right--;
        }
        return right-left+1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

复杂度分析

• 时间复杂度：O(nlog⁡n)，其中 n 为给定数组的长度。我们需要 O(nlog⁡n) 的时间进行排序，以及 O(n) 的时间遍历数组，因此总时间复杂度为 O(n)。

• 空间复杂度：O(n)，其中 n 为给定数组的长度。我们需要额外的一个数组保存排序后的数组 numsSorted。

方法二：双指针一次遍历法

使用两个指针，一个从数组的开头向右移动，找到第一个无序的元素，另一个从数组的末尾向左移动，找到第一个无序的元素。然后，这两个指针之间的子数组就是我们要找的连续子数组。

class Solution {
public:
    int findUnsortedSubarray(vector& nums) {
        int n = nums.size();
        //从左向右找到第一个无序的元素
        int left = 0;
        while(left < n-1 && nums[left] <= nums[left+1]) {
            left++;
        }
        // 如果数组已经有序，返回0
        if(left == n-1) {
            return 0;
        }
        //从右向左找到第一个无序的元素
        int right = n-1;
        while(right > 0 && nums[right] >= nums[right - 1]) {
            right--;
        }
        //找到无序子数组的最小值和最大值
        int min_val = INT_MAX, max_val = INT_MIN;
        for(int i = left; i <= right; ++i) {
            min_val = min(min_val, nums[i]);
            max_val = max(max_val, nums[i]);
        }
        // 扩展左边界
        while(left > 0 && nums[left - 1] > min_val) {
            left--;
        }
        // 扩展右边界
        while(right < n-1 && nums[right + 1] < max_val) {
            right++;
        }
        // 返回子数组的长度
        return right - left + 1;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

更加简洁的写法：

class Solution {
public:
    int findUnsortedSubarray(std::vector& nums) {
        int n = nums.size();
        int maxn = INT_MIN, right = -1;  // 初始化最大值和右边界
        int minn = INT_MAX, left = -1;   // 初始化最小值和左边界

        for (int i = 0; i < n; i++) {
            // 从左向右遍历找到右边界
            if (maxn > nums[i]) {
                right = i;
            } else {
                maxn = nums[i];
            }

            // 从右向左遍历找到左边界
            if (minn < nums[n - i - 1]) {
                left = n - i - 1;
            } else {
                minn = nums[n - i - 1];
            }
        }
        // 如果 right 仍然是初始值 -1，表示数组已经有序，返回 0
        // 否则，返回无序子数组的长度
        return right == -1 ? 0 : right - left + 1;
    }
};
int main() {
    std::vector nums = {2, 6, 4, 8, 10, 9, 15};
    Solution solution;
    int result = solution.findUnsortedSubarray(nums);

    std::cout << "最短无序连续子数组的长度为: " << result << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

不理解？没关系，根据例子看图说话！

复杂度分析

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