快速排序算法最详细讲解

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

第二步：
从第二个数开始，逐个与基准数 Reference 进行比较
函数体为QSort (array, maxlen, begin, end);（maxlen = 9）
假设咱们设置 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进行交换，即数组：
Array【9】= 【4，1，3，8，2，5，6，9，7】，i 不变，j- -（此时i = 2，j = 7）
接着比较Array【i】= 8 > Array【begin】 = 4，同上，此时8和9进行交换，即数组：
Array【9】= 【4，1，3，9，2，5，6，8，7】，i 不变，j- -（此时i = 2，j = 6）
直到不知足 i < j，此时数组：
Array【9】= 【4，1，3，2，5，6，9，8，7】，最后一次交换为5和2进行交换，i不变，j- -，此时 i = 3，j = 3，不知足 i < j 的条件
最后须要将基准数调至基准位，即 4 和 Array【i】= 2 进行交换（特殊状况：若此时Array【i】仍大于基准数Array【begin】，那么交换前须要 i - -，以确保基准数前的数均比它小，基准数后的数均比它大），此时数组：
Array【9】= 【2，1，3，4，5，6，9，8，7】
第一次比较结束，此时下标begin = 0，end = 8，i = 3，j = 3

第三步：函数嵌套
能够发现以基准数为分界，整个数组是有必定规律的
那么把基准数两边的数看作两个新的无序数组（看作两个数组，实际数组并未拆开），一样进行比较，这样一直嵌套最终数组排序完成，到这其实思路已经结束了，想要详细了解过程能够看完，或者本身试试
将 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【3】= 【1，2】，下标begin = 0 ，end = 1，i = 1 ，j = 1
无需比较，一开始就不知足 i < j 的条件，基准数交换仍为特殊状况，i- - 后再交换（此时i = 0，因此Array【begin】 == Array【i】，即与自身交换，无改变），结果为
A1【3】=【1，2】，下标begin = 0 ，end = 1，i = 0 ，j = 1
按照顺序，本应该继续拆分排序，可是根据参数，此时
进入QSort (array, begin, i); 由于begin == i，马上退出
接着进入QSort (array, j, end); 一样由于 j == end,马上退出
不断退出进入嵌套，比较完成后又退出嵌套，完成排序
嵌套中止的条件是函数的第3、四个参数相等，直观地说就是“拆分”的数组仅有一个数
附代码：

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

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