三大排序：快排，归并，堆排

三大排序：快排，归并，堆排

快排

平均O(nlogn)，最坏O(n)，不稳定
Note: 先从右边j找第一个小于base的，放到左边i
再从左边i找到第一个大于base的，放到右边j
最后赋值base。 一次遍历交换一次
不要两个遍历后再交换，容易出错

package sort;

public class QuickSort {
    public static void quickSort(int[] nums, int l, int r) {
        if (l >= r) {
            return;
        }
        int i = l, j = r, base = nums[i];

        while (i < j) {
            while (i < j && nums[j] > base) {
                j--;
            }
            if (i < j) {
                nums[i++] = nums[j]; // 注意这里
            }

            while (i < j && nums[i] <= base) {
                i++;
            }

            if (i < j) {
                nums[j--] = nums[i]; // 注意这里
            }

        }
        nums[i] = base;
        quickSort(nums, l, i-1);
        quickSort(nums, i+1, r);
    }
}

归并排序

平均O(nlogn)，最坏O(nlogn)，！！！稳定！！！
Note：需要一个辅助数组tmp， 注意tmp的下标与原数组的下标的对应关系

public class MergeSort {
    public static void sort(int[] nums, int[] tmp, int l, int r) {
        if (l >= r) {
            return;
        }

        int mid = ((r - l) >> 1) + l;
        sort(nums, tmp, l, mid);
        sort(nums, tmp, mid + 1, r);
        merge(nums, tmp, l, r, mid);
    }

    public static void merge(int[] nums, int[] tmp, int l, int r, int mid) {
        int i = l, j = mid + 1, t = 0;
        while (i <= mid && j <= r) {
            if (nums[i] < nums[j]) {
                tmp[t++] = nums[i++];
            } else {
                tmp[t++] = nums[j++];
            }
        }

        while (i <= mid) {
            tmp[t++] = nums[i++];
        }
        while (j <= r) {
            tmp[t++] = nums[j++];
        }

        t = 0;
        while (l <= r) {
            nums[l++] = tmp[t++];
        }
    }
}

堆排序

平均O(nlogn)，最坏O(nlogn)，！！！不稳定！！！
调整堆void adjust(int[] nums, int i, int len)记住这个结构
从第一个非叶子节点len/2-1构建堆，循环到0.
0与末尾交换（末尾大小会变），再调整adjust(int[] nums, 0, newLen)

package sort;

public class HeapSort {

    public static void sort(int[] nums) {
        int n = nums.length;
        for (int i = n/2 - 1; i >= 0 ; i--) {
            adjust(nums, i, n);
        }

        for (int j = n-1; j > 0; j--) {
            swap(nums, 0, j);
            adjust(nums, 0, j);
        }
    }

    public static void adjust(int[] nums, int i, int len){
        int base = nums[i];

        for (int k = 2 * i + 1; k < len; k = 2 * k + 1) {
            if (k + 1 < len && nums[k] < nums[k+1]) {
                k ++;
            }
            if (nums[k] > base) {
                nums[i] = nums[k];
                i = k;
            } else {
                break;
            }
        }

        nums[i] = base;
    }

    public static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}