【LeetCode】数组-4(581)-给未排序数组中子数组排序使得整个数组排序 找到这个最小的子数组

这道题目感觉并不太容易，也并没有想到什么比较好的方法，看来还是积累太少。

思路一：两个指针向后遍历，分别记下造成逆序的最小和最大下标位置

优化的暴力解法（很精妙，面试的时候可以说出来）

思想：两个指针向后遍历，后面的比前面的大时，分别记录这两个元素的下标 lo 和 hi，前面的下标是造成逆序的第一个元素所以我们记录它，它也一直是后面逆序出现位置的最小值。二而后面的元素更新一直都表示构成元素逆序的最大下标位置。

最后 hi-lo+1就是 最小的那个子数组。

【正确代码】

 public class Solution {
     public int findUnsortedSubarray(int[] nums) {
         int lo = Integer.MAX_VALUE, hi = Integer.MIN_VALUE;
         for (int i = 0; i < nums.length; i++) {
             for (int j = i; j < nums.length; j++) {
                 if (nums[j] < nums[i]) {
                     lo = Math.min(lo, i);
                     hi = Math.max(hi, j);
                 }
             }
         }
         return hi - lo < 0 ? 0 : hi - lo + 1;
     }
 }

复杂度分析

时间复杂度：O(n^2)

空间复杂度：o(1)

思路二：和排序后的比较，找出前后第一个不相等的数字，计算下标差

【正确代码】

 public class Solution {
     public int findUnsortedSubarray(int[] nums) {
         int[] sortNums = new int[nums.length];
         System.arraycopy(nums, 0, sortNums, 0, nums.length);
         Arrays.sort(sortNums);
         int lo = nums.length - 1, hi = 0;
         int i = 0, j = nums.length - 1;
         while (i < nums.length - 1) {
             if (sortNums[i] != nums[i]) {
                 lo = i;
                 break;
             }
             i++;
         }
         while (j > 0) {
             if (sortNums[j] != nums[j]) {
                 hi = j;
                 break;
             }
             j--;
         }
         return hi - lo <= 0 ? 0 : hi - lo + 1;
     }
 }

复杂度分析

时间复杂度：O(n*logn) 主要消耗在排序

空间复杂度：O(n) 申请了空间

思路三：使用stack，从前向后压栈，找到第一个下降的元素，并记录下标。同理，从后向前，找到第一个上升元素，并记录下标，最后计算下标差即可。

第一次写时出现错误，没有考虑到等于的情况。

【错误代码】

 public class Solution {
     public int findUnsortedSubarray(int[] nums) {
         Stack<Integer> stack = new Stack<>();
         int lo = 0, hi = 0;
         one: {
             for (int i = 0; i < nums.length; i++) {
                 while (!stack.isEmpty() && nums[stack.peek()] > nums[i]) { //stack 中元素大于新添加元素
                     lo = stack.peek();
                     break one;
                 }
                 stack.push(i);
             }
         }
         stack.clear();
         two: {
             for (int i = nums.length - 1; i >= 0; i--) {
                 while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
                     hi = stack.peek();
                     break two;
                 }
                 stack.push(i);
             }
         }

         return hi - lo <= 0 ? 0 : hi - lo + 1;
     }
 }

【错误输出】

Input:[1,3,2,2,2]

Output:2

Expected:4

【分析错误原因】

不要随意使用break，蓝色处很重要只要比栈顶大就一只向外弹出。改正代码如下：

【正确代码】

 class Solution {
     public int findUnsortedSubarray(int[] nums) {
         Stack<Integer> stack = new Stack<>();
         int lo = nums.length - 1;
         int hi = 0;
         for (int i = 0; i < nums.length; i++) {
             while (!stack.isEmpty() && nums[i] < nums[stack.peek()]) {
                 lo = Math.min(lo, stack.pop());
             }
             stack.push(i);
         }
         stack.clear();
         for (int j = nums.length -1; j >= 0; j--) {
             while (!stack.isEmpty() && nums[j] > nums[stack.peek()]) {
                 hi = Math.max(hi, stack.pop());
             }
             stack.push(j);
         }
         return hi - lo > 0 ? hi - lo + 1 : 0;
     }
 }

复杂度分析

时间复杂度：O(n)

空间复杂度：O(n) stack的深度

思路四：从前往后找，从前面比后面小的数中，找到并保存其中最小的数，之后再从前向后找，找出第一个大于这个数的下标即为所求。后面同理。