不递归的快速排序

不递归的快速排序

通过分析快速排序我们可以发现，快速排序能实现排序的效果是因为当数组拆分到足够小的时候，通过拆分这个操作，我们可以把只有一两个元素的这样的小数组通过交换保证有序，然后小数组归并成大数组即实现排序。
那么，快速排序是通过递归，将数组不断的拆分成两部分，然后再递归拆分。这个过程使用栈也可以实现，就可以不使用递归。
实例：

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();   //输入数组大小
        int[] temp = new int[n];   
        for (int i = 0; i < n; i++) {   //输入数组的值
            temp[i] = input.nextInt();
        }
        if (!isSorted(temp)) {
            sort(temp, 0, temp.length - 1);
        }
    }

    private static void sort(int[] a, int start, int end) {
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int hign = end;
        int par = partition(a, low, hign);
        //入栈
            stack.push(low);
            stack.push(par - 1);
            stack.push(par + 1);
            stack.push(hign);
        //出栈
        while (stack.size() > 0) {
            hign = stack.pop();
            low = stack.pop();
            if(hign<=low)
                continue;
            par = partition(a, low, hign);
                stack.push(low);
                stack.push(par - 1);
                stack.push(par + 1);
                stack.push(hign);
        }
    }


    private static int partition(int[] a, int start, int end) {
        int i = start;
        int j = end + 1;
        int temp = a[start];
        while (true) {
            while (a[++i] < temp)
                if (i == end)
                    break;
            while (a[--j] > temp) {
                if (j == start)
                    break;
            }
            if (i >= j)
                break;
            exch(a, i, j);
        }
        exch(a, start, j);
        return j;
    }

    private static boolean isSorted(int[] a) {
        for (int i = 1; i < a.length; i++) {
            if (a[i] < a[i - 1])
                return false;
        }
        return true;
    }

    private static void exch(int[] a, int i, int j) {
        //交换元素位置
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}