方法1：

直接copy一个副本数组，排序这个副本，然后拿着副本于nums比较，把升序给特判了，然后left++，right--进行比较

func findUnsortedSubarray(nums []int) int {
    if sort.IntsAreSorted(nums) {
        return 0
    }
    //numsSorted := append([]int(nil), nums...)
    numsSorted := make([]int,len(nums))
    copy(numsSorted,nums)
    sort.Ints(numsSorted)
    left, right := 0, len(nums)-1
    for nums[left] == numsSorted[left] {
        left++
    }
    for nums[right] == numsSorted[right] {
        right--
    }
    return right - left + 1
}

方法2：

从前往后遍历，保证R指向的值往后全都严格递增，且R指向的下一个值比前面的所有的值都大，所以我们要维护一个max值，如果满足max <= nums[i]，我们就让max = nums[i]，如果不满足就让R指向这个下标，从而保证R之后的值都满足max <= nums[i]，且满足R指向的下一个值比前面的所有的值都大。
同理，从后往前遍历，找到L指向的那个下标。

func findUnsortedSubarray(nums []int) int {
    n := len(nums)
    l,r := -1,-1
    min, max := math.MaxInt, math.MinInt
    for i := 0; i < n; i++ {
        if max <= nums[i] {
            max = nums[i]
        }else {
            r = i
        }
    }
    if r == -1 {
        return 0
    }
    for i := n-1; i >= 0; i-- {
        if min >= nums[i] {
            min = nums[i]
        }else {
            l = i
        }
    }
    return r-l+1
}

当然也可以将两个for循环写在一起

func findUnsortedSubarray(nums []int) int {
    n := len(nums)
    l,r := -1,-1
    min, max := math.MaxInt, math.MinInt
    for i,nm := range nums {
        if max > nm {
            r = i
        }else {
            max = nm 
        }
        if min < nums[n-i-1] {
            l = n-i-1
        }else {
            min = nums[n-i-1]
        }
    }
    if r == -1 {
        return 0
    }
    return r-l+1
}

最短无序连续子数组——？

方法1：

方法2：