排序_2.快速排序

快速排序

简介：

　快速排序(QuickSort)是对冒泡排序的一种改进的交换排序算法，又称　分区交换排序(partition-exchange sort)．
在平均状况下，快速排序排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。
事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。因此称为快速排序．

算法描述：

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

• 步骤为：

  1. 从数列中挑出一个元素，称为”基准”（pivot），
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

  递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

• 化简得：

  1. 先从数列中取出一个数作为基准数。
  2. 分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
  3. 再对左右区间重复第二步,直到各区间只有一个数。

冒泡排序视频演示　备份链接１　备份链接２

过程演示：

首先：
       a[0]  a[1]  a[2]  a[3]  a[4]  a[5]  a[6]  a[7]  a[8]  a[9]
　　　　 3     0     1     8     7     2     5     4     9     6
- 第一次：
　　　　 　　　                                                         // 取出tmp = a[0],　
　　　　                                                                    // i = 0, j = 9, 比较 tmp与 a[j](a[9]) , 3 <---> 6, 小, j--, 得：
　　　　 3     0     1     8     7     2     5     4     9     6 
　　　　 　　　                                                         // i = 0, j = 8, 比较 tmp与 a[j](a[8]) , 3 <---> 9, 小, j--, 得：
　　　　 3     0     1     8     7     2     5     4     9     6 
　　　　 　　　                                                         // i = 0, j = 7, 比较 tmp与 a[j](a[7]) , 3 <---> 4, 小, j--, 得：
　　　　 3     0     1     8     7     2     5     4     9     6 
　　　　 　　　                                                         // i = 0, j = 6, 比较 tmp与 a[j](a[6]) , 3 <---> 5, 小, j--, 得：
　　　　 3     0     1     8     7     2     5     4     9     6 
　　　　 　　　                                                         // i = 0, j = 5, 比较 tmp与 a[j](a[5]) , 3