面试官让我手撕快排、归并，写了比较简洁的实现

import org.junit.Test;

import java.util.Arrays;

/**
 * 
 * @create2020-08-10 10:44
 */
public class SortDemo {
    @Test
    public void testSort() {
        int[] nums = new int[15];
        for (int i = 0; i < 15; i++) {
            nums[i] = (int) (Math.random() * 10);
        }
        System.out.println(Arrays.toString(nums));
//        quickSort(nums, 0, nums.length - 1);
        MergeSort(nums);
        System.out.println(Arrays.toString(nums));
    }

    private void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    /**
     * 冒泡排序
     *
     * @param array
     */
    public void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
    }

    /**
     * 选择排序
     *
     * @param array
     */
    public void selectSort(int[] array) {
        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i; j < array.length; j++) {
                temp = array[i];
                if (array[i] > array[j]) {
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

    /**
     * 插入排序
     *
     * @param array
     */
    public void insertSort(int[] array) {
        int temp;
        for (int i = 1; i < array.length; i++) {
            temp = array[i];
            int j = i - 1;
            while (j >= 0 && array[j] > temp) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = temp;
        }
    }

    /**
     * 希尔排序
     *
     * @param array
     */
    public void sheelSort(int[] array) {
        int l = array.length / 2;
        int temp;
        while (l != 0) {
            for (int i = l; i < array.length; i += l) {
                temp = array[i];
                int j = i - l;
                while (j >= 0 && array[j] > temp) {
                    array[j + l] = array[j];
                    j = j - l;
                }
                array[j + l] = temp;
            }
            l /= 2;
        }
    }

    /**
     * 快速排序
     *
     * @param array
     * @param start
     * @param end
     */
    public void quickSort(int[] array, int start, int end) {
        if (start >= end) return;
        int base = array[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (i < j && array[j] > base) j--;
            if (i < j) array[i++] = array[j];
            while (i < j && array[i] < base) i++;
            if (i < j) array[j--] = array[i];
        }
        array[i] = base;
        quickSort(array, start, i - 1);
        quickSort(array, i + 1, end);
    }

    /**
     * 归并排序
     *
     * @param array
     * @return
     */
    public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));
    }

    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     *
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
        int[] res = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < left.length + right.length; index++) {
            if (i >= left.length) {
                res[index] = right[j++];
            } else if (j > right.length) {
                res[index] = left[i++];
            } else if (left[i] > right[j]) {
                res[index] = right[j++];
            } else {
                res[index] = left[i++];
            }
        }
        return res;
    }

}


/**
     * 堆排序
     * @param arr array
     */
    public static void heapSort(int[] arr) {
        //1.构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr, i, arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j = arr.length - 1; j > 0; j--) {
            swap(arr, 0, j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr, 0, j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     *
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];//先取出当前元素i
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {//从i结点的左子结点开始，也就是2i+1处开始
            if (k + 1 < length && arr[k] < arr[k + 1]) {//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if (arr[k] > temp) {//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            } else {
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }