【NO.96】LeetCode HOT 100—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 <= 104

-105 <= nums[i] <= 105

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

解题

方式一：排序

看题意，要我们找出一个子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。说明什么，说明这个子数组不是升序的，但是整个全部数组是升序的，所以我们复制出来一个数组，然后对这个复制数组进行排序，然后将两个数组进行对比，从左向右找到第一个两数组不同的位置，再从右向左找到第一个两数组不同的位置，这两个位置就是子数组的范围。

 /**
 * 时间复杂度：O(n) 排序时间为 O(nlog⁡n)，遍历时间为O(n)，所以总时间复杂度为O(n) 
 * 空间复杂度：O(n) 
 */
class Solution {
    public int findUnsortedSubarray(int[] nums) {
        if (isSorted(nums)) {
            return 0;
        }
        int[] numsSorted = new int[nums.length];
        System.arraycopy(nums, 0, numsSorted, 0, nums.length);
        Arrays.sort(numsSorted);
        int left = 0;
        while (nums[left] == numsSorted[left]) {
            left++;
        }
        int right = nums.length - 1;
        while (nums[right] == numsSorted[right]) {
            right--;
        }
        return right - left + 1;
    }
​
    public boolean isSorted(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] < nums[i - 1]) {
                return false;
            }
        }
        return true;
    }
}

方式二：一次遍历

我们利用升序的特性，现在有一个子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。说明什么，说明有两个位置，这两个位置的数，小于其左边的数，也小于其右边的数。所以，

从左到右循环，记录最大值为 max，若 nums[i] < max, 则表明位置 i 需要调整,，记录需要调整的最大位置 i 为 right;

同理，从右到左循环，记录最小值为 min, 若 nums[i] > min, 则表明位置 i 需要调整，记录需要调整的最小位置 i 为 left.

 /**
 * 时间复杂度：O(n) 
 * 空间复杂度：O(1) 
 */
class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int length = nums.length;
        // 最短子数组的左右下标
        int left = -1;
        int right = -1;
        // 最终结果要是升序，所以顺序找比前面小的，反序找比已经遍历过要大的， 如果没有说明它是一个升序数组
        // 从左到右，记录找到的最大值，找到最后一个比max小的就是right
        int max = nums[0];
        // 从右向左，记录找到的最小值，找到最后一个比min大的就是left
        int min = nums[length - 1];
​
        for (int i = 0; i < length; i++) {
            // 顺序
            if (max > nums[i]) {
                right = i;
            } else {
                max = nums[i];
            }
​
            // 反序
            // index为反序指针
            int index = length - 1 -i;
            if (min < nums[index]) {
                left = index;
            } else {
                min = nums[index];
            }
        }
​
        return right == -1? 0 : right - left + 1;
    }
}