说起排序，总是会想起大名鼎鼎的快速排序，等自己再次翻开快速排序时，感觉是很陌生的，从这个对比也能看出自己确实是已经忘记了曾经重要的日子。
快速排序使用了分治思想，分而治之。为了达到它传说中较低的时间度，接受了来自大家多年的挑战还依然是名副其实的快速排序。
一个简单的例子就是通过简单的实例来说明。
我们假设一组数字如下：
6,9,4,1,8,7,2,3,5
我们假设以第一个数为参考，即temp为6，两边的数分别为i,j,从这组数的两边来比较这个中间变量，不断的移动下标，从右边开始寻找比temp小的数，从左边开始和寻找比temp大的数。
在这个例子中就是以8为基本的参考，分别从这组数的右边，左边开始移动下标，寻找分别是小于6，大于6的节点。
需要经过这么几轮的比较。
第一轮，我们发现右边第一个节点5<6,就是它了，从左边开始，节点9>6,需要对这个两个节点进行对调。
6,9,4,1,8,7,2,3,5
变为
6,5,4,1,8,7,2,3,9
继续移动下标，从右边开始寻找小于6的，从左边开始寻找大于6的数，结果我们比较一番，发现数3<6,8>6
所以结果如下：
6,5,4,1,8,7,2,3,9
变为：
6,5,4,1,3,7,2,8,9
接下来继续移动下标，发现，2<6,7>6得到的结果如下：
6,5,4,1,3,7,2,8,9
变为：
6,5,4,1,3,2,7,8,9
这个时候从右，从左下标都没法再移动了，再移动就交叉了，这个时候就是需要对这组数进行划分了，划分的基本参考就是6
6,5,4,1,3,2,7,8,9
变为：
2,5,4,1,3,6,7,8,9
这个时候就分成了两组数2,5,4,1,3 和7,8,9两组数，然后根据分治思想需要对着两组数进行进一步的比较。
右边的3个数7,8,9已经是最后结果了，我们来看看左边的数,2,5,4,1,3
设定temp=2，然后下标继续从右，从左开始移动。
2,5,4,1,3
变为：
2,1,4,5,3
然后下标继续移动就移动不了了。继续拆分。
变为1,2, 4,5,3 继续比较，拆分得到最后的结果。

通过程序的实现如下：

  1.  

  2. void quicksort(int left,int right)

  3.  

  4. {

  5.  

  6. int i,j,t,temp;

  7.  

  8. if(left>right)

  9.  

  10. return;

  11.  

  13.  

  14. temp=a[left]; //temp中就是基准数,取第一个数

  15.  

  16. i=left;

  17.  

  18. j=right;

  19.  

  20. while(i!=j)

  21.  

  22. {

  23.  

  24. //顺序很重要，要先从右边开始找

  25.  

  26. while(a[j]>=temp && i<j)

  27.  

  28. j--;

  29.  

  30. //再找左边的

  31.  

  32. while(a[i]<=temp && i<j)

  33.  

  34. i++;

  35.  

  36. //交换两个数在数组中的位置

  37.  

  38. if(i<j)

  39.  

  40. {

  41.  

  42. t=a[i];

  43.  

  44. a[i]=a[j];

  45.  

  46. a[j]=t;

  47.  

  48. }

  49.  

  50. }

  51.  

  52. //最后分拆，得到两组数，对基准书进行重新初始化

  53.  

  54. a[left]=a[i];

  55.  

  56. a[i]=temp;

  57.  

  59.  

  60. quicksort(left,i-1);//处理左边的

  61.  

  62. quicksort(i+1,right);//处理右边的

  63.  

  64. }