2.算法系列之排序算法之归并排序

/**
 * 归并排序
 *
 * @author Jian Shen
 * @version V1.0.0
 * @date 2019/7/21
 */
public abstract class MergeSort<T extends Comparable<T>> extends Sort<T> {
    
    

    protected T[] assist; // 辅助数组

    /**
     * 将数组中已经排好序的两个部分[左侧部分、右侧部分]合并
     *
     * @param array
     * @param left
     * @param middle
     * @param right
     */
    protected void merge(@NotNull T[] array, int left, int middle, int right) {
    
    
        int i = left;
        int j = middle + 1;

        for (int k = left; k <= right; k++) {
    
    
            assist[k] = array[k];
        }

        for (int k = left; k <= right; k++) {
    
    
            if (i > middle) {
    
     // 说明左侧部分已经完成合并，仅需合并右侧部分
                array[k] = assist[j++];
            } else if (j > right) {
    
     // 说明右侧部分已经完成合并，仅需合并左侧部分
                array[k] = assist[i++];
            } else if (assist[i].compareTo(assist[j]) <= 0) {
    
    
                array[k] = assist[i++];
            } else {
    
    
                array[k] = assist[j++];
            }
        }
    }
}

/**
 * 自顶向下归并排序
 *
 * 将数组分成两个部分，分别进行排序，然后归并起来
 * 这种对半分的复杂度为O(NlogN)
 *
 * @author Jian Shen
 * @version V1.0.0
 * @date 2019/7/21
 */
public class Up2DownMergeSort<T extends Comparable<T>> extends MergeSort<T> {
    
    

    @Override
    public void sort(T[] array) {
    
    
        assist = (T[]) new Comparable[array.length];
        sort(array, 0, array.length - 1);
    }

    private void sort(T[] array, int left, int right) {
    
    
        if (left >= right) {
    
    
            return ;
        }
        int middle = left + (right - left) / 2;
        sort(array, left, middle);
        sort(array, middle + 1, right);
        merge(array, left, middle, right);
    }

    public static void main(String[] args) {
    
    
        Sort sort = new Up2DownMergeSort();
        Integer[] array = new Integer[]{
    
    1, 3, 2, 4, 4, 9, 10, 3, 3};
        sort.sort(array);
        System.out.println(Arrays.asList(array));
    }
}