快速排序--递归和非递归

1.非递归

使用一个栈来保存区间的首尾节点，难度比递归大一些。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    vector<int> MySort(vector<int>& arr) {
        //非递归快排
        //使用栈存储  存储区间首尾节点位置
        stack<int> st;
        int left = 0, right = arr.size() - 1;
        st.push(left);
        st.push(right);
        while(!st.empty())
        {
            right = st.top();
            st.pop();
            left = st.top();
            st.pop();
            int pivot = quickSort(arr, left, right);
            //左区间
            if(left < (pivot - 1))
            {
                st.push(left);
                st.push(pivot - 1);
            }
            //右区间
            if(right > (pivot + 1))
            {
                st.push(pivot + 1);
                st.push(right);
            }
        
        }
        return arr;
    }
    
    
    int quickSort(vector<int> &arr, int left, int right)
    {
        if(left >= right) return -1;
        int first = left, last = right;
        int pivot = arr[first];
        
        while(first < last)
        {
            while(first < last && arr[last] >= pivot) last--;
            if(first < last) arr[first++] = arr[last];
            
            while(first < last && arr[first] < pivot) first++;
            if(first < last) arr[last--] = arr[first];
        }
        arr[first] = pivot;
        return first;
    }
};

2.递归

懂了非递归再来了解递归，就会变得相对容易很多

vector<int> MySort(vector<int>& arr) {
        //递归快排
        quickSort(arr, 0, arr.size() - 1);
        return arr;
    }
    
    
    void quickSort(vector<int> &arr, int left, int right)
    {
        if(left >= right) return;
        int first = left, last = right;
        int pivot = arr[first];
        
        while(first < last)
        {
            while(first < last && arr[last] >= pivot) last--;
            if(first < last) arr[first++] = arr[last];
            
            while(first < last && arr[first] < pivot) first++;
            if(first < last) arr[last--] = arr[first];
        }
        arr[first] = pivot;
        //递归左区间
        qucikSort(arr, left, first - 1);
        //递归右区间
        quickSort(arr, first + 1, right);
    }