Sort Array

各种 Sort 算法，包括 Quick Sort, Merge Sort, Heap Sort, Count Sort

package Sort;

public class Sort {
    /* 
     * Quick Sort 
     * Time : O(n log n)
     * Space : O(log n) -- stack frame
     */
    private void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) 
            return;
        helperQuick(arr, 0, arr.length-1);
        return;
    }
    private void helperQuick(int[] arr, int left, int right) {
        if (left >= right) 
            return;
        int i = left, j = right;
        int tmp = arr[i];
        while (i < j) {
            while (i<j && arr[j] >= tmp) {
                j--;
            }
            arr[i] = arr[j];
            while (i<j && arr[i] < tmp) {
                i++;
            }
            arr[j] = arr[i];
        }
        arr[i] = tmp;
        helperQuick(arr, left, i-1);
        helperQuick(arr, i+1, right);
    }
    /*--------------------------------------*/
    
    /*
     * Merge Sort
     * Time : O(n log n)
     * Space : O(n)
     */
    private void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2)
            return;
        helperMerge(arr, 0, arr.length-1);
    }
    private void helperMerge(int[] arr, int s, int t) {
        if (s >= t) return;
        int mid = s + (t - s) / 2;
        helperMerge(arr, s, mid);
        helperMerge(arr, mid+1, t);
        merge(arr, s, mid, mid+1, t);
    }
    private void merge(int[] arr, int s1, int t1, int s2, int t2) {
        int[] tmp = new int[t1 - s1 + t2 - s2 + 2];
        int i = s1, j = s2, run = 0;
        while (i <= t1 && j <= t2) {
            if (arr[i] < arr[j]) {
                tmp[run++] = arr[i++];
            } else {
                tmp[run++] = arr[j++];
            }
        }
        while (i <= t1) {
            tmp[run++] = arr[i++];
        }
        while (j <= t2) {
            tmp[run++] = arr[j++];
        }
        System.arraycopy(tmp, 0, arr, s1, tmp.length);
    }
    /*--------------------------------------*/
    
    /*
     * Heap sort
     * Time : O(n log n)
     * Space : O(1)
     */
    private void heapSort(int[] arr) {
        for (int i = arr.length / 2; i >= 0; i--) {
            siftDown(arr, i, arr.length);
        }
        for (int i = arr.length-1; i > 0; i--) {
            swap(arr, 0, i);
            siftDown(arr, 0, i);
        }
    }
    private void siftDown(int[] arr, int parent, int length) {
        int child = parent * 2 + 1;
        while (child < length) {
            if (child + 1 < length && arr[child] < arr[child + 1])
                child++;
            if (arr[parent] < arr[child]) {
                swap(arr, parent, child);
                parent = child;
                child = parent * 2;
            } else break;
        }
    }
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    /*--------------------------------------*/
    
    /*
     * Count Sort
     * - Given a certain Range
     * - all keys in the array are between that range
     * Time : O(n + k)
     * Space : O(n + k)
     */
    public void countSort(int[] arr) {
        int[] range = new int[15];
        
        for (int i : arr) {
            range[i]++;
        }
        int j = 0;
        for (int i = 0; i < arr.length; i++) {
            while (range[j] == 0) {
                j++;
            }
            arr[i] = j;
            range[j]--;
        }
    }
    /*--------------------------------------*/
    
    public static void main(String[] args) {
        Sort sort = new Sort();
        
        System.out.println("Quick Sort");
        int[] arr0 = {6, 9, 10, 7, 8, 5, 3, 4, 11, 2};
        sort.quickSort(arr0);
        for (int i : arr0)
            System.out.print(i+" ");
        System.out.println();
        System.out.println();
        
        System.out.println("Merge Sort");
        int[] arr1 = {6, 9, 10, 7, 8, 5, 3, 4, 11, 2};
        sort.mergeSort(arr1);
        for (int i : arr1)
            System.out.print(i+" ");
        System.out.println();
        System.out.println();
        
        System.out.println("Heap Sort");
        int[] arr2 = {6, 9, 10, 7, 8, 5, 3, 4, 11, 2};
        sort.heapSort(arr2);
        for (int i : arr2)
            System.out.print(i+" ");
        System.out.println();
        System.out.println();
        
        System.out.println("Count Sort <range: 0 - 14>");
        int[] arr3 = {6, 9, 10, 7, 8, 5, 3, 4, 11, 2};
        sort.heapSort(arr3);
        for (int i : arr3)
            System.out.print(i+" ");
        System.out.println();
    }
}