相信算法对于许多开发人员来说都是一大难点，之所以难，就像设计模式一样，许多人在阅读之后，没有很好地理解，也不愿意动手上机操作，只停留在理论的学习上面，随着时间推移就慢慢淡忘。

有些东西，你可以发明创造，但是有些东西呢，你要么死记硬背，要么好好理解并动手进行练习来巩固。搞开发的话，死记硬背没用，好好理解火候还是差一点。最好的方式，还要在理解的基础上多敲敲代码，使自己即知其然，又知其所以然。

本篇只是简单介绍快速排序算法，大牛可以从旁帮忙指点，但是请嘴下留情哦:)

 快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 这里可以看看老外的一个非常棒的创意视频来认识快速排序的算法是怎么样的(http://v.youku.com/v_show/id_XMzMyODk4NTQ4.html)，它以舞蹈的方式形象而生动地再现快速排序算法的方式。

 假设现有一组整型数据需要你用快速排序的算法来进行排序（如int[] unsort = { 3, 2, 4, 1, 7, 5}，假设以第一个数据3作为左右数据的分隔数）

那么运行完int midPosition = QuickSort(unsort, left, right);这一句的时候，得出的数组结果是：
｛2, 1, 3, 4, 7, 5｝，并且midPosition返回数据3的索引位置（即为索引2）。

这样之后，就可以根据3为分隔数（3的位置已经排好序），把数据分为｛2, 1｝，｛ 4, 7, 5｝两部分，然后通过递归的方式进行排序。

下面的代码我觉得很好理解，虽然在网上看到有很多可以改进的地方，但是这都不是本文的重点。本文只是入门的内容，能简单理解，尽量简单。毕竟要复杂些，我也写不出来。 

唯一不好理解的地方，就是怎么去理解分隔数的位置。就我本人来说吧，以前在大学时也没学好，以至于后面来学习的时候，总会先入为主，觉得好难好难。人有抵触的心结在的话，做事情往往是事倍功半。

所以在我花大部分时间去理解好分隔数的位置之后，下面这种快速排序算法就能自己手动敲打出来了。理解了之后，再动手实践能巩固学习到的知识。

下面谈谈我对求分隔数位置的理解，不好的地方，欢迎大家讨论。

（1）预先定好一个分隔数，默认为第一个数（如我们讲到的实例3，我们假设是按照从小到大的顺序排序）

（2）按照先从右端和左端向中间的方式来进行排序（一趟排序只是排好分隔数的位置，并且分隔数左部分的数据都比右部分的数据要小）。

右端先开始排序，如果右端的数据比分隔数要大时，则位置不用改变。一旦出现右端的数据比分隔数要小时，则需要把右端的这个小数据挪到左边去，具体看下面步骤说明。

并且排序方向改为从左端开始，如果左端的数据比分隔数要小时，则位置不用改变。一旦出现左端的数据比分隔数要大时，则需要把左端的这个大数挪到右边去。

并且排序方向又改为从刚才已到达的右边位置再进行排序。

其实说白了，就是开始时，我们从左边拿出了一个数存给一个变量（分隔数），相当于左边留出了一个空位，让分隔数右边的数（这个数小于分隔数）来存放，一旦存放了，则右边就空出一个空位，等待分隔数左边的数（这个数比分隔数要大）来存放，反正就这么一直调来调去，调到没得调了，剩下的空位就是分隔数的位置。

步骤：{ 3, 2, 4, 1, 7, 5}

第一小步：把3赋值给一个存储的变量，假设是 int splitNum = 3 （而数组3的这个位置到时将会给比3小的数占用）。我们可以理解为数组3这个数暂时是一个空位

即：{ X, 2, 4, 1, 7, 5}，X代表空位

第二小步：拿splitNum跟右端的5来进行比较（跟右端比较的目的是什么，当然是想把比3大的数保留在3的右边，比3小的数放在3的左边），5大，所以5右边不变

即：{ X, 2, 4, 1, 7, 5}

第三小步：拿splitNum跟右端的7来进行比较，7大，所以7右边不变

即：{ X, 2, 4, 1, 7, 5}

第四小步：拿splitNum跟右端的1来进行比较，splitNum大，所以X赋值为1（那么原先数组1的索引位置就是一个空位）

即：{ 1, 2, 4, X, 7, 5}

第五小步：拿splitNum跟左端的1来进行比较，（跟左端比较的目的是什么，当然是想把比3大的数放到3的右边，比3小的数保留在3的左边），splitNum大，所以1不变

即：{ 1, 2, 4, X, 7, 5}

第六小步：拿splitNum跟左端的2来进行比较，splitNum大，所以2不变

即：{ 1, 2, 4, X, 7, 5}

第七小步：拿splitNum跟左端的4来进行比较，4大，所以X赋值为4，（那么原先数组4的索引位置就空出来了）

即：{  1, 2, X, 4, 7, 5}

第八小步：由于两天都比较完了，那X赋值为splitNum的值

即：{  1, 2, 3, 4, 7, 5}

从而实现以3为分隔数，3左边的数都比3右边的数要小（按照从小到大的顺序排序）

namespace Sort
{
    class Program
    {
        static void Main(string[] args)
        {
            string result = string.Empty;
            int[] unsort = { 3, 2, 4, 1, 7, 5 };

            result = GetPrint(unsort);
            Console.Write("排序前结果： ");
            Console.WriteLine(result);

            //快速排序
            QuickSort(unsort, 0, unsort.Length - 1);

            result = GetPrint(unsort);
            Console.Write("排序后结果： ");
            Console.WriteLine(result);

            Console.ReadLine();
        }

        /// <summary>
        /// 调用快速排序算法
        /// </summary>
        /// <param name="unsort">待排序的整形数组</param>
        /// <param name="left">左边起始点</param>
        /// <param name="right">右边结束点</param>
        public static void QuickSort(int[] unsort, int left, int right)
        {
            if (left < right)
            {
                //获取一次排序的中间索引位置
                int midPosition = GetSplitNum(unsort, left, right);
                
                //递归实现
                QuickSort(unsort, left, midPosition - 1);
                QuickSort(unsort, midPosition + 1, right);
            }
        }

        /// <summary>
        /// 获取一次排序的中间索引位置
        /// </summary>
        /// <param name="unsort">待排序的整形数组</param>
        /// <param name="left">左边起始点</param>
        /// <param name="right">右边结束点</param>
        public static int GetSplitNum(int[] unsort, int left, int right)
        {
            int splitNum = unsort[left];
            while (left < right)
            {
                /**
                 * 从右端开始比较
                 * （1）假如从右端过来的数比分隔数要大，则不用处理
                 * （2）假如从右端过来的数比分隔数要小，则需要挪到分隔线左边
                 * */
                while (left < right && splitNum <= unsort[right])
                {
                    right--;
                }
                unsort[left] = unsort[right];

                /**
                 * 从从端开始比较
                 * （1）假如从左端过来的数比分隔数要小，则不用处理
                 * （2）假如从左端过来的数比分隔数要大，则需要挪到分隔线右边
                 * */
                while (left < right && splitNum >= unsort[left])
                {
                    left++;
                }
                unsort[right] = unsort[left];
            }
            //一趟比较之后，分隔数的位置就可以确认起来
            unsort[left] = splitNum;

            return left;
        }

        /// <summary>
        /// 打印输出结果
        /// </summary>
        /// <param name="unsort">数据</param>
        public static string GetPrint(int[] unsort)
        {
            string result = string.Empty;
            foreach (int n in unsort)
            {
                if (!string.IsNullOrEmpty(result))
                {
                    result += string.Format("->{0}", n);
                }
                else
                {
                    result = string.Format("{0}", n);
                }
            }
            return result;
        }
    }
}