快排算法的实现

先来说网上流行最多的实现，用两个指针，一个从前往后，一个从后往前。直接上代码，如下。

package com.jeaven;

public class Solution2 {
    public void quick_sort(int[] arr, int begin, int end) {
        if(begin < end) {
            int mid = partition(arr, begin, end);
            quick_sort(arr, begin, mid-1);
            quick_sort(arr, mid+1, end);
        }
    }
    
    
    /* 双向指针的快排思路
     * 前一个指针指向开始元素begin，第二个指针指向数组倒数第二个end-1，最后一个元素为轴pivot
     *当arr[i] > pivot时，交换arr[i]和arr[j]然后 j=j-1
     *当arr[i] < pivot时，就i++
     *最终当i和j重合的时候相遇，再将轴归位返回轴的位置，注意下标即可
    */
    public int partition(int[] arr, int begin, int end) {
        int pivot = arr[end];
        int i = begin;
        int j = end - 1;
        while(i < j) {
            if(arr[i] > pivot) {
                int temp = arr[j]; 
                arr[j] = arr[i];
                arr[i] = temp;
                j--;
            } else {
                i++;
            }
        }
        int temp = arr[j+1];
        arr[j+1] = arr[end];
        arr[end] = temp;
        return j+1;
    }
    
    public static void main(String[] args) {
        int[] arr = {1,4,2,3,5};
        new Solution2().quick_sort(arr, 0, arr.length-1);
        for(int c : arr) {
            System.out.print(c + " ");
        }
    }
}

再来说说我最喜欢的风格，也是算法导论上的快排实现方法，两个指针从同一边开始，算法导论的思路很清晰，还给出了完整的理论推导，不变性的证明，有兴趣的可以去看看算法道路的快排章节。

下面是算法导论关于快排的实现思路，如下：

 然后我给出java版本的快排实现：

package com.jeaven;

public class Solution3 {
    public void quick_sort(int[] arr, int begin, int end) {
        if(begin < end) {
            int mid = partition(arr, begin, end);
            quick_sort(arr, begin, mid-1);
            quick_sort(arr, mid+1, end);
        }
    }
    
    public int partition(int[] arr, int begin, int end) {
        int pivot = arr[end];
        int i = begin - 1;
        for(int j = begin; j < end; j++) {
            if(arr[j] < pivot) {
                i++;
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
        int temp = arr[i+1];
        arr[i+1] = arr[end];
        arr[end] = temp;
        return i+1;
    }
    
    public static void main(String[] args) {
        int[] arr = {1,4,2,3,5};
        new Solution3().quick_sort(arr, 0, arr.length-1);
        for(int c : arr) {
            System.out.print(c + " ");
        }
    }
}

说明：我喜欢选最后一个元素为轴pivot，当然可以选取数组任意位置为轴，即使分的恨不均匀，但是可以证明除了极端情况，时间复杂度仍然为O(nlgn)。如果选取其他位置作为轴，代码实现的时候可以先将轴和最后一个元素交换位置，这样就可以看成是最后一个位置是轴，就可以很容易实现。