快排 递归与非递归实现 优化

快排，面试题中出现概率最高的一道，甚至没有之一。python实现，直接上代码

1.python代码

def getMiddle(list,low,high):
tmp = list[low]
while(low < high):
while(low < high and list[high] > tmp):
high -= 1
list[low] = list[high]

while(low < high and list[low] < tmp):
low += 1
list[high] = list[low]

list[low] = tmp

return low

def quickSort1(list,low,high):
if low < high:
middle = getMiddle(list, low, high)
quickSort1(list, low, middle-1)
quickSort1(list, middle+1, high)

if __name__ == '__main__':
list = [7,4,3,1,9,8,6,5]
getMiddle(list, 0, len(list)-1)
print list
quickSort1(list, 0, len(list)-1)
print list

2.快排的相关优化思路如下：

1. 合理选择pivot

你就直接选择分区的第一个或最后一个元素做pivot肯定是不合适的。对于已经排好序，或者接近排好序的情况，会进入最差情况，时间复杂度衰退到O(N^{2} )。

pivot选取的理想情况是：让分区中比pivot小的元素数量和比pivot大的元素数量差不多。较常用的做法是三数取中（midian of three），即从第一项、最后一项、中间一项中取中位数作为pivot。当然这并不能完全避免最差情况的发生。所以很多时候会采取更小心、更严谨的pivot选择方案（对于大数组特别重要）。比如先把大数组平均切分成左中右三个部分，每个部分用三数取中得到一个中位数，再从得到的三个中位数中找出中位数。

我在javascript v8引擎中看到了另外一种选择pivot的方式：认为超过1000项的数组是大数组，每隔200左右（不固定）选出一个元素，从这些元素中找出中位数，再加入首尾两个元素，从这个三个元素中找出中位数作为pivot。

By the way，现实环境中，你要对一个预先有一定顺序的数组做排序的需求太太太普遍了，这个优化必须要有。

2. 处理重复元素的问题

假如一个数组里的元素全部一样大（或者存在大量相同元素），会怎么样？这是一个边界case，但是会令快速排序进入最差情况，因为不管怎么选pivot，都会使分区结果一边很大一边很小。那怎么解决这个问题呢？还是修改分区过程，思路跟上面说的双向分区类似，但是会更复杂，我们需要小于pivot、等于pivot、大于pivot三个分区。既然说了不贴代码，那就点到为止吧，有兴趣可以自己找别人实现看看。

3.优化小数组效率

这一点很多人都提到了。为什么要优化小数组？因为对于规模很小的情况，快速排序的优势并不明显（可能没有优势），而递归型的算法还会带来额外的开销。于是对于这类情况可以选择非递归型的算法来替代。好，那就有两个问题：多小的数组算小数组？替换的算法是什么？

通常这个阈值设定为16（v8中设定的是10），替换的算法一般是选择排序。据说阈值的设定是要考虑更好地利用cpu缓存，这个问题我就不是很清楚了，不深入。同样，对于分区得到的小数组是要立刻进行选择排序，还是等分区全部结束了之后，再统一进行选择排序，这个问题也会存在一定的缓存命中的区别，我也不懂，不深入。

3.非递归实现

非递归实现快排本质就是用栈实现递归的操作。具体步骤如下：

1. 申请一个栈，存放排序数组的起始位置和终点位置。

2.将整个数组的起始位置start和终点位置end进栈

3.出栈数据，对出栈的数据进行排序，查找基准数据所在最终的位置 pivot。

4.判断起始位置start是否小于基准位置pivot-1，如果小于则将起始位置和pivot-1为终点位置进栈

5.判断基准位置pivot+1 是否小于终点位置end,如果小于则将 pivot+1作为起始位置，end作为终点位置进栈

6.判断栈是否为空，如果不为空则重复第三步，否则退出操作。

按惯例，talk is cheap，show me the code

package leilei.bit.edu.stacktest;

import java.util.Stack;

public class Quick {

public static int partition(int[] a, int start, int end) {
int pivot = a[start];
while (start < end) {
while (start < end && a[end] >= pivot) {
end--;
}
a[start] = a[end];
while (start < end && a[start] <= pivot) {
start++;
}
a[end] = a[start];
}
a[start] = pivot;

return start;
}

public static void recursiveQucikSort(int[] a, int start, int end) {
if (start < end) {
int position = partition(a, start, end);
recursiveQucikSort(a, start, position-1);
recursiveQucikSort(a, position+1, end);
}
}

public static void nonRecursiveQuickSort(int[] a) {
//存放开始与结束索引
Stack<Integer> s = new Stack<Integer>();
//压栈
s.push(0);
s.push(a.length - 1);
//利用循环里实现
while(!s.empty()) {
int right = s.pop();
int left = s.pop();
if(right < left) {
continue;
}

int i = partition(a,left,right);
if(left < i-1) {
s.push(left);
s.push(i-1);
}
if(i+1 < right) {
s.push(i+1);
s.push(right);
}
}
}

public static void printArray(int[] a) {
for(int i=0; i<a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}

public static void main(String[] args) {
int[] a = {1,3,5,7,9,2,4,6,8};
nonRecursiveQuickSort(a);
printArray(a);
}
}

代码运行结果

1 2 3 4 5 6 7 8 9