L581. 最短无序连续子数组

581. 最短无序连续子数组
     给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

你找到的子数组应是最短的，请输出它的长度。

示例 1:

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

输入的数组长度范围在 [1, 10,000]。
输入的数组可能包含重复元素 ，所以升序的意思是<=。

1.暴力方法，需要理解其逻辑，以及其判断处理方法

只需要做的是，检查0-i单调递增，j - len单调递增，对于中间的无需检查（这个需要注意）；因此判断相对较多
z注意区间假定的是[i,j)作为乱序数组区间，一开一闭，为什么这样，因为有可能不存在，若为1,2，3,4这种答案得为0，可对比看

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        //暴力方法，[i,j)作为乱序数组区间
        
        int len = nums.length;
        int ans = len;//开始取最长
        for(int i = 0; i < len; i++){
            for(int j = i; j <= len; j++){//z注意等号是可以取的
                //暴力枚举，已经形成了i,j的区间,注意是[i, j)
                //先找出给区间的最小值，最大值
                int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

                for(int k = i; k < j; k++){
                    min = Math.min(min, nums[k]);
                    max = Math.max(max, nums[k]);
                }
                //再判断（0,i)是否严格单调，同时小于min
                //[j, len - 1]也要单调，同时严格大于等于max
                int pre = Integer.MIN_VALUE;//辅助变量，判断是否单调
                if((i > 0 && nums[i - 1] > min) || (j < len && nums[j] < max)){
                    continue;//先判断每个区间的第一个元素，这样后面只需要判断是否单调即可
                }
                int k = 0;
                while(k < i && pre <= nums[k]){
                    pre = nums[k];
                    k++;
                }
                if(k != i) continue;//出现了不单调的情况
                k = j;//判断后面的区间
                while(k < len && pre <= nums[k]){
                    pre = nums[k];
                    k++;
                }
                
                //如果都满足的话，更新结果
                if(k == nums.length) {
                    ans = Math.min(ans, j - i);//起始区间是[i, j)
                }
            }
        }
        return ans;
    }
}

对比//若全用闭合区间，其实暗含的假定最小值必为1

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int len = nums.length;
        int ans = len;

        for(int i = 0; i < len; i++){
            for(int j = i; j < len; j++){
                int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
                //若全用闭合区间
                for(int k = i; k <= j; k++){
                    min = Math.min(min, nums[k]);
                    max = Math.max(max, nums[k]);
                }

                if(i > 0 && nums[i - 1] > min || (j + 1 < len && nums[j + 1] < max)){
                    continue;
                }

                int k = 0, pre = Integer.MIN_VALUE;

                while(k < i && pre <= nums[k]){
                    pre = nums[k];
                    k++;
                }
                if(k!= i) continue;

                k = j + 1;

                while(k < len && pre <= nums[k]){
                    pre = nums[k];
                    k++;
                }

                if(k == len){
                    ans = Math.min(ans, j - i + 1);//这里必然最小值为1
                }
            }
        }
        return ans;
    }
}

2.改善暴力措施
仍是遍历，但是每次比较i,j，条件是不单调即nums[i] > nums[j]
这里可以避免出现上述问题，因为初始时已经设定了left，right的值，最后可特判

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int len = nums.length;
        int left = len, right = 0;
        for(int i = 0; i < len; i++){
            for(int j = i + 1; j < len; j++){//这里从i,或者从i + 1开始都是可以的，同时
                if(nums[j] < nums[i]){
                    //更新边界值，与i,j比较，
                    right = Math.max(right, j);//尽可能扩大右边界
                    left = Math.min(left, i);//尽可能左移左边界
                }
            }
        }
        return right - left < 0 ? 0 : right - left + 1;
    }
}

3.先排序
因为排序之后的首尾必然与原始是相同的，这样就可以直接一次遍历即可实现，直接判断两个数组同一位置的元素是否相同即可；

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int[] snum = nums.clone();//这个函数比较方便，直接克隆一个
        Arrays.sort(snum);
        //比对两个数组
        int len = nums.length;
        int left = len, right = 0;//注意这里是len,对于样例只有一个数1，结果应当输出0，而不是1
        for(int i = 0; i < len; i++){
            if(snum[i] != nums[i]){
                left = Math.min(left, i);
                right = Math.max(right, i);
            }
        }
        return (right - left >= 0 ? right - left + 1: 0);//等于可以取消
    }
}

4.利用单调栈，一旦遇到比栈顶元素小的（因为单调递增），这个时候就弹出，栈中存放的是下标，遍历一遍，便可确定它应该在的位置，恰好是不单调的起始位置；
为了达到这一目的，此方法中，我们使用 栈 。我们从头遍历 nums 数组，如果遇到的数字大小一直是升序的，我们就不断把对应的下标压入栈中，这么做的目的是因为这些元素在目前都是处于正确的位置上。一旦我们遇到前面的数比后面的数大，也就是 nums[j]nums[j] 比栈顶元素小，我们可以知道 nums[j]nums[j] 一定不在正确的位置上。

为了找到nums[j] 的正确位置，我们不断将栈顶元素弹出，直到栈顶元素比nums[j] 小，我们假设栈顶元素对应的下标为 k，那么我们知道 nums[j]nums[j] 的正确位置下标应该是 k + 1，

我们重复这一过程并遍历完整个数组，这样我们可以找到最小的 kk， 它也是无序子数组的左边界。
同理，对于最右边，逆序遍历，又可确定right的范围 。

class Solution {
    public int findUnsortedSubarray(int[] nums) {
        LinkedList<Integer> st = new LinkedList<>();
        int len = nums.length;
        int left = len, right = 0;
        for(int i = 0; i < len; i++){
            while(!st.isEmpty() && nums[st.peek()] > nums[i]){//注意这里应当比较的是值
                //突然遇到了一个比栈顶元素小的值，要进行更新
                left = Math.min(left, st.pop());
            }
            st.push(i);//不断加入下标
        }
        st.clear();
        for(int i = len - 1; i >= 0; i--){
            //更新right的值，尽可能往右推
            while(!st.isEmpty() && nums[st.peek()] < nums[i]){
                right = Math.max(right, st.pop());
            }
            st.push(i);
        }
        return right - left > 0 ? right - left + 1 : 0;
    }
}