算法：快速排序（Quick Sort）

算法定义

目前学习是五种排序（冒泡、插入、选择、合并、快速）中，快速排序是最让我喜欢的算法（因为我想不到），其定义如下：

• 随机的从数组中选择一个元素，如：item。
• 对数组进行分区，将小于等于 item 的元素移动到 item 左边，将大于 item 的元素移动到 右边，移动过程 item 的位置也有可能发生变化的。
• 分区后 item 的位置为 ItemIndex，递归的对 0 至 ItemIndex -1 和 ItemIndex + 1 至 length -1 部分执行递归。

算法举例

【5，4，3，2，1】

【5，4，3，2，1】

【4，5，3，2，1】

【1，5，3，2，4】

【1，4，3，2，5】

【1，2，3，4，5】

算法实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy.Sorts
{
    class QuickSort<T>
        where T : IComparable<T>
    {
        private static Random _random = new Random();

        private static void Swap(T[] items, int left, int right)
        {
            if (left != right)
            {
                var temp = items[left];
                items[left] = items[right];
                items[right] = temp;
            }
        }

        public static void Sort(T[] items)
        {
            if (items.Length < 2)
            {
                return;
            }

            Sort(items, 0, items.Length - 1);
        }

        private static void Sort(T[] items, int left, int right)
        {
            if (left >= right)
            {
                return;
            }

            var pivotIndex = _random.Next(left, right);
            var newPivotIndex = Partition(items, left, right, pivotIndex);

            Sort(items, left, pivotIndex - 1);
            Sort(items, pivotIndex + 1, right);
        }

        private static object Partition(T[] items, int left, int right, int pivotIndex)
        {
            T pivotValue = items[pivotIndex];

            Swap(items, pivotIndex, right);
            var newPivotValue = right;

            for (var i = left; i < right; i++)
            {
                if (items[i].CompareTo(pivotValue) > 0)
                {
                    Swap(items, i, newPivotValue);
                    newPivotValue = i;
                }
            }

            return newPivotValue;
        }
    }
}