【Lintcode】464. Sort Integers II

题目地址：

https://www.lintcode.com/problem/sort-integers-ii/description

$O(n\log n)$时间复杂度内对一个数组排序。

对于快速排序、归并排序（递归版和非递归版）和堆排序的最详细解释，可以参考https://blog.csdn.net/qq_46105170/article/details/104085776。

法1：快速排序。代码如下：

public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        // write your code here
        quickSort(A, 0, A.length - 1);
    }
    
    private void quickSort(int[] A, int l, int r) {
        if (l >= r) {
            return;
        }
        
        int start = l, end = r, mid = l + (r - l >> 1);
        swap(A, l, mid);
        int piv = A[l];
        
        while (l < r) {
            while (l < r && A[r] >= piv) {
                r--;
            }
            A[l] = A[r];
            
            while (l < r && A[l] <= piv) {
                l++;
            }
            A[r] = A[l];
        }
        
        A[l] = piv;
        
        quickSort(A, start, l - 1);
        quickSort(A, l + 1, end);
    }
    
    private void swap(int[] A, int i, int j) {
        int tmp = A[i];
        A[i] = A[j];
        A[j] = tmp;
    }
}

平均时间复杂度$O(n\log n)$，平均空间复杂度$O(\log n)$。

法2：归并排序。代码如下：

public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        // write your code here
        mergeSort(A, 0, A.length - 1, new int[A.length]);
    }
    
    private void mergeSort(int[] A, int l, int r, int[] tmp) {
        if (l >= r) {
            return;
        }
        
        int m = l + (r - l >> 1);
        mergeSort(A, l, m, tmp);
        mergeSort(A, m + 1, r, tmp);
        
        int i = l, j = m + 1, idx = 0;
        while (i <= m && j <= r) {
            if (A[i] <= A[j]) {
                tmp[idx++] = A[i++];
            } else {
                tmp[idx++] = A[j++];
            }
        }
        
        while (i <= m) {
            tmp[idx++] = A[i++];
        }
        while (j <= r) {
            tmp[idx++] = A[j++];
        }
    
        idx = 0;
        for (int k = l; k <= r; k++) {
            A[k] = tmp[idx++];
        }
    }
}

时间复杂度$O(n\log n)$，空间$O(n)$。