Question

所以，我发现了一个有趣的问题，你得到2个排序数组，你的任务是将它们组合成一个新数组并保持排序。此外，找到您的程序的效率。我让我的代码工作，但我不确定效率..我认为它是O（n），因为我使用while循环迭代遍历数组的每个元素。有小费吗？有没有办法让这个更有效率？ O（n）是否正确？这是代码：

class mergesorted{
    static void Main(string[] args){
        int[] x = { 1, 3, 7};
        int[] y = { 2, 4, 5, 6, 15};
        int[] retrieval =  answer(x, y);

        for (int i = 0; i < retrieval.Length; i++){
            Console.WriteLine(retrieval[i]);                
        }
        Console.ReadLine();
    }

    public static int[] answer(int[] x, int[] y)
    {
        int[] a = x;
        int[] b = y;
        int abc = 0; //counter for a
        int abc2 = 0; //counter for b
        int i = 0; //counter for index of new array
        Boolean flagA = true; //if flag changed, array is exhaused
        Boolean flagB = true;
        int[] newarray = new int[a.Length+b.Length]; //so size is 7

        while (abc < a.Length && abc2 < b.Length){
            if (a[abc] < b[abc2]){
                newarray[i] = a[abc];
                abc++;
            }
            else{
                newarray[i] = b[abc2];
                abc2++;
            }

            if (abc >= a.Length){
                flagA = true;
                flagB = false;
            }

            else if (abc2 >= b.Length){
                flagA = false;
                flagB = true;
            }
            i++;
        }

        if (flagA == false){
            while (abc < a.Length){
                newarray[i] = a[abc];
                abc++;
                i++;
            }
        }
        else if (flagB == false){
            while (abc2 < b.Length){
                newarray[i] = b[abc2];
                abc2++;
                i++;
            }
        }
        return (newarray);
    }
}

Answer 1

你有很多冗余测试。但是你的算法是O（N），因为它只触及每个元素一次。你不能做得更好（在一般情况下），因为构建最终数组是O（N）。

在一个数组比另一个数组大得多并且你有一个O（1）插入（或移动）操作的特殊情况下，你可以制作一个O（A log B）的算法，其中A是数字较小列表中的条目和B是较大列表中的条目数。例如，如果一个数组有1,000,000个对象而另一个只有2个，则可以使用二进制搜索来确定在1,000,000个对象列表中移动另一个列表中的每个对象的位置。如果这两个列表大小相同，则无济于事。

合并2个数组，保持排序，并找到效率

1 个答案: