快速排序的非递归实现

前一篇文章我们看了怎样用递归实现快速排序，那么如果不用递归方法，又该怎么实现快速排序呢？
思路是这样的：

    第一次找完基准后，若基准左右两边都还未有序，则按照从左往右的次序把新的索引全部压入一个栈中。当栈中存在数据
时，每次出栈两个元素作为新的结束索引和开始索引重新找一次基准，这样就类似于递归地实现了多次找基准的目的。

同样的，找基准的代码是一样的：

public static int partion(int[] arr, int start, int end) {

    int tmp = arr[start];

    while (start < end) {

        while (arr[end] >= tmp && start < end) {
            --end;
        }

        if (start >= end) {
            break;
        }else {
            arr[start] = arr[end];
        }

        while (start < end && arr[start] <= tmp) {
            ++start;
        }

        if (start >= end) {
            break;
        }else {
            arr[end] = arr[start];
        }
    }

    arr[start] = tmp;
    return start;
}

以下是利用堆栈重复找基准的代码：

public static void quickSort(int[] arr) {

    int[] stack = new int[arr.length];
    int top = 0;
    int low = 0;
    int high = arr.length - 1;
    int par = partion(arr, low, high);
    // 若基准左边至少存在两个数据，新的索引入栈
    if(par > low + 1) {
        stack[top++] = low;
        stack[top++] = par - 1;
    }
    // 若基准右边至少存在两个数据，新的索引入栈 
    if (par < high - 1) {
        stack[top++] = par + 1;
        stack[top++] = high;
    }
    /** 每次出栈两个元素，栈里还有元素，找完一次基准再次入栈，这样就实现了重复找基准  */  
    while (top > 0) {
        // 两个新索引依次出栈
        high = stack[--top];
        low = stack[--top];
        par = partion(arr, low, high);
        // 再次入栈
        if (par > low + 1) {
            stack[top++] = low;
            stack[top++] = par - 1;
        }

        if (par < high - 1) {
            stack[top++] = par + 1;
            stack[top++] = high;
        }
    }
}

来验证一下以上程序是否可以运行：

import java.util.Arrays;

public class QuickSort2 {
    public static void main(String[] args) {
        int[] arr = {20, 23, 12 , 14, 45, 2, 89, 100, 65, 77, 96};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

输出结果是：[2, 12, 14, 20, 23, 45, 65, 77, 89, 96, 100]