详谈内部排序之快速排序

快速排序

交换排序：

​ 两两比较待排序记录的关键码，如果发生逆序（即排列顺序与排序后的次序正好相反），则交换之，直到所有记录都排好序为止 。

​ 交换排序的主要算法有：

​ (1) 冒泡排序

​ (2) 快速排序

---

快速排序基本思想：

(1) 基本思想：

​ 通过一趟排序将待排序列以枢轴为标准划分成两部分，使其中一部分记录的关键字均比另一部分小，再分别对这两部分进行快速排序，以达到整个序列有序。

​ 通常取第一个记录的值为基准值或枢轴。

(2) 具体做法：

​ 附设两个指针low和high，初值分别指向第一个记录和最后一个记录，设枢轴为key；

​ 1.从high 所指位置起向前搜索，找到第一个不大于基准值的记录与枢轴记录相互交换；

​ 2.从low 所指位置起向后搜索，找到第一个不小于基准值的记录与枢轴记录相互交换。

​ 3.重复这两步直至为止。

---

快速排序的过程：

例：以关键字序列（256，301，751，129，937，863，742，694，076，438）为例

​ 写出执行快速算法的各趟排序结束时，关键字序列的状态。

初始队列	256	301	751	129	937	863	742	694	076	438
第一趟	【076	129】	256	【751	937	863	742	694	301	438】
第二趟	076	129	256	【438	301	694	742】	751	【863	937】
第三趟	076	129	256	【301】	438	【694	742】	751	863	937
第四趟	076	129	256	301	438	694	742	751	863	937

详细讲解：

​ 首先我们默认每一组数据的枢轴为它第一个元素。即将初始队列中的第一个元素：256设置为枢轴。

​ 我们这里将，low或high的值改变到其他位置后，将low或high设为0，以方便辨别每一步步骤。

第一趟：

将low = 256，high = 438，key = 256；

先从high处开始：

① key < high ，所以位置不变，将 high- - 得：low = 256，high = 076

② key > high ，所以交换位置，将 low= high，同时将high处的值设为0得：low = 076，high = 0

即：

076 301 751 129 937 863 742 694 0 438

---

当high的位置改变后，再从low处开始：

③ key > low ，所以位置不变，将 low = 301，high = 0

④ key < low ，所以交换位置，将 low = 0，high = 301

即：

076 0 751 129 937 863 742 694 **301 ** 438

当low的位置改变后，再从high处开始：

⑤ key < high ，所以位置不变，low = 0，high = 694

⑥ key < high ，所以位置不变，low = 0，high = 742

⑦ key < high ，所以位置不变，low = 0，high = 863

⑧ key < high ，所以位置不变，low = 0，high = 937

⑨ key < high ，所以位置不变，low = 0，high = 129

⑩ key > high ，所以交换位置，low = 129，high = 0

即：

076 129 751 0 937 863 742 694 301 438

---

当high的位置改变后，再从low处开始：

⑪ key > low ，所以位置不变，low = 751，high = 0

⑫key < low ，所以交换位置，low = 0 ，high = 751

076 129 0 751 937 863 742 694 301 438

当low和high都搜算到一个位置的时候，说明第一趟查询结束，所以将low和high所指的地方赋值为key=256；

得到 076 129 256 751 937 863 742 694 301 438

由上可知：

在枢轴256 左边的都是小于256的，在枢轴256 右边的都是大于256的。

之后再将左边和右边分为两个序列，分别进行如上的快速排序步骤。

之后的步骤只需重复上面的步骤，直到全部排列完成。

---

一趟快速排序算法描述：

int Partition (Elem R[ ], int low, int high){
     R[0] = R[low];   pivotkey = R[low].key;  
     while (low < high) { //从两端交替向中间扫描
         while (low < high && R[high].key >= pivotkey) - - high;
         R[low] = R[high];  //将比枢轴记录小的移到低端
         while (low < high && R[low].key <= pivotkey)  + + low;
         R[high] = R[low];  //将比枢轴记录大的移到高端
    } 
    R[low] = R[0];   //枢轴记录到位
    return low;    //返回枢轴位置
} 

---

快速排序核心算法描述：

void QSort ( Elem R[ ], int low, int high ){  //对序列R[low...high]进行快速排序
   if (low < high-1) {    //长度大于1
      pivot = Partition( L,low,high);  //将R[low..high]一分为二
      QSort(L,low, pivot-1);    //对低子表递归排序，pivo是枢轴
      QSort(L, pivot+1, high);   // 对高子表递归排序
      }
} 
void QuickSort(Elem R[], int n){   //对记录序列进行快速排序
     QSort(R, 1, n);
} 

---

快速排序算法分析：

​ •可以证明，函数Quicksort的平均计算时间是O(nlog2n)。实验结果表明：就平均计算时间而言，快速排序是我们所讨论的所有内排序方法中最好的一个。

​ •快速排序是递归的，需要有一个栈存放每层递归调用时的指针和参数(新的low和high)。最大递归调用层次数与递归树的深度一致，理想情况为 。因此，要求存储开销为 O(log2n)。

•最好情况：

​ 如果每次划分对一个对象定位后，该对象的左侧子序列与右侧子序列的长度相同，则下一步将是对两个长度减半的子序列进行排序，这是最理想的情况。此时，快速排序的趟数最少。

•最坏情况：

​ 即待排序对象序列已经按其关键码从小到大排好序的情况下，其递归树成为单支树，每次划分只得到一个比上一次少一个对象的子序列。这样，必须经过 n-1 趟才能把所有对象定位，而且第 i 趟需要经过 n-i 次关键码比较才能找到第 i 个对象的安放位置，总的关键码比较次数将达到n^2/2

---

快速排序的性能分析：

时间效率：O(nlog2n) —因为每趟确定的元素呈指数增加

空间效率：O(log2n)—因为算法的递归性，要用到栈空间

稳 定 性：不稳定 —因为可选任一元素为支点。

---

思考问题：快速排序是否真的比任何排序算法都快？

答：——基本上是！因为每趟可以确定的数据元素是呈指数增加的！

设每个子表的支点都在中间（比较均衡），则：

第1趟比较，可以确定1个元素的位置；

第2趟比较（2个子表），可以再确定2个元素的位置；

第3趟比较（4个子表），可以再确定4个元素的位置；

第4趟比较（8个子表），可以再确定8个元素的位置；

​ ……

综上只需 （ └ log2n ┘ + 1 ） 趟便可排好序。

​ 而且，每趟需要比较和移动的元素也呈指数下降，加上编程时使用了交替逼近技巧，更进一步减少了移动次数，所以速度特别快。