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

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