快速排序的两种实现方式（递归、非递归）

#ifndef QUICK_SORT_H
#define QUICK_SORT_H

#include<vector>
#include<stack>
#include<cstddef>

/// 快速排序是不稳定的，其时间平均时间复杂度是O(nlgn)。
/// 逆序序列下效果最差，逼近 O(n2)，起空间复杂度是 log2n，因为需要空间来保存递归的区间范围。
template<typename T>
class sort_quick
{
public:
    //递归方法
    static void sort_r(std::vector<T>& arr)
    {
        _sort_r(arr, 0, arr.size()-1);
    }

    ///快速排序非递归
    static void sort(std::vector<T>& arr)
    {
        size_t n = arr.size();
        if(n<2)
        {
            return;
        }

        std::stack<T> s;
        s.push(0);
        s.push(n - 1);

        while (s.size())
        {
            int right = s.top();
            s.pop();
            int left = s.top();
            s.pop();

            if (left < right)
            {
                int mid = _partition(arr, left, right);
                s.push(left);
                s.push(mid - 1);

                s.push(mid + 1);
                s.push(right);
            }
        }
    }

private:
    static void _sort_r(std::vector<T>& arr, int left, int right)
    {
        if(left>=right)
            return;

        int mid=_partition(arr,left, right);
        _sort_r(arr, left, mid-1);
        _sort_r(arr, mid+1, right);
    }

    static int _partition(std::vector<T>& arr, int left, int right)
    {
        auto data=arr[left];
        while(left<right)
        {
            while(left<right && data<arr[right]) right--;
            arr[left]=arr[right];

            while(left<right && data>=arr[left]) left++;
            arr[right]=arr[left];
        }

        arr[left]=data;
        return left;
    }
};

#endif // QUICK_SORT_H