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 <= 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<int>& nums) {if(is_sorted(nums.begin(),nums.end())) {// 如果数组已经是升序排序，返回0return 0;}vector<int> 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;}
};

复杂度分析

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

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

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

class Solution {
public:int findUnsortedSubarray(vector<int>& nums) {int n = nums.size();//从左向右找到第一个无序的元素int left = 0;while(left < n-1 && nums[left] <= nums[left+1]) {left++;}// 如果数组已经有序，返回0if(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;}
};

更加简洁的写法：

class Solution {
public:int findUnsortedSubarray(std::vector<int>& 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<int> nums = {2, 6, 4, 8, 10, 9, 15};Solution solution;int result = solution.findUnsortedSubarray(nums);std::cout << "最短无序连续子数组的长度为: " << result << std::endl;return 0;
}

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

在这里插入图片描述
复杂度分析