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

来源：互联网发布：飞向札幌的班机js 编辑：程序博客网时间：2024/05/16 14:15

快排，面试题中出现概率最高的一道，甚至没有之一。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 lowdef 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);    }}