快速排序算法最详细讲解

想起刚接触C语言时，第一次知道快速排序算法便惊为天人，思路真的好。
当我再次回顾算法时，发现其实不止一种思路，这里详细介绍一种，简单讲下另一种
首先第一种思路：
假设有一个数组 Array【9】=【4，1，3，7，2，5，6，9，,8】
我们想把它按照升序排列
第一步：
把第一个数 4 设为比较的基准数 = Reference（参考） = Array【begin】
我们需要把比它小的数都放到前面，比它大的数都放到后面

第二步：
从第二个数开始，逐个与基准数 Reference 进行比较
函数体为QSort (array, begin, end);
假设我们设置 i = 1 = begin + 1 ，j = 8 = end （这里假设元素个数已知）
那么首先 Array【i】= 1 < Array【begin】 = 4，不做交换，i++ （i = 2）
继续比较 Array【i】= 3 < Array【begin】 = 4，不做交换，i++ （i = 3）
接着比较 Array【i】= 7 > Array【begin】 = 4，将 Array【i】与 Array【j】做交换
注意，这步是将比基准数大的元素调至数组后面，此时7和8进行交换，

即数组变成：

i 不变，j- -（变成i = 3，j = 7）这样下次就是和倒数第二个数交换，因为倒数第一个数已经确定是比基准数4更大的数
接着和基准数比较Array【i】= 8 > Array【begin】 = 4，同上，此时8和9进行交换

即数组变成：

i 不变，j- -（变成i = 3，j = 6）
如此往复，直到不满足 i < j
最后一次交换为5和2进行交换，i不变，j- -，此时 i = 3，j = 3，不满足 i < j 的条件

此时数组：

最后需要将基准数调至基准位，即 4 和 Array【i】= 2 进行交换

此时数组：

第一次比较结束，此时下标begin = 0，end = 8，i = 3，j = 3
特殊情况：若交换基准数时Array【i】仍大于基准数Array【begin】，如下

最后一次交换完成后，i == j == 3，然而此时Array【i】== 10 > 基准数 4
那么交换前需要 i - -，以确保基准数前的数均比它小，基准数后的数均比它大

第三步：函数嵌套
可以发现以基准数为分界，整个数组是有一定规律的

那么把基准数两边的数看做两个新的无序数组（看做两个数组，实际数组并未拆开），同样进行比较，这样一直嵌套最终数组排序完成，到这其实思路已经结束了，想要详细了解过程可以看完，或者自己试试
将 i 作为 前段数组的 end ，j 作为后段数组的 begin
即 begin 到 i 为前段，j 到 end 为后段

函数体为：
QSort (array, begin, end);
{
…
…第二步
…
QSort (array, begin, i);
QSort (array, j, end);
}

在嵌套函数中重复第二步，设 i = begin + 1 ，j = end则
A【4】 = 【2，1，3，4】，基准数Array【begin】 = 2 ，比较前下标 begin = 0 ，end = 3 ， i = begin + 1 = 1 ，j = end = 3
实际上进入第一个嵌套后又会有嵌套，所以第二个嵌套永远会在第一个嵌套之后，故下面至以第一个嵌套排序作为例子
进行第二步的排序
按照算法，1不动，3和4进行交换，此时 i = 2，j = 2
A【4】= 【2，1，4，3】，注意，此时出现了上面提到的特殊情况，
基准数 Array【begin】= 2 < Array【i】= 4，因此 i- -，再对基准数进行交换（此时为2 与 1 交换）因此
A【4】= 【1，2，4，3】，比较后下标begin = 0，end = 3， i = 1 ， j = 2
同样的，以基准数为界再次嵌套，对两数组进行划分
先划分A
QSort (array, begin, i);
QSort (array, j, end);
那么
A1【2】= 【1，2】，下标begin = 0 ，end = 1，i = 1 ，j = 1
无需比较，一开始就不满足 i < j 的条件，基准数交换仍为特殊情况，i- - 后再交换（此时i = 0，所以Array【begin】 == Array【i】，即与自身交换，无改变），结果为
A1【2】=【1，2】，下标begin = 0 ，end = 1，i = 0 ，j = 1
按照顺序，本应该继续拆分排序，但是根据参数，此时
进入QSort (array, begin, i); 因为begin == i，立刻退出
接着进入QSort (array, j, end); 同样因为 j == end,立刻退出
不断退出进入嵌套，比较完成后又退出嵌套，完成排序
嵌套停止的条件是函数的第二、三个参数相等，直观地说就是“拆分”的数组仅有一个数
附代码：

#include<stdio.h>
#include<math.h>

//打印函数
void display(int array[],int maxlen)
{
	int i;

	for(i=0 ; i<maxlen ; i++)
	{
		printf("%d ",array[i]);
	}
	printf("\n");

	return;
}
	

//交换函数
void swap(int *a,int *b)
{
	int temp;
	temp= *a;
	*a= *b;
	*b= temp;

	return;
}


//快速排序算法
void QSort(int array[], int begin, int end)
{
	int i,j;
	display(array,end+1);
	if(begin < end)
	{
		i= begin+1;	//将array[begin]作为基准数
		j= end;	//array[end]是数组最后一位
		while(i < j)
		{
			if(array[i] > array[begin])
			{
				swap(&array[i],&array[j]);	//如果该元素大于基准数，则交换位置
				j--;
			}
			else
			{
				i++;	//继续比较
			}
		}
		//跳出后i=j

		if(array[i] >= array[begin])	//特殊情况
		{
			i--;
		}

		swap(&array[begin],&array[i]);	//将基准数换至分界点

		QSort(array,begin,i);	//继续排序，以此类推，直到begin == i，j == end
		QSort(array,j,end);	//或者说直到第二第三两个参数相等
	}
}

//主函数
main()
{
	int array[10];	//数组长度可改变
	int maxlen,i;
	
	printf("Input 10 number:\n");
	for(i=0 ; i<10 ; i++)
	{
		scanf("%d",&array[i]);
	}
	
	maxlen=10;	//快速排序
	QSort(array,0,maxlen-1);

	printf("Positive sequence alignment:\n");
	display(array,maxlen);
}

第二种思路：
同样的选择第一个数作为基准数，最大的区别是：
同时从第二个数和最后一个数开始向中间遍历
前面找到比基准数大的数后停，后面找到比基准数小的数后停，交换两数
交换完成后继续遍历，直到相遇，同第一种思路，嵌套，退嵌套，直到排序完成，这里不做详细讲解，与第一种思路相差不大。