归并排序法02：归并排序法的优化

优化一：对有序数组排序的优化

在每次合并两个子数组前进行判断，如果左边数组的最大值都小于右边数组的最小值，就不用进行合并操作

对于完全有序的数组，递归树中每层都不用进行合并，最后一层叶子节点需要操作的次数是n，其上一层为1/2n，1/4n...最后总共需要操作的次数为2n

因此对于完全有序的数组，归并排序法的时间复杂度会降为O(n)

import java.util.Arrays;

public class Algorithm {

    public static void main(String[] args) {

        Integer[] arr = {6,6,3,2,4,7};

        MergeSort.sortOptimised1(arr);
        System.out.println(Arrays.toString(arr));
    }
}

class MergeSort {

    private MergeSort(){}

    public static<E extends Comparable<E>> void sortOptimised1(E[] arr){
        
        sortOptimised1(arr, 0, arr.length - 1);
    }

    private static<E extends Comparable<E>> void sortOptimised1(E[] arr, int left, int right){

        if (left >= right){
            
            return;
        }

        int mid = left + (right - left) / 2;

        sortOptimised1(arr, left, mid);
        sortOptimised1(arr, mid + 1, right);

        /**
         * 优化一：对有序数组排序的优化，合并前先判断一下是否需要合并
         */
        if (arr[mid].compareTo(arr[mid + 1]) > 0) {
            merge(arr, left, mid, right);
        }
    }

    public static<E extends Comparable<E>> void merge(E[] arr, int left, int mid, int right) {

        int i = left;
        int j = mid + 1;

        E[] tem = Arrays.copyOfRange(arr, left, right + 1);

        for (int n = left; n < right + 1; n++) {

            if (i == mid + 1){
                
                arr[n] = tem[j - left];
                j++;
            }
            else if (j == right + 1) {
                
                arr[n] = tem[i - left];
                i++;
            }
            else if (tem[i - left].compareTo(tem[j - left]) <= 0) {
                
                arr[n] = tem[i - left];
                i++;
            }
            else{
                
                arr[n] = tem[j - left];
                j++;
            }
        }
    }
}

优化二：使用插入排序法优化（不稳定）

虽然归并排序法的时间复杂度小于插入排序法，但是merge()方法包含大量的if判断和赋值语句，常数级别的语句很多，在子区间长度较小时，可用插入排序法来代替

import java.util.Arrays;

public class Algorithm {

    public static void main(String[] args) {

        Integer[] arr = {6,6,3,2,4,7};

        MergeSort.sortOptimised2(arr);
        System.out.println(Arrays.toString(arr));
    }
}

class MergeSort {

    private MergeSort(){}

    /**
     * 优化二：在子区间长度小于16时，使用插入排序法代替
     */
    public static<E extends Comparable<E>> void sortOptimised2(E[] arr){

        sortOptimised2(arr, 0, arr.length - 1);
    }

    private static<E extends Comparable<E>> void sortOptimised2(E[] arr, int left, int right){

        if (right - left <= 15) {

            InsertionSort.sort(arr, left, right);
            return;
        }

        int mid = left + (right - left) / 2;

        sortOptimised2(arr, left, mid);
        sortOptimised2(arr, mid + 1, right);

        if (arr[mid].compareTo(arr[mid + 1]) > 0) {
            merge(arr, left, mid, right);
        }
    }

    public static<E extends Comparable<E>> void merge(E[] arr, int left, int mid, int right) {

        int i = left;
        int j = mid + 1;

        E[] tem = Arrays.copyOfRange(arr, left, right + 1);

        for (int n = left; n < right + 1; n++) {

            if (i == mid + 1){

                arr[n] = tem[j - left];
                j++;
            }
            else if (j == right + 1) {

                arr[n] = tem[i - left];
                i++;
            }
            else if (tem[i - left].compareTo(tem[j - left]) <= 0) {

                arr[n] = tem[i - left];
                i++;
            }
            else{

                arr[n] = tem[j - left];
                j++;
            }
        }
    }
}

class InsertionSort {

    private InsertionSort() {}

    /**
     * 插入排序法修改一下传入的参数
     */
    public static <E extends Comparable> void sort(E[] arr, int left, int right) {

        for (int i = left + 1; i < right + 1; i++) {

            E tem = arr[i];
            int j;

            for (j = i; j > left && tem.compareTo(arr[j - 1]) < 0; j--) {
                arr[j] = arr[j - 1];
            }

            arr[j] = tem;
        }
    }
}

优化三：内存优化

merge()方法在每次调用时，都会开辟一个新的数组来接收传来的数组，当数据规模很大时，空间消耗也会损失很多性能

因此在排序之前先创建一个原数组的副本temp，merge()方法就在temp中进行赋值和读取，节省了大量的空间

import java.util.Arrays;

public class Algorithm {

    public static void main(String[] args) {

        Integer[] arr = {6,6,3,2,4,7};

        MergeSort.sortOptimised3(arr);
        System.out.println(Arrays.toString(arr));
    }
}

class MergeSort {

    private MergeSort(){}

    /**
     * 优化三：内存操作优化，提前将arr数组保存一个副本，当作参数传入，不用每次再新建临时数组，也没有索引的偏差了
     */
    public static<E extends Comparable<E>> void sortOptimised3(E[] arr){

        E[] temp = Arrays.copyOf(arr, arr.length);
        sortOptimised3(arr, 0, arr.length - 1, temp);
    }

    private static<E extends Comparable<E>> void sortOptimised3(E[] arr, int left, int right, E[] temp){

        if (left >= right){

            return;
        }

        int mid = left + (right - left) / 2;

        sortOptimised3(arr, left, mid, temp);
        sortOptimised3(arr, mid + 1, right, temp);

        if (arr[mid].compareTo(arr[mid + 1]) > 0) {
            mergeOptimised(arr, left, mid, right, temp);
        }
    }

    public static<E extends Comparable<E>> void mergeOptimised(E[] arr, int left, int mid, int right, E[] temp) {

        int i = left;
        int j = mid + 1;

        /**
         * System.arraycopy()方法将传过来的有序子区间在相同位置赋值给副本数组temp，因此索引范围一致没有偏移
         */
        System.arraycopy(arr, left, temp, left, right - left + 1);

        for (int n = left; n < right + 1; n++) {

            if (i == mid + 1){

                arr[n] = temp[j];
                j++;
            }
            else if (j == right + 1) {

                arr[n] = temp[i];
                i++;
            }
            else if (temp[i].compareTo(temp[j]) <= 0) {

                arr[n] = temp[i];
                i++;
            }
            else{
                
                arr[n] = temp[j];
                j++;
            }
        }
    }
}