归并排序（JS版）

归并排序的时间复杂度为O(nlogn)，属于稳定排序（需要额外空间）。

其是一种采用分治法的典型的算法应用。

该排序算法的主体思想：

1. “分治”：不断将当前数组从中点处分割（直至末尾被分割的数组只有1个元素），不断将复杂的大问题拆解为易于处理的小问题；

2. “合并”：当拆分后的子数组长度为1时，开始由底向上进行合并操作（将当前子数组排序后合并），直至合并至原数组，此时完成了排序；

示例代码1（返回新数组）：

/**
 * 归并排序
 * @param {number[]} arr - 待排序数组
 * @return {number[]} 排序后的新数组
 */
function mergeSort(arr) {
  const len = arr.length;
  if (len < 2) return arr;
  // --- “分”
  const m = Math.floor(len / 2);
  const left = arr.slice(0, m);
  const right = arr.slice(m);
  // --- “合”
  return merge(mergeSort(left), mergeSort(right));
}

/**
 * 合并数组（排序）
 * @param {number[]} A - 子数组（左）
 * @param {number[]} B - 子数组（右）
 * @return {number[]} 合并且排序后的数组
 */ 
function merge(A, B) {
  const merged = [];
  while (A.length > 0 && B.length > 0) {
    if (A[0] <= B[0]) {
      merged.push(A.shift());
    } 
    else {
      merged.push(B.shift());
    }
  }

  if (A.length > 0) {
    merged.push(...A);
  } 
  else if (B.length > 0) {
    merged.push(...B);
  }

  return merged;
}

示例代码2（修改原数组）：

/**
 * 归并排序
 * @param {number[]} nums - 待排序的数组
 * @param {number} l - 左端点索引
 * @param {number} r - 右端点索引
 */
function mergeSort(nums, l, r) {
  // 终止条件
  if (l >= r) return;
  // 分治
  const m = ((r - l) >> 1) + l;
  mergeSort(nums, l, m);
  mergeSort(nums, m + 1, r);
  // 合并
  // 拷贝nums的[l, r]区间内的元素，对应到tmp的[0, r - l];
  const tmp = nums.slice(l, r + 1);
  // i 指向tmp数组中左半部的起点
  let i = 0;
  // j 指向tmp数组中右半部的起点
  let j = m - l + 1;
  // 对nums[l, r]区间的元素进行赋值重排，参照tmp的数据备份
  for (let k = l; k <= r; k++) {
    // 如果当前区间内的左半部已走完
    if (i === m - l + 1) {
      nums[k] = tmp[j++];
    }
    // 如果当前区间内的右半部已走完 或 左半部当前索引的元素小于等于对应右半部的
    else if (j === r - l + 1 || tmp[i] <= tmp[j]) {
      nums[k] = tmp[i++];
    }
    // 右半部当前索引的元素小于对应左半部的
    else {
      nums[k] = tmp[j++];
    }
  }
}

End