快速排序递归与非递归--Java实现

算法思想：

​ 在数组中选出一个元素做枢轴，把所有比它小的元素移到它的左边比它大的元素移到它的右边,对两边的数组递归地进行上述操作，直到数组有序。

排序过程：

递归版：

import java.util.Arrays;

public class QuickSort {
	
	public static void main(String[] args) {
		int a[] = new int[] {5,7,2,9,4,1,0,5,7};
		quickSort(a,a.length);
		System.out.println(Arrays.toString(a));
	}
    
	//用户接口
	private static void quickSort(int[] a, int length) {
		qSort(a,0,length-1);
	}
	
	//快排递归体
	private static void qSort(int[] a, int left, int right) {
		if(left<right) {
			int mid = divide(a,left,right);
			qSort(a,left,mid);
			qSort(a,mid+1,right);
		}
	}

	//划分方法
	private static int divide(int[] a, int left, int right) {
		int mid = left;
		
		while(left<right) {
			while(left<right&&a[right]>=a[mid])
				right--;
			while(left<right&&a[left]<=a[mid])
				left++;
			if(left<right) {
				swap(a,left,right);
			}
		}
		swap(a,mid,left);
		return left;
	}
	
	//交换方法
	private static void swap(int[] a, int left, int right) {
		int t = a[left];
		a[left] = a[right];
		a[right] = t;
	}

}

其中divide函数用两个哨兵实现的方法让枢轴左边的元素比它小，右边的元素比它大：

1.定义一个left和right指针代表两个哨兵初始时分别指向数组的最左和最右。

2.当右边的元素大于等于枢轴时，right向左移，否则停下

3.当左边的元素小于等于枢轴时，left向右移，否则停下

4.当left<right时，交换这两个指针指向的元素

5.若left<right依然成立，重复上述4个步骤

6.最后，把枢轴元素和left指向的元素交换，即可完成一轮划分，即该区间内，枢轴左边的元素比它小，右边的元素比它大。

非递归版：

采用非递归的方法，首先要想到栈的使用，通过阅读递归调用部分的代码，思考如何用栈来代替。递归调用的核心代码是 pivot = partition(a, low, high); 每次循环都必须包含这句核心代码，可以想到，如果要对该行代码实现循环，只能对low和high采取操作，所以我们在栈中压入low和high，每个循环弹出一对low和high，用于核心代码的实现，当栈空后就说明没有需要排序的部分了，结束循环。
　　下面是递归代码和根据递归代码修改成的非递归代码(只修改了qSort方法);

	//非递归实现
	private static void qSort(int[] a, int left, int right) {
		Stack<Integer> s = new Stack<>();
		s.push(left);
		s.push(right);
		
		while(!s.isEmpty()) {
			int r = s.pop();
			int l = s.pop();
			int mid = divide(a, l, r);
			if(l<mid) {
				s.push(l);
				s.push(mid);
			}
			if(mid+1<r) {
				s.push(mid+1);
				s.push(r);
			}
			
		}
	}