标签：
partition函数是快排的核心部分
它的目的就是将数组划分为<=pivot和>pivot两部分，或者是<pivot和>=pivot
其实现方法大体有两种，单向扫描版本和双向扫描版本，但是具体到某个版本，其实现方法也是千差万别，参差不齐。本着严谨治学的态度，我将目前所接触的所有实现列举出来，并作出比较。除了伪代码，我也会给出相应的C&C++实现，供读者参考。
下面是算法导论中例子
PARTITION(A, p, r) x = A[r] i = p - 1 for j = p to r - 1 if A[j] <= x i = i + 1 exchange A[i] with A[j] exchange A[i + 1] with A[r] return i + 1 int partition(int a[], int p, int r) { int x = a[r]; int i = p - 1; int j = p; for (; j < r; ++j) if (a[j] <= x) swap(&a[++i], &a[j]); swap(&a[i + 1], &a[j]); return i + 1; }
这个是标准的单向扫描，其思路是：
将小于或等于pivot的元素通过交换全部移到前面去，这里需要注意的是i的作用，这是个哨兵，用于记录交换后的位置，也就是i之前的元素都是交换好了的。
下面是一些可以变动的地方：
1.可以将小于pivot的元素移到前面去，而不是小于等于，这样可以减少些交换次数，同理，可以将大于pivot的元素移到后面去，不过这样就需要倒序遍历了
2.或者是将i的初始值设置为p，而不是p-1；
3.可以将pivot设置成第一个元素；
4.存在i=j的情况，这时候的交换就是多余的，可以优化掉。
下面是稍作优化的版本
int partition(int a[], int p, int r) { int x = a[r]; int i = p; int j = p; for (; j < r; ++j) if (a[j] < x) { if (i != j) swap(&a[i], &a[j]); i++; } swap(&a[i], &a[j]); return i; }
算法导论上的课后题有该算法，但是错误百出，这里以《算法》第四版的方法为例
PARTITION(A, p, r) x = A[p] i = p j = r + 1 while true repeat j = j - 1 until A[j] <= x repeat i = i + 1 until A[i] >= x if i >= j break exchange A[i] with A[j] exchange A[p] with A[j] return j int partition(int a[], int p, int r) { int x = a[p]; int i = p; int j = r + 1; while (true) { while (a[--j] > x); while (a[++i] < x); if (i >= j) break; swap(&a[i], &a[j]); } swap(&a[j], &a[p]); return j; }
其思路是从左到右找到大于等于pivot的元素，从右到左找到小于等于pivot的元素，然后将这两个元素交换，直到左右扫描相遇，最后还要进行一次交换，将pivot调整到正确位置
这是上面程序的变种，看起来差别很大，不过原理是相同的
int partition(int a[], int p, int r) { int x = a[p]; int i = p + 1; int j = r; while (i <= j) { while (a[j] > x) j--; while (a[i] < x) i++; if (i >= j) break; swap(&a[i++], &a[j--]); } swap(&a[j], &a[p]); return j; }
我们看一下它的扫描条件，一个是大于等于，一个是小于等于，也就是说左右扫描点存在都等于pivot的情况，这时候我们是不用交换的。根据互补原理，一个扫描点条件是大于等于，那么另一扫描点条件应该是互补条件小于，这样两个扫描点交换就不会出现交换相等元素的情况。
另外程序还存在着巨大的溢出漏洞，内层的while循环如：
while (a[i] < x) i++;
我们无法保证其不会越界，事实上，我经过测试，发现i的值一旦越界就不确定了，虽然都能保证i >= j的临界条件，但我们还是应该尽量避免越界问题
可以在循环中加入越界条件
int partition(int a[], int p, int r) { int x = a[p]; int i = p; int j = r + 1; while (true) { while (i < j && a[--j] >= x); if (i >= j) break; while (i < j && a[++i] < x); if (i >= j) break; swap(&a[i], &a[j]); } swap(&a[j], &a[p]); return j; }
变种的防越界版如下
int partition(int a[], int p, int r) { int x = a[p]; int i = p + 1; int j = r; while (true) { while (i <= j && a[j] >= x) j--; if (i > j) break; while (i <= j && a[i] < x) i++; if (i > j) break; swap(&a[i++], &a[j--]); } swap(&a[j], &a[p]); return j; }
左右扫描的版本还有很多，让我们再来举几个例子
网上流传比较广的一个版本是下面这个
int partition(int a[], int p, int r) { int x = a[p]; int i = p; int j = r; while (i < j) { while (i < j && a[j] >= x) j--; if (i >= j) break; a[i++] = a[j]; while (i < j && a[i] < x) i++; if (i >= j) break; a[j--] = a[i]; } a[i] = x; return i; }
仔细观察会发现，它与我们上面介绍的版本几乎如出一辙，不同的是，它没有使用swap交换元素，而是依次覆盖，最后再把pivot归位
具体过程可以参阅：http://blog.csdn.net/morewindows/article/details/6684558
算法的时间复杂度是O(n)，但是为什么要写成双循环呢？我们完全可以把它改成单循环，代码如下：
int partition(int a[], int p, int r) { int x = a[p]; int i = p + 1; int j = r; while (i <= j) { if (a[j] > x) { j--; continue; } if (a[i] < x) { i++; continue; } swap(&a[i++], &a[j--]); } swap(&a[j], &a[p]); return j; }
但是，并不推荐这种做法，因为每次判断i的时候，势必会再次判断j，多一次比较。
总结：个人推荐单向扫描的优化版本，双向扫描可以看到会有越界的问题，为了防止越界付出了一定代价。
标签：
原文地址：http://www.cnblogs.com/sdlwlxf/p/5131793.html
