三大排序算法

merge sort

空间复杂度：O(n)（sort list是O(1））

时间复杂度为O(nlgn)

稳定性：稳定排序

先局部有序，再整体有序

public class Solution {
    /**
     * @param A an integer array
     * @return void
     */
    public void sortIntegers(int[] A) {
        int[] temp = new int[A.length];
        mergeSort(A, 0, A.length - 1, temp);
    }
    
    public void mergeSort(int[] A, int start, int end, int[] temp) {
        if (start >= end) {
            return;
        }
        mergeSort(A, start, (start + end) / 2, temp);
        mergeSort(A, (start + end) / 2 + 1, end, temp);
        
        merge(A, start, end, temp);
    }
    
    public void merge(int[] A, int start, int end, int[] temp) {
        int mid = (start + end) / 2;
        int left = start;
        int right = mid + 1;
        int index = start;
        
        while (left <= mid && right <= end) {
            if (A[left] <= A[right]) {
                temp[index++] = A[left++];
            } else {
                temp[index++] = A[right++];
            }
        }
        while (left <= mid) {
            temp[index++] = A[left++];
        }
        while (right <= end) {
            temp[index++] = A[right++];
        }
        for (int i = start; i <= end; i++) {
            A[i] = temp[i];
        }
    }
}

quick sort

空间复杂度：O(1)的额外空间

时间复杂度：期望时间复杂度为O(nlgn)，最坏情况下时间复杂度为O(n^2)

稳定性：不稳定排序

先整体有序，再局部有序

public class Solution {
    /**
     * @param A an integer array
     * @return void
     */
    public void sortIntegers(int[] A) {
        if (A == null || A.length == 0) {
            return;
        }
        quickSort(A, 0, A.length - 1);
    }
    
    public void quickSort(int[] A, int start, int end) {
        if (start >= end) {
            return;
        }
        int left = start;
        int right = end;
        int pivot = A[(start + end) / 2];
        
        while (left <= right) {
            while (left <= right && A[left] < pivot) {
                left++;
            }
            while (left <= right && A[right] > pivot) {
                right--;
            }
            if (left <= right) {
                int tmp = A[left];
                A[left] = A[right];
                A[right] = tmp;
                left++;
                right--;
            }
        }
        
        quickSort(A, start, right);
        quickSort(A, left, end);
    }
}

heap sort

空间复杂度：O(1)

时间复杂度: O(nlgn)

步骤：把数组A建立成一个大根堆（从左到右shiftup操作）。然后把堆顶元素（即最大值）与堆末尾元素交换，再shiftdown，重复n次。

public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        if (A == null) {
            return;
        }
        buildHeap(A);
        int size = A.length;
        for (int i = A.length - 1; i >= 0; i--) {
            swap(A, 0, i);
            size--;
            shiftDown(A, 0, size);
        }
    }
    
    public void buildHeap(int[] A) {
        for (int i = 0; i < A.length; i++) {
            shiftUp(A, i);
        }
    }
    
    public void shiftUp(int[] A, int cur) {
        if (cur == 0) {
            return;
        }
        int father = cur % 2 == 0 ? cur / 2 - 1 : cur / 2;
        if (A[father] < A[cur]) {
            swap(A, father, cur);
        }
        shiftUp(A, father);
    }
    
    public void shiftDown(int[] A, int cur, int size) {
        if (cur >= size - 1) {
            return;
        }
        int left = cur * 2 + 1;
        int right = cur * 2 + 2;
        
        int max_child = -1;
        if (left <= size - 1 && right <= size - 1) {
            max_child = A[left] < A[right] ? right : left;
        } else if (left <= size - 1) {
            max_child = left;
        } else {
            return;
        }
        if(A[cur] < A[max_child]) {
            swap(A, cur, max_child);
            shiftDown(A, max_child, size);
        }
    }
    
    public void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }
}