归并排序、快速排序、堆排序

归并排序

稳定性：稳定
时间复杂度：最佳：O(nlogn)， 最差：O(nlogn)， 平均：O(nlogn)
空间复杂度：O(n)

public class MergeSort {
    int[] tmp;
    public int[] sortArray(int[] nums) {
        tmp = new int[nums.length];
        mergeSort(nums, 0, nums.length - 1);
        return nums;
    }
    public void mergeSort(int[] nums, int l, int r) {
        if (l >= r) return;
        int mid = (r-l) >> 1+l;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        int i = l, j = mid + 1;
        int cnt = l;
        while (i <= mid && j <= r) {
            tmp[cnt++] = nums[i] <= nums[j]?nums[i++] : nums[j++];
        }
        while (i <= mid)  tmp[cnt++] = nums[i++];
        while (j <= r)  tmp[cnt++] = nums[j++];
        for (int k = l; k < r+1; ++k) {
            nums[k] = tmp[k];
        }
    }
}

快速排序

稳定性：不稳定
时间复杂度：最佳：O(nlogn)， 最差：O(n^2)退化为冒泡排序，平均：O(nlogn)
空间复杂度：最好O(logn)，最差：O(n)

1. 快排并没有开辟空间，但是使用了递归，递归会开辟栈帧
2. 递归算法的空间复杂度 = 每次递归的空间复杂度 * 递归深度

public static int partition(int[] array, int left, int right) {
    int pivot = array[left];
    int l = low;
    for (int i = left+1; i < =right; i++) {
        if (array[i] < pivot) {
            l ++;
            int temp = array[i];
            array[i] = array[l];
            array[l] = temp;
        }
    }
    int temp = array[l];
    array[l] = array[left];
    array[left] = temp;
    return l;
}
public static void quickSort(int[] array, int low, int high) {
    if (low >= high) return;
    int position = partition(array, low, high);
    quickSort(array, low, position - 1);
    quickSort(array, position + 1, high);
    
}

堆排序

时间复杂度O(nlogn)，无论在最好还是最坏情况下都是O(nlogn)
建堆的时间复杂度为O(n)
空间复杂度为O(1)**

public class HeapSort {
    public int[] sortArray(int[] nums) {
        heapSort(nums);
        return nums;
    }

    public void heapSort(int[] nums) {
        int len = nums.length - 1;
        buildMaxHeap(nums, len);
        for (int i = len; i >= 1; --i) {
            swap(nums, i, 0);
            len -= 1;
            maxHeapify(nums, 0, len);
        }
    }
    public void buildMaxHeap(int[] nums, int len) {
        for (int i = len / 2; i >= 0; --i) {
            maxHeapify(nums, i, len);
        }
    }
    public void maxHeapify(int[] nums, int i, int len) {
        for (; (i << 1) + 1 <= len;) {
            int lson = (i << 1) + 1;
            int rson = (i << 1) + 2;
            int large =i;
            if (lson <= len && nums[lson] > nums[i]) {
                large = lson;
            } 
            if (rson <= len && nums[rson] > nums[large]) {
                large = rson;
            }
            if (large != i) {
                swap(nums, i, large);
                i = large;
            } else {
                break;
            }
        }
    }