算法：快速排序（Quick Sort）

算法定义

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

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

算法举例

【5，4，3，2，1】

【5，，，2，1】

【，5，3，2，1】

【1，5，3，2，】

【1，，3，2，5】

【1，2，3，，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 < )
             {
                 return;
             }

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

         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 - );
             Sort(items, pivotIndex + , 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) > )
                 {
                     Swap(items, i, newPivotValue);
                     newPivotValue = i;
                 }
             }

             return newPivotValue;
         }
     }
 }