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

项目github地址：bitcarmanlee easy-algorithm-interview-and-practice
欢迎大家star，留言，一起学习进步

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