顾名思义，快速排序（quick sort）速度十分快，时间复杂度为O(nlogn)。虽然从此角度讲，也有很多排序算法如归并排序、堆排序甚至希尔排序等，都能达到如此快速，但是快速排序使用更加广泛，以至于STL中默认排序方法就是快速排序。此外，快速排序的思想——划分（Partition）思想给人很多启发。下面以非降序排序进行介绍，不求有更深的理解，只求为自己做个简要笔记。
1）划分（Partition）
划分思想十分简单，却又十分重要，应用广泛。即：将待排序数组以某一个元素为键值（Key），将比此key小的放在左边，否则放在右边。其可能的情况为：3,1,4,2,0,KEY=5,6,9,7,8.键值Key可以任意选择。好的键值对于提高性能有帮助，但选择最优键值的方法，本身就是一种排序思想。所以，对于排序来说，一般选择第一个元素作为Key。以下为Partition代码的一种实现：
// Partition - <small> KEY <big>
int partition(int arr[], int begin, int end)
{
int i=begin, j=end-1, key;
if (i>=j) return i;
for (key=arr[i]; i<j;){
// find last arr[j]<key
for(; i<j && arr[j]>=key; --j);
arr[i] = arr[j];
// find first arr[i]>key
for(; i<j && arr[i]<=key; ++i);
arr[j] = arr[i];
}
arr[i] = key;
return i; // current key position
} // Time O(n)
// after partition, the KEY must be the position where ordered
首先定义两个下标变量i,j，分别指向开始和结尾，并将开始begin的元素作为键值key。然后从后向前遍历arr[]，找到小于key的元素j，将其覆盖i；从前向后遍历arr[]，找到大于key的元素i，将其覆盖j。直到i与j碰头，将key写回i。此时i的位置即选中的key应该在的位置，即：key左边的元素不大于key，key右边的不小于key。返回此时key的下标位置i。其时间复杂度为O(n).
2）快速排序（quick sort）
快速排序就是利用划分思想。每次经过划分之后，其key所在位置（下标）必然是经过排序后key所在的位置！如上面的3,1,4,2,0,KEY=5,6,9,7,8。元素5此时在位置5，正是其排序后的位置。再如：3,5,1,KEY=10,23,19.元素10在位置3，也是其排完序后所在的位置。正是如此，利用划分进行快速排序才成为可能。
快速排序思想为：对于数组arr[]以及其首位元素位置begin和末尾元素end，选择其中一个元素作为Key，进行一趟划分，得到key此时应该在的位置i；然后对于key的左部分begin~i-1进行划分，对于key右部分i+1~end进行划分；逐渐划分更小的范围进行划分。最终排序完毕。每次进二分划分，一共划分了logn次，故快速排序时间复杂度为O(nlogn)。
// quick sort, ascending order
void quick_sort(int arr[], int begin, int end)
{
int mid = partition(arr,begin,end);
if (mid<0) return;
quick_sort(arr,begin,mid);
quick_sort(arr,mid+1,end);
}
一种写法更加巧妙的快速排序，将quick_sort与partition结合，如下：
// A simple quick sort version, which combine partition and sort
void quick_sort(int arr[], int begin, int end)
{
int i=begin, j=end-1, key;
if (i>=j) return;
for(key=arr[i]; i<j;){
for(; i<j && arr[j]>=key; --j);
arr[i] = arr[j];
for(; i<j && arr[i]<=key; ++i);
arr[j] = arr[i];
}
arr[i] = key;
quick_sort(arr,begin,i);
quick_sort(arr,i+1,end);
}
对于长度为N的数组arr[]而言，快速排序只需调用quick_sort(arr,0,N)。
3）链表的快速排序
链表的排序方法也有很多，此处使用快速排序对单链表进行排序。其中链表节点定义如下：
// A simple quick sort version, which combine partition and sort
// A simple ListNode define
typedef struct __ListNode
{
int val;
struct __ListNode *next;
}ListNode;
由于数组进行划分时，其元素进行移动很费时，然而对于链表而言，其元素划分后，并不需要移动，只需要指针交换即可。所以，定义两个指针mid和p，p进行快速向后遍历，当遇到小于KEY的节点时，将其加入到mid尾部并且mid后移一位。执行一趟partition后，p到达尾部NULL，mid为KEY的位置，然后继续划分begin~mid以及mid~end。具体过程见下面：
/* quick sort - list version (ascending order) * 5 -> 3 -> 2 -> 7 -> 8 -> 1 -> 9 ->NULL * |__begin: as KEY |__end * |__mid : as sorted list mid * * p1 p2 * 5 -> 3 -> 2 -> 7 -> 8 -> 1 -> 9 ->NULL * |__begin * |__mid (1) * |__mid (2) * p3 p4 * 5 -> 3 -> 2 -> 7 -> 8 -> 1 -> 9 ->NULL * |__begin | * |__mid (2) * p5 * 5 -> 3 -> 2 -> 7 -> 8 -> 1 -> 9 ->NULL * |__begin | * |__mid (2): move mid, and swap(mid,p) * || * p5 * 5 -> 3 -> 2 -> 1 -> 8 -> 7 -> 9 ->NULL * |__begin | * |__mid (3) * * at last, swap begin and mid: * 1 -> 3 -> 2 -> 5 -> 8 -> 7 -> 9 ->NULL * |__begin | * |__mid * * */
其代码如下：
// quick sort by ascending order for list
void qsort(ListNode *begin, ListNode *end)
{
if (begin==end || begin==NULL) return;
ListNode *p, *mid;
for(mid=begin, p=mid->next; p!=end; p=p->next){
if (p->val > begin->val) continue;
mid = mid->next;
if (mid!=p) swap(p->val,mid->val);
}
swap(begin->val,mid->val);
qsort(begin,mid);
qsort(mid->next,end);
}
对于一个无头节点的单链表ListNode *head而言，进行快速排序只需调用qsort(head,NULL);即可。此处已将parition合并到快速排序中，并没有单独给出Partition，如需要请自行写出。
4) 第K小的数字（Kth-smallest number）
划分可以不用完全排序，就可以求一个数组中第k小（或第k大）的数字。
例如给定一个数组{5,2,3,1,4}，求其第2小的数字。如果排序，则很容易找到其答案为2，但使用的时间为O(nlogn)。在划分时，如果当前返回的key的位置pos正是k，则可以直接找到答案，而不必完全排序。
// Kth-smallest number, partition by ascending order
int kth_smallest(int k, int arr[], int n) {
int i=0, j=n, pos=-1;
for(--k; pos!=k;){
pos = partition(arr,i,j);
i = (pos<k ? pos+1 : i);
j = (pos>k ? pos : j);
}
return arr[k];
}
类似的题目可参见第k大元素。
注：本文涉及的源码：https://git.oschina.net/eudiwffe/codingstudy/blob/master/src/sort/quicksort.c