这种合并排序的迭代实现是否正确？

Question

对我来说，这似乎很简单。请注意，这不会通过分成两半来生成单个元素数组，而是通过使用单个循环来生成。

function mergeSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    arr[i] = [arr[i]]
  }
  while (arr.length > 1) {
    for (let i = 0; i < arr.length; i = i + 2) {
      arr.splice(i, 2, mergeTwoSortedArrays(arr[i], arr[i + 1] || []))
    }
  }
  return arr[0]
}

我的测试通过了，但时间/空间复杂度可能没有那么好？

Answer 1

arr.splice(i, 2, ...) 将需要移动i 之后的内容，因此这不是一个恒定时间操作，因此您超出了您期望的 O(nlogn) 时间复杂度使用合并排序。

为了解决这个问题，我建议不要从数组中拼接任何东西，而只是跳过不再相关的数组条目。

function mergeSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        arr[i] = [arr[i]];
    }
    for (let step = 1; step < arr.length; step *= 2) {
        for (let i = 0; i + step < arr.length; i += step*2) {
            arr[i] = mergeTwoSortedArrays(arr[i], arr[i+step]);
            delete arr[i+step]; // optional; to have it garbage collected
        }
    }
    return arr[0];
}

function mergeTwoSortedArrays(a, b) {
    let merged = [];
    let i = 0, j = 0;
    while (i < a.length || j < b.length) {
        merged.push(
            i < a.length && (j >= b.length || a[i] < b[j])
            ? a[i++]
            : b[j++]
        );
    }
    return merged;
}

let arr = Array.from({length: 1000}, () => Math.floor(Math.random() * 1000000));
let sorted = mergeSort([...arr]);
let sorted2 = arr.sort((a,b) => a-b); // verify
console.log(sorted+"" === sorted2+""); // output verification result

Answer 2

这是O(n^2)，但常量很好。

问题是arr.splice是O(n)操作，没有办法优化。您从数组中间取出 2 个值，然后必须将其他所有内容移过来。该移动操作经过高度优化，但仍然是O(n)。

改用shift/push 来解决这个问题。这将导致元素在数组中“旋转”。 （实际上数组会在内存中移动，直到它被移动，然后再次在内存中移动。但这一切都应该得到很好的优化。）

function mergeSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    arr[i] = [arr[i]]
  }
  while (arr.length > 1) {
    let elt1 = arr.shift()
    let elt2 = arr.shift()
    arr.push(mergeTwoSortedArrays(elt1, elt2))
  }
  return arr[0]
}

（旁注，我保持了你的风格。但天哪，我想在几个地方撒;！）