写一个方法实现“归并排序算法”，并解释下时间复杂度和空间复杂度

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr; // 递归终止条件：数组长度小于等于1时，已经有序
  }

  const mid = Math.floor(arr.length / 2);
  const left = arr.slice(0, mid);
  const right = arr.slice(mid);

  // 递归地对左右两部分进行排序
  const sortedLeft = mergeSort(left);
  const sortedRight = mergeSort(right);

  // 合并已排序的两部分
  return merge(sortedLeft, sortedRight);
}

function merge(left, right) {
  let result = [];
  let i = 0;
  let j = 0;

  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      result.push(left[i]);
      i++;
    } else {
      result.push(right[j]);
      j++;
    }
  }

  // 将剩余元素添加到结果数组
  while (i < left.length) {
    result.push(left[i]);
    i++;
  }
  while (j < right.length) {
    result.push(right[j]);
    j++;
  }

  return result;
}


// 示例用法:
const unsortedArray = [5, 2, 8, 1, 9, 4, 7, 3, 6];
const sortedArray = mergeSort(unsortedArray);
console.log(sortedArray); // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

时间复杂度：

归并排序的时间复杂度是 O(n log n)，其中 n 是数组的长度。 这是因为它将问题分解成更小的子问题（对半分），递归地解决这些子问题，然后合并结果。 分解和合并步骤都需要线性时间 O(n)，而递归深度是 log n。 因此，总时间复杂度为 O(n log n)。 这个时间复杂度在所有情况下（最好、平均和最坏）都是一样的，使得归并排序成为一种非常稳定的排序算法。

空间复杂度：

归并排序的空间复杂度是 O(n)，因为它需要额外的空间来存储合并过程中的临时数组。虽然递归调用会占用一些栈空间，但这部分空间通常远小于用于合并的临时数组的空间，因此空间复杂度主要由临时数组决定。 这意味着归并排序不是一个“原地”排序算法，因为它需要额外的内存。 在处理大型数据集时，这可能会成为一个限制因素。

前端开发中的考虑：

• JavaScript 的数组方法: 上面的代码使用了 slice() 和 push() 等 JavaScript 数组方法，这些方法使得代码更简洁易懂。
• 大型数据集: 对于非常大的数据集，递归可能会导致栈溢出。 虽然这种情况在前端相对少见，但如果需要处理极大的数组，可以考虑使用迭代版本的归并排序来避免这个问题。
• 实用性: 在前端开发中，对于小型到中等大小的数据集，内置的 Array.prototype.sort() 方法通常足够快。 归并排序更常用于需要稳定排序或作为学习排序算法的示例。

希望这个解释对您有所帮助！