关于快速排序的实现方式

- 递归方法

• 占坑式

    //采用递归的快速排序
    public void quickSortRecursion(int[] arr, int len, int start, int end) {
        if (start > end) {
            return;
        }
        int index = partition(arr, len, start, end);
        if (index > start) {
            quickSortRecursion(arr, len, start, index -1);
        }
        if (index < end) {
            quickSortRecursion(arr, len, index + 1, end);
        }
    }
    /**
     * 以基础比较位为中心，小的排在左边，大的排在右边
     * @param arr
     * @param start
     * @param end
     * @param len
     * @return 返回已排序元素的下标
     */
    private int partition(int[] arr, int len, int start, int end) {
        //异常情况返回-1
        if (arr == null || len <= 1 || start < 0 || end > len) {
            return -1;
        }
        //以第一个元素作为被排序的元素,这里可以随便指定基线元素位置
        int index = start;
        int temp = arr[index];
        //基线元素首先和第一个元素交换
        arr[index] = arr[index] ^ arr[start];
        arr[start] = arr[index] ^ arr[start];
        arr[index] = arr[index] ^ arr[start];

        while (start < end) {
            //1.找到右边小于基线元素的下标，然后填坑,填坑注意只有满足start<end才可以
            while ((arr[end] > temp) && (end > start)) {
                --end;
            }
            if (start < end) {
                arr[start++] = arr[end];
            }
            //2.找到左边大于基线元素的下标，然后和end做交换
            while ((arr[start] < temp) && (start < end)) {
                start++;
            }
            if (start < end) {
                arr[end--] = arr[start];
            }
        }
        //需要把坑填上，因为坑里面是原有元素的一个副本
        arr[start] = temp;
        return start;
    }

• 交换式

private int partitionExchange(int[] arr, int len, int start, int end) {
        //异常情况返回-1
        if (arr == null || len <= 1 || start < 0 || end > len) {
            return -1;
        }
        //以第一个元素作为被排序的元素,这里可以随便指定基线元素位置
        int index = RandomInRange(start, end);
        //交换式的关键在于，一开始就固定基线元素的位置
        swap(arr, index, end);
        //从左到右开始扫描，用来标记第一个小于基线元素的值
        int small = start -1;
        for (index = start; index < end; index++) {
            if (arr[index] < arr[end]) {
                ++small;
                if (small < index) {
                    swap(arr, small, index);
                }
            }
        }
        ++small;
        swap(arr, small, end);
        return small;
    }

- 非递归方法

public void quickSortNonRecursion(int[] arr, int len, int start, int end) {
        LinkedList<Integer> stack = new LinkedList<Integer>();  //用栈模拟
        if(start < end) {
            stack.push(end);
            stack.push(start);
            while(!stack.isEmpty()) {
                int l = stack.pop();
                int r = stack.pop();
                int index = partition(arr,len, l, r);
                if(l < index - 1) {
                    stack.push(index-1);
                    stack.push(l);
                }
                if(r > index + 1) {
                    stack.push(r);
                    stack.push(index+1);
                }
            }
        }
    }

总结：
一：快速排序的占坑式比较容易理解，但是结合随意指定基线元素就需要思考一下，如何处理。比较好的处理办法是把随意指定的基线元素和数组中的头元素或者尾元素交换，这样处理就简单一些。
二：交换式，着重在每次交换两个元素，而不是每次填坑。把基线元素的位置固定后末尾，从左到右扫描，大于基线元素的元素不管，找到第一个小于基线元素的元素，此时交换第一个大于基线元素的元素和第一个小于基线元素的元素。经典，代码简洁。