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]。
- 创建数组的副本并对其进行排序。
原始数组: nums = [2, 6, 4, 8, 10, 9, 15]
排序后的数组: temp = [2, 4, 6, 8, 9, 10, 15]
- 初始化左右边界
left和right。
left = Integer.MAX_VALUE
right = Integer.MIN_VALUE
- 从左到右遍历数组，找到第一个不同的元素索引并将其赋值给
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。
- 从右到左遍历数组，找到第一个不同的元素索引并将其赋值给
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。
- 计算无序子数组的长度。
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 ) O(n \log n) O(nlogn) ，其中 n n n 为给定数组的长度。我们需要 O ( n log n ) O(n \log n) O(nlogn) 的时间进行排序，以及 O ( n ) O(n) O(n) 的时间遍历数组，因此总时间复杂度为 O ( n ) O(n) O(n) 。
- 空间复杂度:
O
(
n
)
O(n)
O(n) ，其中
n
n
n 为给定数组的长度。我们需要额外的一个数组保存排序后的数组
numsSorted。
两次遍历，O(n)
假设输入数组 nums 为 [2, 6, 4, 8, 10, 9, 15]。
- 初始化变量
maxn：遍历时从左到右更新的最大值，初始值为Integer.MIN_VALUE。right：表示无序子数组的右边界，右边界即从左到右遍历时小于已遍历元素的最大值的最后一个元素。初始值为-1。minn：遍历时从右到左更新的最小值，初始值为Integer.MAX_VALUE。left：表示无序子数组的左边界，左边界即从右到左遍历时大于已遍历元素的最小值的最后一个元素，初始值为-1。
- 遍历数组
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
- 计算无序子数组的长度
最终结果:
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)。我们只需要常数的空间保存若干变量。