快速排序

• 取一个标杆元素pivot
• 将小于pivot的元素放左边，大于pivot的元素放右边
• 对第二步产生的左右两个区间进行相同操作，直到排序完成

递归实现

递归实现易于理解，其主要思想就是通过递归来不断对左右两个子区间进行快速排序直到排序完成。

    public int[] quickSort(int[]arr){
        quickSort(arr,0, arr.length-1);
        return arr;
    }
    private int[] quickSort(int[]arr, int left, int right){
        if(left<right){
            int q = media(arr, left, right);
            quickSort(arr, left, q - 1);
            quickSort(arr, q + 1, right);
        }
        return arr;
    }
    private int media(int[]arr, int left, int right){
        int tmp = arr[right];
        int i = left;
        for(int j=left;j<right;j++){
            if(arr[j]<tmp){
                int x = arr[j];
                arr[j] = arr[i];
                arr[i] = x;
                i++;
            }
        }
        int x = arr[right];
        arr[right] = arr[i];
        arr[i] = x;
        return i;
    }

非递归实现

用非递归实现的话就需要人为地将左右子区间进行保存。将递归程序改为非递归程序，首先我们就能想到使用栈，因为递归本来就是一个压栈出栈的一个过程。

    public int[] quickSort(int[]arr){
        Stack<Integer> stack = new Stack<>();
        int left = 0, right = arr.length - 1;
        stack.push(left);
        stack.push(right);
        while (!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            int tmp = arr[right];
            int i = left;
            for(int j=left;j<right;j++){
                if(arr[j]<tmp){
                    int x = arr[j];
                    arr[j] = arr[i];
                    arr[i] = x;
                    i++;
                }
            }
            int x = arr[right];
            arr[right] = arr[i];
            arr[i] = x;
            if(i-1>left) {
                stack.push(left);
                stack.push(i - 1);
            }
            if(i+1<right) {
                stack.push(i + 1);
                stack.push(right);
            }
        }
        return arr;
    }