快速排序算法C#实现

最近想把几大经典的排序算法系统的整理过一遍，写下笔记，算是复习吧！！

1、快速排序。

　　快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列——来自百度百科。

　　假设我们要对数组Array 6  7  2  1  9  4  3  10  5  8排序，先在序列中找任意一个数（此例取第一个）作为基准数（就是一界限，大于此数放序列的右边小于或等于放左边）

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 6 　　 7　　2 　　1 　　 9 　　4 　　3 　  10 　   5 　   8

　　

从j开始往前找一个小于或等于X的数，初始化:i=0,j=9,基准数 X=6

当j=8时，Array [0] = Array[8]（i++），数组变为:

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 7　　2 　　1 　　 9 　　4 　　3 　  10 　   5 　   8

 

当i=1时，Array[8]= Array[1](j--),数组变为:从i开始往后找一个比X大的数，

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 7　　2 　　1 　　 9 　　4 　　3 　  10 　   7 　   8

 

当j=6时，Array[1]= Array[6](i++),数组变为:从j开始往前找一个小于或等于X的数，

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 3　　2 　　1 　　 9 　　4 　　3 　  10 　   7 　   8

当i=4时，Array[6]= Array[4] (j--),数组变为:从i开始往后找一个大于X的数,

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 3　　2 　　1 　　 9 　　4 　　9 　  10 　   7 　   8

当j=5时，Array[4]= Array [5] (i++),数组变为:从j开始往前找一个小于或等于X的数,

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 3　　2 　　1 　　4 　　4 　　9 　  10 　   7 　   8

 

当i==j==5时，停止循环，将基准数填入，Array[5]=X,数组变为:

下标 　　0　　 1　　 2　　 3　　 4 　　5 　　6 　　7 　　8　　 9
 值  　　 5 　　 3　　2 　　1 　　4 　　6 　　9 　  10 　   7 　   8

 

C#代码实现:此次循环结束后，可以看出，Array[5]左边的数据都比它小，右边的数都比它大，因此再对Array [0…4] 和Array [6…9]重复上述步骤即可（递归调用）。

 static void Main(string[] args)
{
     int[] array = new[] {6, 7, 2, 1, 9, 4, 3, 10, 5, 8};
     Sort(array, 0, array.Length - 1);
     foreach (int item in array)
     {
         Console.Write(item + " ");
      }
        Console.ReadLine();
  }

　　　　  /// <summary>
        /// 排序
        /// </summary>
        /// <param name="array">要排序的数组</param>
        /// <param name="low">下标开始位置，向右查找</param>
        /// <param name="high">下标开始位置，向左查找</param>
        public static void Sort(int[] array, int low, int high)
        {
            if (low >= high)
                return;
            //完成一次单元排序
            int index = SortUnit(array, low, high);
            //递归调用，对左边部分的数组进行单元排序
            Sort(array, low, index - 1);
            //递归调用，对右边部分的数组进行单元排序
            Sort(array, index + 1, high);
    }

　　　　  /// <summary>
        /// 单元排序
        /// </summary>
        /// <param name="array">要排序的数组</param>
        /// <param name="low">下标开始位置，向右查找</param>
        /// <param name="high">下标开始位置，向右查找</param>
        /// <returns>每次单元排序的停止下标</returns>
        public static int SortUnit(int[] array, int low, int high)
        {
            int key = array[low];//基准数
            while (low < high)
            {
                //从high往前找小于或等于key的值
                while (low < high && array[high] > key)
                    high--;
                //比key小开等的放左边
                array[low] = array[high];
                //从low往后找大于key的值
                while (low < high && array[low] <= key)
                    low++;
                //比key大的放右边
                array[high] = array[low];
           }
            //结束循环时，此时low等于high，左边都小于或等于key，右边都大于key。将key放在游标当前位置。 
            array[low] = key;
            return high;
        }