如何在 Big-O(N) 时间内将 3 个排序数组合并为 1 个排序数组？

Question

尝试将 3 个数组合并为一个，以使最终数组有序。

给定

int[] a = {1,3};
int[] b = {2,4};
int[] c = {1,5};

合并数组，使最终数组 d = {1,1,2,3,4,5}

不能只是连接它们然后对 d 数组进行排序，因为这会使时间复杂度大于 Big-O(N)。

这是我到目前为止所得到的。遇到索引超出范围异常的问题：

public static void main(String[] args) {
    // Sort these 3 arrays. The final array should be d = {1,1,2,3,4,5}
    int[] a = {1,3};
    int[] b = {2,4};
    int[] c = {1,5};
    int[] d = new int[a.length + b.length + c.length];

    int i = 0;
    int j = 0;
    int k = 0;
    int l = 0;

    for (int iteration = 0; iteration <= d.length; iteration++){
        if ((i != a.length || j != b.length) && a[i] < b[j]){
            if (a[i] < c[k]){
                // then a[i] is smallest
                d[l] = a[i];
                i++;
                l++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
            else if (a[i] > c[k]){
                // then c[k] is smallest
                d[l] = c[k];
                k++;
                l++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
            else if (a[i] == c[k]){
                d[l] = a[i];
                i++;
                l++;
                d[l] = c[k];
                k++;
                l++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
        }
        else if(b[j] < a[i]){
            if (b[j] < c[k]){
                // b[j] is smallest
                d[l] = b[j];
                l++;
                j++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
            else if (b[j] > c[k]){
                // c[k] is smallest
                d[l] = c[k];
                l++;
                k++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
            else if (b[j] == c[k]){
                d[l] = b[j];
                j++;
                l++;
                d[l] = c[k];
                k++;
                l++;
                displayArrayContents(a,b,c,d,i,j,k,l);
            }
        }
    }
}

Answer 1

假设这是 java，数组名称是对数组的引用，可以像 C / C++ 中的指针一样交换。这可以用来减少主合并循环中的条件数，使代码更简单一些，但代价是交换。空数组检查在主合并循环之前完成。此方法可以轻松扩展以处理 4 路或更多路合并，否则需要大量条件。

static int[] Merge(int[] a, int[] b, int[] c)
{
    int[] d = new int[a.length + b.length + c.length];
    int[] e;   // temp used for swap
    int i = 0;
    int j = 0;
    int k = 0;
    int l = 0;
    int t;
    // empty array checks
    if(0 == b.length){      // if b empty
        if(0 == c.length){  // if b and c empty
            c = a;          //   c = a
            a = b;          //   a = b = empty
        } else {            // if b empty, c not empty
            e = a;          //   swap a and b
            a = b;
            b = e;
        }
    } else {                // else b not empty
        if(0 == c.length){  // if c empty
            e = c;
            c = b;          //   shift c = b, b = a
            b = a;
            a = e;          //   a = empty
        }
    }
    // main merge loop
    while(i < a.length){    // 3 way merge
        if(a[i] > b[j]){    // if b smaller swap
            e = a;
            a = b;
            b = e;
            t = i;
            i = j;
            j = t;
        }
        if(a[i] > c[k]){    // if c smaller swap
            e = a;
            a = c;
            c = e;
            t = i;
            i = k;
            k = t;
        }
        d[l++] = a[i++];
    }
    while(j < b.length){    // 2 way merge
        if(b[j] > c[k]){    // if c smaller swap
            e = b;
            b = c;
            c = e;
            t = j;
            j = k;
            k = t;
        }
        d[l++] = b[j++];
    }
    while(k < c.length)     // copy rest of c
        d[l++] = c[k++];
    return d;
}

Answer 2

你的想法是正确的，代表了一个O(n)的解决方案。但是，你的代码确实存在一些问题，其中一些会导致越界异常：

• 您访问c[k]，而没有首先确保k < c.length；
• 即使您在length 上进行 测试，也不会避免这种无效访问：(i != a.length || j != b.length) && a[i] < b[j] 仍将导致a[i] 在i === a.length 时被访问（尤其是j != b.length时）；
• 外部循环需要迭代的次数通常是错误的，因为有时（在相等的情况下）您将两个值存储在目标数组中，这使得数组填满的速度比循环预期的要快。事实上，相等的情况（如a[i] == c[k]）并不真正需要单独处理。如果你把它和>（所以：>=）一起处理，算法仍然是正确的：那么第二个（相等的）值将在下一次迭代中被复制；
• 即使您修复了上一个问题，您的外部循环仍然会使一次迭代过多； for 条件应该是 < d.length 而不是 <= d.length

没有问题，但你的代码中有很多重复：

• 您可以将调用移至 displayArrayContents(a,b,c,d,i,j,k,l); 的 if 构造之外，因此它始终会被执行，这正是您真正想要的；
• 由于您总是在if 构造中分配给d，因此您可以使用三元运算符? ... : 将该分配放在“if 之外”；
• 尽管像i != a.length 这样的测试可以达到预期的目的，但是像这样测试：i < a.length 是一种很好的做法。

这是考虑到上述内容的代码：

import java.util.Arrays; // for easy output of arrays with Arrays.toString().

class Main {
  public static void main(String[] args) {
    // Sort these 3 arrays. The final array should be d = {1,1,2,3,4,5}
    int[] a = {1,3};
    int[] b = {2,4};
    int[] c = {1,5};
    int[] d = new int[a.length + b.length + c.length];

    int i = 0;
    int j = 0;
    int k = 0;
    for (int l = 0; l < d.length; l++) {
      d[l] = i < a.length && (j >= b.length || a[i] < b[j])
                ? (k >= c.length || a[i] < c[k]
                    ? a[i++]
                    : c[k++])
                : (j < b.length && (k >= c.length || b[j] < c[k])
                    ? b[j++]
                    : c[k++]);
       // Uncomment this if you still need it:
       //displayArrayContents(a,b,c,d,i,j,k,l); 
    }

    System.out.println(Arrays.toString(d));
  }
}

最后一条语句的输出：

[1, 1, 2, 3, 4, 5]

查看它在repl.it 上运行。

Answer 3

按照以下步骤操作：

• 从这里获取答案代码：How to merge two sorted arrays into a sorted array?
• 在a 和b 上调用该函数，得到结果数组ab
• 在ab 和c 上调用该函数，得到你的结果abc
• 您已经调用了两次O(n) 函数，所以它仍然是O(n)。轰隆隆。

事实上，摆弄数组索引是令人沮丧的。如果你可以将这些数组作为队列或迭代器来代替，只需take() 或next() 每次迭代中的最小值并将其放入结果列表中，它会干净很多。

Answer 4

您需要清楚 N 会发生什么变化。如果您总是只有三个数组，并且它们的大小或最大大小会随着 N 而变化，那么几乎所有重复选择三个数组中任意一个可用的最小数字的代码，删除它，并将其附加到结果数组的末尾，将是 O(N)。您选择最小数字的代码可能既笨拙又昂贵，但它只是一个常数因子，不会随着 N 的增加而改变。

如果要合并的数组数量随着 N 的增加而增加，那么您需要更加小心如何选择可用的最小数字，最终您会遇到排序问题，这是您无法在线性时间内完成的通常的假设。

通常，外部排序将使用堆（例如http://www.geeksforgeeks.org/external-sorting/）合并磁盘上保存的大量列表。这对于一次合并大量列表会更有效，但只会为您获得一个常数因子，