C#之快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序的基本概念是：
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
下面通过一个例子来了解快速排序的具体含义：
 { 23, 45, 60, 10, 17, 101,12}
第一遍排序：

由此思想，我们可以实现快速排序的代码：
注意基准数据永远不变，永远是和基准数据进行比较，无论在什么位置，最后的目的就是把基准数据放在中间，小的放前面大的放后面。

namespace QuickSort
{
    class QuickSort
    {
        private int  Func(int[] n, int left, int right)
        {
            int baseNum = n[left]; // 基准数据

            int i = left;
            int j = right;
            while (true)
            {
                if (n[i] < baseNum && i < j)
                {
                    i++;
                }
                else if (n[i] > baseNum && i < j)
                {
                    int number = n[i];
                    n[i] = n[j];
                    n[j] = number;
                    j--;
                }
                else if (n[j] < baseNum && i < j)
                {
                    int number = n[i];
                    n[i] = n[j];
                    n[j] = number;
                    i++;
                }
                else if (n[j] > baseNum && i < j)
                {
                    j--;
                }
                else if (i == j)
                {
                    n[i] = baseNum;
                    break;
                }
            }
            return i;
        }

        public void QuickSortFunc(int[] n, int left, int right)
        {
            //左下标一定小于右下标，否则就超越了
            if (left < right)
            {
                //对数组进行分割，取出下次分割的基准标号 
                int i = Func(n, left, right);

                //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                QuickSortFunc(n, left, i - 1);

                //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                QuickSortFunc(n, i + 1, right);

            }
        }
        static void Main(string[] args)
        {
            int[] n = { 23, 45, 60, 10, 17, 101,12};
            QuickSort qs = new QuickSort();
            qs.QuickSortFunc(n, 0, n.Length - 1);
            for (int i = 0; i < n.Length; i++)
            {
                Console.WriteLine(n[i]);
            }

            Console.ReadLine(); 
        }
    }
}

其实我们还可以取中间的数作为基准，具体示例如下：

        private  void Sort(int[] numbers, int left, int right)
        {
             //左边索引小于右边，则还未排序完成 　　
               if (left < right)
            {
                //取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移 　　
                   int middle = numbers[(left + right) / 2];
                int i = left - 1;
                int j = right + 1;
                while (true)
                {
                    while (numbers[++i] < middle && i < right) ;
                    while (numbers[--j] > middle && j > 0) ;
                    if (i >= j)
                        break;
                    Swap(numbers, i, j);

                }        
                Sort(numbers, left, i - 1);
                Sort(numbers, j + 1, right);

                for (int k = 0; k < numbers.Length; k++)
                {
                    Console.WriteLine(numbers[k]);
                }
                Console.ReadLine(); 
            }           
        }

        private  void Swap(int[] numbers, int i, int j)
        {
            int number = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = number;
        }