归并排序算法

归并排序是基于分治的思想,是稳定排序
分(divide)的阶段：分成一些小的问题然后递归求解，时间复杂度为O(log2n)
治(conquer)的阶段：则将分的阶段得到的各答案"合并"在一起,时间复杂度为cn)

总的平均时间复杂度为O(nlogn)。而且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

递归

     *  long f(int n){
     *      if(n=1){
     *          return 1;
     *      }
     *      return n+f(n-1);
     *  }

第一版，merge方法中把定义了两个临时数组来进行合并

/**
 * @description: 归并排序，
 *  如果一个数组{1, 3, 5,7, 8 ,2, 4,6, 9}
 *  分成两个数组{1,3,5,7,8} 和{2,4,6,9}
 *  这两个数组都是有序的。
 *  只需要把这两个数组放到merge方法中，比较两个数组的元素，就能得到一个排好序的数组
 *  参考
 *  https://www.bilibili.com/video/BV1yb411p7f1?spm_id_from=333.337.search-card.all.click
 * @author: xt
 * @create: 2022-03-16 23:45
 **/
public class MergeSort {


    public static void main(String[] args) {
        //{1, 7, 5,3, 8 ,2, 4,6, 9};
        int arr[] = {7, 1, 5,3};
        int left = 0;
        int right = 3;
        sort(arr, left, right);
        System.out.println("===============");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    /**
     * @Author
     * @Description 递归调用来拆分数组。把原数组放进去，
     * 分成两个数组A（left，mid）和B（mid+1，right），理论上如果A和B是有序的，直接调用C方法 (merge方法)就能完成排序
     * 但A与B方法有可能不是有序的，就需要在不断的2分，A变成A1和A2，执行C1(merge方法)，B变成B1和B2，执行C2(merge方法)
     * 一直递归调用下去，最后使A和B都变成有序的，才能执行C方法完成
     *
     *  递归方法
     *  求f(10)
     *  long f(int n){
     *      if(n=1){
     *          return 1;
     *      }
     *      return n+f(n-1);
     *  }
     *
     * @Date 21:33 2022/3/17
     * @Param [arr, left, right]
     * @return void
     **/
    public static void sort(int arr[], int left, int right) {
        /**
         * 数组中只有一个元素了，那这个数组肯定是有序的
         **/
        if (right == left) {
            return;
        }
        int mid = (left + right) / 2;
        /**
          左半边排序
         **/
        sort(arr, left, mid);
        /**
         右半边排序
         **/
        sort(arr, mid + 1, right);
        /**
         合并左右数组
         **/
        merge(arr, left, mid + 1, right);
    }

    /**
     * @Author
     * @Description  将两个有序的数组进行合并
     * @Date 21:32 2022/3/17
     * @Param [arr, left, mid, right]
     * @return void
     **/
    public static void merge(int arr[], int left, int mid, int right) {
        int leftSize = mid - left;
        int rightSize = right - mid + 1;
        int leftArr[] = new int[leftSize];
        int rightArr[] = new int[rightSize];

        /**
          保存左边的数组
         **/

        for (int i = left; i < mid; i++) {
            leftArr[i-left] = arr[i];
        }
        /**
         保存右边的数组
         **/
        for (int i = mid; i < right+1; i++) {
            rightArr[i - mid] = arr[i];
        }
        /**
           需要3个指针
            i 为左边数组的起始位置
            j 为右边数组的起始位置
            k 为新数组的起始位置
         **/
        int i = 0, j = 0, k = left;
        /**
         *  从起始位置开始比较左右数组的大小，小的放入新的位置
         **/
        while (i < leftSize && j < rightSize) {
            if (leftArr[i] < rightArr[j]) {
                arr[k++] = leftArr[i++];
            } else {
                arr[k++] = rightArr[j++];
            }
        }
        /**
         *  如果左边的数组还有多余的值，因为数组是有序的，直接放入新数组
         **/
        while (i < leftSize) {
            arr[k++] = leftArr[i++];
        }
        /**
         *  如果右边的数组还有多余的值，因为数组是有序的，直接放入新数组
         **/
        while (j < rightSize) {
            arr[k++] = rightArr[j++];
        }
    }


}

第二版，merge方法中把定义了一个临时数组，但需要回写原数组

/**
 * @description: 归并排序，
 *  如果一个数组{1, 3, 5,7, 8 ,2, 4,6, 9}
 *  分成两个数组{1,3,5,7,8} 和{2,4,6,9}
 *  这两个数组都是有序的。
 *  只需要把这两个数组放到merge方法中，比较两个数组的元素，就能得到一个排好序的数组
 *  参考
 *  https://www.bilibili.com/video/BV1yb411p7f1?spm_id_from=333.337.search-card.all.click
 * @author: xt
 * @create: 2022-03-16 23:45
 **/
public class MergeSort_V2 {


    public static void main(String[] args) {
        //{1, 7, 5,3, 8 ,2, 4,6, 9};
        int arr[] = {1, 7, 5,3, 8 ,2, 4,6};
        int left = 0;
        int right = 7;
        sort(arr, left, right);
        System.out.println("===============");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    /**
     * @Author
     * @Description 递归调用来拆分数组。把原数组放进去，
     * 分成两个数组A（left，mid）和B（mid+1，right），理论上如果A和B是有序的，直接调用C方法 (merge方法)就能完成排序
     * 但A与B方法有可能不是有序的，就需要在不断的2分，A变成A1和A2，执行C1(merge方法)，B变成B1和B2，执行C2(merge方法)
     * 一直递归调用下去，最后使A和B都变成有序的，才能执行C方法完成
     *
     *  递归方法
     *  求f(10)
     *  long f(int n){
     *      if(n=1){
     *          return 1;
     *      }
     *      return n+f(n-1);
     *  }
     *
     * @Date 21:33 2022/3/17
     * @Param [arr, left, right]
     * @return void
     **/
    public static void sort(int arr[], int left, int right) {
        /**
         * 数组中只有一个元素了，那这个数组肯定是有序的
         **/
        if (right == left) {
            return;
        }
        int mid = (left + right) / 2;
        /**
          左半边排序
         **/
        sort(arr, left, mid);
        /**
         右半边排序
         **/
        sort(arr, mid + 1, right);
        /**
         合并左右数组
         **/
        merge(arr, left, mid + 1, right);
    }

    /**
     * @Author
     * @Description  将两个有序的数组进行合并
     * @Date 21:32 2022/3/17
     * @Param [arr, left, mid, right]
     * @return void
     **/
    public static void merge(int arr[], int left, int mid, int right) {


        /** 保存已经排好的临时数组
         **/
        int[] tmp=new int[right-left+1];

        /**
           需要3个指针
            i 为左边数组的起始位置
            j 为右边数组的起始位置(中间的位置开始)
            k 为新数组的起始位置
         **/
        int i = left, j = mid, k = 0;
        /**
         *  从起始位置开始比较左右数组的大小，小的放入新的位置
         **/
        while (i <mid && j <= right) {
            if (arr[i] < arr[j]) {
                tmp[k++] = arr[i++];
            } else {
                tmp[k++] = arr[j++];
            }
        }
        /**
         *  如果左边的数组还有多余的值，因为数组是有序的，直接放入新数组
         **/
        while (i < mid) {
            tmp[k++] = arr[i++];
        }
        /**
         *  如果右边的数组还有多余的值，因为数组是有序的，直接放入新数组
         **/
        while (j <= right) {
            tmp[k++] = arr[j++];
        }

        /**
         * 回写原数组
         **/
        for (int m = 0; m <tmp.length ; m++) {
            arr[left+m]=tmp[m];
        }
    }


}