归并排序

递归的佛系理解：
事实上，我们并不是每个函数都需要跟进去看执行结果的，比如我们在自己的函数中调用printf函数时，并没有钻进去看它是怎么打印的，因为我们相信它能完成打印工作。

如果你相信你正在写的递归函数是正确的，并调用它，然后在此基础上写完这个递归函数，那么它就会是正确的，从而值得你相信它正确。

以上两句话就是要明白一个道理：不要把自己放进递归函数中，放进一些简单的递归如阶乘，可能你还能理解，但是换个求全排列这样复杂点的递归函数你可能就懵逼了。
你要站在一个上帝视角去看待问题，就像走迷宫，你不知道正确的路线就往里面走，那么你一定会迷路的，但是如果我站在高处的地方把正确的路线找到了，
那我走迷宫的时候就不会迷路了。所以不要主观的看待，客观的把它当做一个人，你交给他的任务他一定能够完成的，你也千万别替他安排任务该如何去完成

 

归并排序

采用分治法的一个非常典型的应用。（分治法--->将一个大问题分成很多个小问题进行解决，最后重新组合起来；------》针对排序杂乱无章的数组）
即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并排序的时间复杂度，在最坏，最好和平均都是O(nlogn)，这是效率，性能非常好的排序算法。
只不过它需要占用 O(n)的内存空间，如果数据量一旦很大，内存可能吃不消，这是它的弱点和致命伤。
而其他排序算法，比如快速排序，希尔排序，都是就地排序算法（不随程序规模增大，而增加空间资源），它们不占用额外的内存空间。
不过，这个占用内存的弱点，可以改进为就地排序（场景：MR的shuffle，内存中利用了快速排序，外部文件中利用了归并排序）

归并操作的工作原理如下：
    第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
    第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
    第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
    重复步骤3直到某一指针超出序列尾
    将另一序列剩下的所有元素直接复制到合并序列尾

总结：
将两个已排好序的数组合并成一个有序的数组,称之为归并排序
步骤：遍历两个数组，比较它们的值。谁比较小，谁先放入大数组中，直到数组遍历完成

代码实现：
1）递归拆分
2）合并
   a.遍历两个数组，比较它们的值。谁比较小，谁先放入大数组中，直到数组遍历完成
   b.将左右两边剩余元素合并
   c.将temp中的元素全部拷贝到原数组中
   

java版：
public class MergeSort {
    public static void main(String[] args) {
        int[] arr= {9, 22, 5, 1, 3, 27};

        int[] temp = new int[arr.length];// 在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr, 0, arr.length - 1, temp);

        for(int ele: arr){
            System.out.println(ele);
        }
    }

    private static void sort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(arr, left, mid, temp);// 左边归并排序，使得左子序列有序
            sort(arr, mid + 1, right, temp);// 右边归并排序，使得右子序列有序
            merge(arr, left, mid, right, temp);// 将两个有序子数组合并操作
        }
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;// 左序列指针left到mid
        int j = mid + 1;// 右序列指针mid+1到right
        int t = 0;// 临时数组指针
        while (i <= mid && j <= right) {//合并
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        while (i <= mid) {// 将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while (j <= right) {// 将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        // 将temp中的元素全部拷贝到原数组中
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }
}

 

--------

scala版：

/**
 * 代码实现：
 * 1）递归拆分
 * 2）合并
 *    a.遍历两个数组，比较它们的值。谁比较小，谁先放入大数组中，直到数组遍历完成
 *    b.将左右两边剩余元素合并
 *    c.将temp中的元素全部拷贝到原数组中
 */
object MergeSort {

  def main(args: Array[String]): Unit = {
    //对象不可变的是地址，内容可变;
    val array = Array(3, 44, 5, 66, 8, 0, 2, 4)

    //定义数组长度
    val temp = new Array[Int](array.length)

    mergeSort(array, 0, array.length - 1, temp)

    //归并后再次遍历原来的数组array
    for (arr <- array) {
      println(arr)
    }

  }


  def mergeSort(arrayData: Array[Int], left: Int, right: Int, temp: Array[Int]): Unit = {
    if (left < right) {
      val mid = (left + right) / 2
      //递归拆分
      mergeSort(arrayData, left, mid, temp)
      mergeSort(arrayData, mid + 1, right, temp)

      //合并
      merge(arrayData, left, mid, right, temp)
    }
  }


  def merge(array: Array[Int], left: Int, mid: Int, right: Int, temp: Array[Int]) = {
    var i = left
    var j = mid + 1
    var t = 0

    //a.遍历两个数组，比较它们的值。谁比较小，谁先放入大数组中，直到数组遍历完成
    while (i <= mid && j <= right) {
      if (array(i) <= array(j)) {
        temp(t) = array(i)
        t = t + 1
        i = i + 1
      } else {
        temp(t) = array(j)
        t = t + 1
        j = j + 1
      }
    }

    //b.将左两边剩余元素合并
    while (i <= mid) {
      temp(t) = array(i)
      t = t + 1
      i = i + 1
    }

    //将右两边剩余元素合并
    while (j <= right) {
      temp(t) = array(j)
      t = t + 1
      j = j + 1
    }

    // c.将temp中的元素全部拷贝到原数组中
    t = 0
    var start = left //当前批次的array的起始位置
    while (start <= right) {
      array(start) = temp(t)
      t = t + 1
      start = start + 1
    }

  }


}

 

----------------------------------------------------------

二、归并排序:

想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列

1.两路归并排序算法思路 

①把 n 个记录看成 n 个长度为1的有序子表

②进行两两归并使记录关键字有序，得到 n/2 个长度为 2 的有序子表

 

 

 ③重复第②步直到所有记录归并成一个长度为 n 的有序表为止

 

直白的所就是分为两个步骤

现将数组中的元素拆分成一个一个的子集,使用合并将子集变成有序

拆分是很简单的操作,每次都按照原有的数组元素进行一半拆分 开始元素的位置+最后一个元素的位置/2

如何将将二个有序数列合并。只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。 

总体思路

归并排序的算法我们通常用递归实现。 
先把待排序区间 [s,t] 以中点二分； 
接着把左边子区间排序； 
再把右边子区间排序； 
最后把左区间和右区间用一次归并操作合并成有序的区间 [s,t] 。

 

import java.util.Arrays;   public class MergeSort { public static void main(String[] args) {   int[] array = new int[10];         for(int i = 0;i<array.length;i++){          array[i] = (int)(Math.random()*100);         }     System.out.println(Arrays.toString(array));   mergeSort(array, 0, array.length - 1);  System.out.println(Arrays.toString(array)); }   public static void mergeSort(int[] array, int left, int right) { if (left < right) { int center = (left + right) / 2; // 将数组拆分为两份，并递归拆分子数组，直到数组中只有一个元素 mergeSort(array, left, center); mergeSort(array, center + 1, right); // 合并相邻数组 merge(array, left, center, right);   } }   // 合并子数组的函数 public static void merge(int[] array, int left, int center, int right) { // 临时数组，用于排序 int[] tempArray = new int[array.length]; // 用于将排好序的临时数组复制回原数组 int mark = left; // 第二个数组的左端 int mid = center + 1; // 用于临时数组的下标 int tempLeft = left; while (left <= center && mid <= right) { // 从两个子数组中取出最小的放入临时数组，即按从小到大的顺序重新排布 if (array[left] <= array[mid]) { tempArray[tempLeft++] = array[left++]; } else { tempArray[tempLeft++] = array[mid++]; } } // 剩余部分依次放入临时数组 while (left <= center) { tempArray[tempLeft++] = array[left++]; } while (mid <= right) { tempArray[tempLeft++] = array[mid++]; } // 将中间数组中的内容复制回原数组 while (mark <= right) { array[mark] = tempArray[mark++]; } } }

 

 

归并排序的时间复杂度为O(nlogn) ，因为递归每次按照一半分区，并且merge需要线性时间。最重要的是该算法中最好、最坏和平均的时间性能都是O(nlogn)。

归并排序的空间复杂度为O(n)，会占用内存。

总之，归并排序虽然比较占用内存，但却是一种效率高且稳定的算法。

 

6 总结

归并排序的时间复杂度，在最坏，最好和平均都是O(nlogn)，这是效率，性能非常好的排序算法。

只不过它需要占用 O(n)的内存空间，如果数据量一旦很大，内存可能吃不消，这是它的弱点和致命伤。而其他排序算法，比如快速排序，希尔排序，都是就地排序算法，它们不占用额外的内存空间。

不过，这个占用内存的弱点，可以改进为就地排序（场景：MR的shuffle，内存中利用了快速排序，外部文件中利用了归并排序）