581. 最短无序连续子数组

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

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

示例 1:

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

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

直接法

思路：另辟一个vector，保存排序之后的数组，然后扫描两次得到头部不同的值和尾部不同的值
复杂度分析：
时间复杂度：O(nlogn)
空间复杂度：O(n)

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        vector<int> temp = nums;
        sort(temp.begin(),temp.end());
        int start = 0;
        int end = 0;
        int i;
        for(i=0; i<nums.size();i++)
        {
            if(temp[i]!=nums[i])
            {
                start = i;
                break;
            }
        }
        if(i==nums.size())    return 0;
        for(i=nums.size()-1; i>start; i--)
        {
            {
                if(temp[i]!=nums[i])
                {
                    end = i;
                    break;
                }
            }
        }
        return end-start+1;
    }
};

双指针法

思路：正向搜索一遍，找到第一个拐点和最大值点；反向搜索一遍，找到最后一个拐点和最小值点，然后拓展区间（可以画个函数图更好理解）
复杂度分析：
时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        if(nums.size()==0 || nums.size()==1)  return 0;
        int i=0;
        int j=1;
        int p=nums.size()-1;
        int q=nums.size()-2;
        int nums_max;
        int nums_min;
        int start = -1;
        int end = nums.size();
        while(j<nums.size())
        {
            while(j<nums.size() && nums[i]<=nums[j])
            {
                i++;
                j++;
            }
            if(j<nums.size())
            {
                if(start == -1)
                {
                    start = i;
                    nums_max = nums[i];
                }
                else
                    nums_max = max(nums_max,nums[i]);
            }
            while(j<nums.size() && nums[i]>=nums[j])
            {
                i++;
                j++;
            }
        }
        if(start == -1 && j == nums.size()) return 0;
        while(q>-1)
        {
            while(q>-1 && nums[q]<=nums[p])
            {
                p--;
                q--;
            }
            if(q>-1)
            {
                if(end == nums.size())
                {
                    end = p;
                    nums_min = nums[p];
                }
                else
                    nums_min = min(nums_min,nums[p]);
            }
            while(q>-1 && nums[q]>=nums[p])
            {
                q--;
                p--;
            }
        }
        for(int k=0; k<start; k++)
        {
            if(nums[k]>nums_min)
                start = k;
        }
        for(int k=nums.size()-1; k>end; k--)
        {
            if(nums[k]<nums_max)
                end = k;
        }
        return end-start+1;
    }
};

也可以用一次循环搜索start，end，min，max

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        if(nums.size()==0 || nums.size()==1)  return 0;
        int i=0;
        int j=1;
        int nums_max;
        int nums_min;
        int start = -1;
        int end = nums.size();
        while(j<nums.size())
        {
            while(j<nums.size() && nums[i]<=nums[j])
            {
                i++;
                j++;
            }
            if(j<nums.size())
            {
                if(start == -1)
                {
                    start = i;
                    nums_max = nums[i];
                }
                else
                    nums_max = max(nums_max,nums[i]);
            }
            if(j==nums.size())
            {
                if(start == -1)
                    return 0;
                else
                {
                    break;
                }
            }
            while(j<nums.size() && nums[i]>=nums[j])
            {
                i++;
                j++;
            }
            if(i<nums.size())
            {
                if(end==nums.size())
                {
                    end = i;
                    nums_min = nums[i];
                }
                else
                    nums_min = min(nums_min,nums[i]);
            }
            
        }
        for(int k=0; k<start; k++)
        {
            if(nums[k]>nums_min)
                start = k;
        }
        for(int k=nums.size()-1; k>end; k--)
        {
            if(nums[k]<nums_max)
                end = k;
        }
        return end-start+1;
    }
};