快速排序的非递归实现

这里讲了快速排序的递归实现插入排序 快速排序 分析整理，这里写一下非递归实现，非递归实现的要点是利用栈保存partition操作的子区间，即左边的坐标和右边的坐标。

partition操作跟递归实现一样，不需要任何更改。

代码如下：

import java.util.Stack;

//快速排序的非递归实现，利用栈保存一对下标
public class QuickSortNonRecursion {

    public static void main(String[] args) {

        QuickSortNonRecursion quickSort = new QuickSortNonRecursion();

        int[] array = { 3, 2, 11, 121,2,32,545,3434,222,18, 99, 233, 53, 101, 22, 9, 100 };

        quickSort.sort(array);

        for (int num:array) {
            System.out.print(num + " ");
        }
    }

    public void sort(int[] array) {

        if (array == null || array.length == 1)
            return;

        //栈顶的两个元素存放要partition的最左坐标和最优坐标
        Stack<Integer> s = new Stack<Integer>();

        //初始化最左和最右坐标，即0和len-1
        s.push(0);
        s.push(array.length - 1);

        //循环，结束条件为栈空
        while (!s.empty()) {

            int right = s.pop();    //栈顶两个元素出栈
            int left = s.pop();

            //右边索引小于等于左边索引了，不需要调整，仅需要出栈，结束
            if (right <= left)
                continue;

            int i = partition(array, left, right);

            s.push(left);   //左半部分入栈
            s.push(i-1);

            s.push(i+1);    //右半部分入栈
            s.push(right);
        }
    }

    //将pivot放到最终位置，并且左边的元素都小于等于pivot，右边的元素都大于等于pivot
    public int partition(int[] a,int left,int right){     
        int i = left,j=right;  
        int pivot = a[left];                //将pivot暂存，因为之后这个位置将由比pivot小的数占据  

        while(i<j){  
            for(;i<j && a[j]>=pivot;j--);   //从右边找一个比pivot小的数  
            a[i] = a[j];                    //将这个数放到左边空位，空位是由pivot或之前比pivot大的数留出来的  
            for(;i<j && a[i]<=pivot;i++);   //从左边找一个比pivot大的数  
            a[j] = a[i];                    //将这个数放到右边空位  
        }
        a[i] = pivot;  
        return i;  
    } 
}