顾名思义,快速排序(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

内容来源于网络如有侵权请私信删除
你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!

相关课程