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 }，继续这样排，直到不能排为止。

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);
	}

本文来自博客园，作者：一纸年华，转载请注明原文链接：https://www.cnblogs.com/nullcodeworld/p/16749326.html