算法（第四版）讀書筆記--排序（4）快速排序

快速排序比歸併排序稍快，但是不需要輔助棧，普通的快速排序實現如下

    /// <summary>
    /// 快速排序
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="v"></param>
    public static void Sort<T>(List<T> v) where T : IComparable
    {
        Sort<T>(v, 0, v.Count-1);
    }
    public static void Sort<T>(List<T> v, int lo, int hi) where T : IComparable
    {
        if (lo >= hi)
        {
            return;
        }
        int m = pert<T>(v,lo,hi);

        Sort<T>(v, lo, m - 1);
        Sort<T>(v, m + 1, hi);
    }
    public static int pert<T>(List<T> v, int lo, int hi) where T : IComparable
    {
        int i = lo;
        int j = hi + 1;
        T m = v[lo];
        while (true)
        {
            while (m.CompareTo(v[++i]) > 0)
            {
                if (i == hi)
                    break;
            };
            while (m.CompareTo(v[--j]) < 0) ;
            if (i >= j)
                break;
            Sort_Templet.exch<T>(v, i, j);
        }
        Sort_Templet.exch<T>(v, lo, j);

        return j;
    }

快速排序複雜度約爲1.39NLgN，同時可以通過對小組數據插入排序的方式優化。如果涉及到含有多個重複數據，可以使用三取樣切分的方式進行優化。

三取樣切分快速排序：

    public static void Quick3Way<T>(List<T> v) where T : IComparable
    {
        Quick3Way(v, 0, v.Count - 1);
    }

    /// <summary>
    /// 三取樣切分
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="v"></param>
    /// <param name="lo"></param>
    /// <param name="hi"></param>
    private static void Quick3Way<T>(List<T> v, int lo, int hi) where T:IComparable
    {
        if (lo >= hi)
            return;
        int lt = lo, i = lo + 1, gt = hi;
        T m = v[lo];
        while (i <= gt)
        {
            int cmp = v[i].CompareTo(m);
            if (cmp < 0)
            {
                Sort_Templet.exch<T>(v, lt++, i++);
            }
            else if (cmp > 0)
            {
                Sort_Templet.exch<T>(v, i, gt--);
            }
            else
            {
                i++;
            }
            Sort<T>(v, lo, lt - 1);
            Sort<T>(v, lt + 1, hi);

        }
    }

對於快排來說實際使用中考慮對數據先進行打亂再排序。