LeetCode581. 最短无序连续子数组（排序，数组）

https://leetcode-cn.com/problems/shortest-unsorted-continuous-subarray/submissions/

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

你找到的子数组应是最短的，请输出它的长度。
示例 1:
输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。
说明 :
输入的数组长度范围在 [1, 10,000]。
输入的数组可能包含重复元素 ，所以升序的意思是<=。

/*
思路一：
    从数组前面开始，满足升序要求，并判断最小值，若接下来的数有小于前面的数，则start定位前面
    从数组后面开始，满足降序要求，并判断最大值，若接下来的数有大于后面的数，则end定位前面
    
思路二：
    排序比较即可
*/


void quick_sort(int *nums, int start, int end){
    if(start >= end) return;
    
    int i = start;
    int j = end;
    
    while(i < j){
        while(nums[j] >= nums[start] && i < j) j--;
        while(nums[i] <= nums[start] && i < j) i++;
        
        if(i < j){
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }
    int tmp = nums[start];
    nums[start] = nums[i];
    nums[i] = tmp;
    
    quick_sort(nums, start, i - 1);
    quick_sort(nums, i + 1, end);
}

int findUnsortedSubarray(int* nums, int numsSize){
    int *tmp = (int *)malloc(numsSize * sizeof(int));
    int i = 0;
    for(; i < numsSize; i++){
        tmp[i] = nums[i];
    }
    quick_sort(tmp, 0, numsSize - 1);
    
    int start = 0;
    int end = 0;
    bool sflag = true;
    bool eflag = true;
    for(i = 0; i < numsSize; i++){
        if(sflag && nums[i] != tmp[i]){
            start = i;
            sflag = false;
        }
    }
    for(i = numsSize - 1; i >= 0; i--){
        if(eflag && nums[i] != tmp[i]){
            end = i;
            eflag = false;
        }
    }
    if(start == end && start == 0) return 0;
    return end - start + 1;
    
}