13 归并排序法

1 归并排序法思想

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。


再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤

2 归并排序法的代码实现

2.1 java

package sort;

/**
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/17 08:29:03
 * @desc 归并排序
 */

public class MergeSortForJava {
    public static void main(String[] args) {
        int sum = 8;
        int[] arr = new int[sum];
        for (int i = 0; i < sum; i++) {
            arr[i] = (int) (Math.random() * sum); //生成一个[0, sum) 数
        }
        int[] temp = new int[sum];
        System.out.println("排序前:");
        show(arr);
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println("排序后:");
        show(arr);
    }

    /**
     * 分+合方法
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            ; //中间索引

            //向左递归进行分解
            mergeSort(arr, left, mid, temp);

            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);

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

    /**
     * 合并的方法
     *
     * @param arr   排序的原始数组
     * @param left  左边有序序列的初始索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp  做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; //初始化 i, 左边有序序列的初始索引
        int j = mid + 1; //初始化 j, 右边有序序列的初始索引
        int t = 0; // 指向 temp 数组的当前索引

        //先把左右两边(有序)的数据按照规则填充到 temp 数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right) {
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素，填充到 temp 数组
            //然后 t++, i++
            if (arr[i] < arr[j]) {
                temp[t] = arr[i];
                i++;
                t++;
            } else {
                temp[t] = arr[j];
                j++;
                t++;
            }
        }
        //(二)
        //把有剩余数据的一边的数据依次全部填充到 temp
        while (i <= mid) {
            temp[t] = arr[i];
            i++;
            t++;
        }

        while (j <= right) {
            temp[t] = arr[j];
            j++;
            t++;
        }

        //(三)
        //将 temp 数组的元素拷贝到 arr
        //注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            tempLeft++;
            t++;
        }

    }

    public static void show(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

2.2 scala

package sort

/**
 *
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/17 08:50:56
 * @desc TODO
 *
 */

object MergeSortForScala {
  def main(args: Array[String]): Unit = {
    val sum = 8

    val arr = Array.ofDim[Int](sum)
    for (i <- 0 until arr.length) {
      arr(i) = (math.random() * sum).toInt
    }
    val temp = Array.ofDim[Int](sum)
    println("排序前:")
    show(arr)
    mergeSort(arr, 0, arr.length - 1, temp)
    println("排序后:")
    show(arr)
  }

  /**
   * 分 + 合方法
   *
   * @param arr
   * @param left
   * @param right
   * @param temp
   */
  def mergeSort(arr: Array[Int], left: Int, right: Int, temp: Array[Int]) {
    if (left < right) {
      var mid: Int = (left + right) / 2

      //左边分解
      mergeSort(arr, left, mid, temp)

      //右边分解
      mergeSort(arr, mid + 1, right, temp)

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

  /**
   * 合并方法
   *
   * @param arr
   * @param left
   * @param mid
   * @param right
   * @param temp
   */
  def merge(arr: Array[Int], left: Int, mid: Int, right: Int, temp: Array[Int]) = {
    var i = left
    var j = mid + 1
    var t = 0

    //从left 和right中选择小的数放到temp中
    //如果其中一个数组没有数据停止
    while (i <= mid && j <= right) {
      if (arr(i) < arr(j)) {
        temp(t) = arr(i)
        t += 1
        i += 1
      } else {
        temp(t) = arr(j)
        t += 1
        j += 1
      }
    }

    //把left和right剩下的数放到temp中
    while (i <= mid) {
      temp(t) = arr(i)
      t += 1
      i += 1
    }

    while (j <= right) {
      temp(t) = arr(j)
      t += 1
      j += 1
    }

    //把temp中的数组复制回arr
    var tempLeft = left
    t = 0
    while (tempLeft <= right) {
      arr(tempLeft) = temp(t)
      t += 1
      tempLeft += 1
    }

  }

  def show(arr: Array[Int]): Unit = {
    for (i <- arr) {
      print(i + " ")
    }
    println()
  }
}