C#：快速排序

1. 介绍

快速排序是一种非常高效的排序算法，它采用“分而治之”的思想，把大的拆分为小的，小的再拆分为更小的。

其原理如下：
对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中前一部分的所有记录均比后一部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均有序为止。

具体而言，算法步骤如下：

1. 分解：将输入的序列array[m..n]划分成两个非空子序列array [m…k]和array [k+1…n]，使array [m…k]中任一元素的值不大于array [k+1…n]中任一元素的值。
2. 递归求解：通过递归调用快速排序算法分别对array [m…k]和array [k+1…n]进行排序。
3. 合并：由于对分解出的两个子序列的排序是就地进行的，所以在array [m…k]和array [k+1…n]都排好序后不需要执行任何计算array [m…n]就已排好序。

2. 排序过程

以数组{ 5, 4, 9, 8, 7, 6, 0, 1, 3, 2 }为例。排序过程如下：

• 取第一个值为基准值，即5。
• i为下标，从左向右移。
• j为下标，从右向左移。

5	4	9	8	7	6	0	1	3	2
i									j

从j开始，j数组值为2，<5，所以应该放到左边，赋值给当前i的值，i右移一位。

2	4	9	8	7	6	0	1	3	2
	i								j

i数组值为4，<5，所以位置不变，i再右移一位。

2	4	9	8	7	6	0	1	3	2
		i							j

i数组值为9，>5，所以应该放到右边，赋值给当前j的值，j向左移一位。

2	4	9	8	7	6	0	1	3	9
		i						j

j数组值为3，<5,所以应该放到左边，赋值给当前i的值，i向右移一位。

2	4	3	8	7	6	0	1	3	9
			i					j

i数组值为8，>5，所以放到右边，赋值个当前j的值，j向左移一位。

2	4	3	8	7	6	0	1	8	9
			i				j

j数组值为1，<5，所以放到左边，赋值给当前i的值，i右移。

2	4	3	1	7	6	0	1	8	9
				i			j

i数组值为7，>5，放右边，j左移。

2	4	3	1	7	6	0	7	8	9
				i		j

j数组值为0，<5，放左边，i右移。

2	4	3	1	0	6	0	7	8	9
					i	j

i数组值为6，>5，放右边，j左移。

2	4	3	1	0	6	6	7	8	9
					i，j

这时，i和j已经相等，跳出移动循环，把基准值赋给i数组值。

2	4	3	1	0	5	6	7	8	9

第一趟排序之后，数组就为{ 2, 4, 3, 1, 0, 5, 6, 7,8,9 }。
第二趟排序的话就会分成两组，即{2,4,3,1,0}和{5,6,7,8,9 }，继续这样排，直到不能排为止。

3. 程序代码

程序如下：

static void Main(string[] args)
{
    int i = 0;
    int[] a = { 5, 4, 9, 8, 7, 6, 0, 1, 3, 2 };
    int len = a.Length;
    quickSort(a);
    for (i = 0; i < len; i++)
    {
        Console.WriteLine(a[i] + "");
    }
}
public static void quickSort(int[] array)
{
    sort(array, 0, array.Length - 1);
}
/// <summary>
/// 排序
/// </summary>
/// <param name="array">需要排列的数组</param>
/// <param name="low">低位</param>
/// <param name="high">高位</param>
static void sort(int[] array, int low, int high)
{
    if (low >= high)
    {
        return;
    }
    // 基准值 选取当前数组第一个值
    int index = array[low];
    // 低位i从左向右扫描
    int i = low;
    // 高位j从右向左扫描
    int j = high;
    while (i < j)
    {
        while (i < j && array[j] >= index)
        {
            j--;
        }
        if (i < j)
        {
            array[i] = array[j];
            i++;
        }
        while (i < j && array[i] < index)
        {
            i++;
        }
        if (i < j)
        {
            array[j] = array[i];
            j--;
        }
    }
    array[i] = index;
    // 左边的继续递归排序
    sort(array, low, i - 1);
    // 右边的继续递归排序
    sort(array, i + 1, high);
}