Leetcode#581. Shortest Unsorted Continuous Subarray（最短未排连续子数组）

题目

Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too.

You need to find the shortest such subarray and output its length.

Example 1:

Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.

Note:

1. Then length of the input array is in range [1, 10,000].
2. The input array may contain duplicates, so ascending order here means <=.

题意

给你一个数组，数组是未排序的，现在你排序数组的一个子数组，可以实现整个数组排序，这个的子数组有很多个，现在你需要找出最短长度的一个子数组。

题解

首先你要知道排序好的数组是什么样子的，拿未排序的数组分别从左边和右边查找同一位置不相同的数，左右不相同数之间就是最短长度的子数组。
同时需要注意原数组已经是排序好的情况。

C++代码

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        vector<int>numscopy;
        for(int i=0; i<nums.size(); i++){
            numscopy.push_back(nums[i]);
        }
        sort(numscopy.begin(), numscopy.end());
        int sum = 0, left=-1,right=-1;
        for(int i=0; i<nums.size(); i++)
        {
            if(nums[i]!=numscopy[i]){
                left = i;
                break;
            }
        }
        if(left==-1)//查找到最后一个，即原数组已经为升序排列
            return 0;
        for(int i=nums.size()-1; i>=0; i--)
        {
            if(nums[i]!=numscopy[i]){
                right = i;
                break;
            }
        }

        return right - left + 1;
    }
};

python代码

class Solution(object):
    def findUnsortedSubarray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        numscopy = nums[::]
        numscopy.sort()
        sum = 0
        left=-1
        right=-1
        for i in range(0, len(nums)):
            if nums[i]!=numscopy[i]:
                left = i
                break
        if left==-1:
            return 0
        for i in range(len(nums)-1,-1,-1):
            if nums[i]!=numscopy[i]:
                right = i
                break
        return right - left + 1;