如何从两个排序数组的备用元素生成所有可能的排序数组？答案

【问题标题】：How can I generate all possible sorted arrays from alternate elements of two sorted arrays?如何从两个排序数组的备用元素生成所有可能的排序数组？
【发布时间】：2015-07-08 18:04:18
【问题描述】：

我最近在一次采访中遇到了这个问题。我真的无法想出这个问题的答案。我开始，从第一个数组中取出第一个元素，然后在另一个数组中找出有多少元素大于这个元素。但是，我的意思是，我不知道，无法真正形成解决方案。问题如下：

给定两个已排序的数组 A 和 B，生成所有可能的数组，使得第一个元素从 A 中取出，然后从 B 中取出，然后从 A 中取出，依此类推，直到数组用完为止。生成的数组应以 B 中的元素结尾。

Eg:
A = {10, 15, 25}
B = {1, 5, 20, 30}

The resulting arrays are:
  10 20
  10 20 25 30
  10 30
  15 20
  15 20 25 30
  15 30
  25 30

我不是在寻找代码，只要一个算法/伪代码就可以了。谢谢！

【问题讨论】：

事后请务必让面试官为您提供建议的答题纸。
建议的答题纸是什么？ ://
他们认为您的答案应该解决的问题。很多时候，人们甚至无法解决他们提出的问题。
哦！对。从下一次开始，我一定会记住这一点。不错的提示。谢谢！但是，既然我现在只是一个初学者，这不会让面试官觉得很反感吗？他/她不能只说，只回答提出的问题。只是问问。
@john 所以第一个数字应该总是来自第一个数组？

标签： arrays algorithm sorting

【解决方案1】：

如何使用带有 BFS 路径搜索的有向图。

创建一个directed graph，其中如果B 中的元素更大，则从数组A 中的一个元素到数组B 中的每个元素创建有向边。反之亦然。如果 A 中的元素更大，则从数组 B 中的元素到数组 A 中的每个元素创建一条有向边。
从 A 中选择一个元素
然后使用BFS 搜索来生成所有可能的路径。
每当路径包含来自 B 的元素时，将该子路径添加到您的解决方案路径列表中
当 A 的所有元素都被用作搜索键时停止

更新

根据@MiljenMikic 的建议，您可以通过加快步骤 1 来利用数组排序这一事实。您不必搜索另一个数组中的所有元素来查找大于元素。只需跟踪最后找到的并在搜索时将指针向前移动。

【讨论】：

【解决方案2】：

@dpmcmlxxvi 提出的 BFS 解决方案很有趣。另外，我建议使用递归变体。一些基本点：

您的递归函数的输入参数之一应该是一个布尔变量，它将指示您应该从 A 中添加元素还是从 B 中添加元素；您将在随后的递归调用中交替使用此值
数组已排序 - 使用该信息！当您看到已排序的数组时，请始终考虑 二分查找 - 在这种情况下，您应该递归传递最后添加的元素，然后在另一个数组中，二分查找大于最后一个元素的第一个元素
如果最后添加的元素来自 B，则将当前工作数组添加到结果列表中

【讨论】：

这个解决方案的时间复杂度是多少？ O(n*m) 其中 n & m 是两个数组的长度？
@YeshwanthVenkatesh 实际上，在最坏的情况下，当元素交替时（即每个索引的 A[i]

【解决方案3】：

一个递归的简单的基于java的解决方案可以是这样的

public static void main(String[] args) {

    int[] A = {10, 15, 25};
    int[] B = {1, 5, 20, 30};

    Stack<Integer> st = new Stack<>();

    for (int i = 0; i < A.length; i++) {
        st.push(A[i]);
        generateArrays(A, B, i, 0, st, false);
        st.clear();
    }
}

static void generateArrays(int ar1[], int ar2[], int index_of_a, int index_of_b, Stack<Integer> st, boolean first) {
    if (index_of_a >= ar1.length || index_of_b >= ar2.length) {
        st.pop();
        return;
    }

    // take from second if available
    if (!first) {
        for (int j = index_of_b; j < ar2.length; j++) {
            if (ar1[index_of_a] < ar2[j]) {
                st.push(ar2[j]);
                System.out.println(st);
                generateArrays(ar1, ar2, index_of_a + 1, j, st, true);
            }
        }
    }

    // take from first if available
    else if (first) {
        for (int i = index_of_a; i < ar1.length; i++) {
            if (ar1[i] > ar2[index_of_b]) {
                st.push(ar1[i]);
                generateArrays(ar1, ar2, i, index_of_a + 1, st, false);
            }
        }
    }

    st.pop();
}

【讨论】：

【解决方案4】：

抱歉，我写算法有点懒，但你可以从代码中驱动它。下面是我的解决方案，你可以使用它

void Generate_all_possible_sorted_arrays_from_two_sorted_arrays(int[] a1,int[] a2){
    int[] array3=new int[a1.length+a2.length];// max length
    int flag=-1;
    for(int i=0;i<a1.length;i++){
        for(int j=0;j<a2.length;j++){
            if(a1[i]<a2[j]){
                System.out.println(a1[i]+" "+a2[j]);
                flag+=2;
                array3[flag-1]=a1[i];
                array3[flag]=a2[j];
                int k=i+1,l=j+1;
                findWave:for(;k<a1.length;k++){
                    if(a1[k]>array3[flag]){
                        for(;l<a2.length;l++){
                            if(a2[l]>a1[k]){
                                flag+=2;
                                array3[flag-1]=a1[k];
                                array3[flag]=a2[l];
                                for(int element=0;element<=flag;element++){
                                    System.out.print(array3[element]+" ");
                                }
                                System.out.println();
                             continue findWave;
                            }
                        }
                    }
                }
            flag=-1;
            }
        }
    }
    }

【讨论】：