Question

这个算法的时间复杂度是多少：

public int[] createTargetArray(int[] nums, int[] index) {
    int[] target = new int[nums.length];
    int i = 0, k = 0;
    while (i < index.length) {
        for (k = target.length - 1; k > index[i]; k--)
            target[k] = target[k - 1];
        target[index[i]] = nums[i];
        i++;
    }
    return target;
}

我已经提供了输入/输出以及下面的解释。

Input: nums = [0,1,2,3,4], index = [0,1,2,2,1]
Constraint: nums.length == index.length
Output: [0,4,1,3,2]
Explanation:
nums       index     target
0            0        [0]
1            1        [0,1]
2            2        [0,1,2]
3            2        [0,1,3,2]
4            1        [0,4,1,3,2]

根据我的理解，while 循环需要 O(n) 时间，内部 for 循环也需要 O(n)。此解决方案的时间复杂度是 O(n^2) 吗？如果我错了，请纠正我。

Answer 1

是的，时间复杂度为 O(n^2) 外部 while 循环正在执行 n 步骤，这很清楚，内部 for 循环依赖于 index[] 数组的项。假设所有项目都在 0 中，那么内循环将始终运行 n-1 步，因此时间复杂度为 n*(n-1)，即 n*n，因为我们正在考虑大O 符号，因此 O(n^2)

Answer 2

TL;DR 更准确地说，如果我们假设 m = n，则复杂度为 O(n * m), O(n^2)；

<块引用>

根据我的理解，while 循环需要 O(n) 时间，而内部 for 循环也需要 O(n)。是这个的时间复杂度吗解 O(n^2)？

首先让我们重新编写您的代码：

public int[] createTargetArray(int[] nums, int[] index) {
    int[] target = new int[nums.length];
    for (int i = 0; i < index.length; i++) {
        for (int k = target.length - 1; k > index[i]; k--)
            target[k] = target[k - 1];
        target[index[i]] = nums[i];
    }
    return target;
}

第一个循环从 i = 0 迭代到 index.length，在最坏的情况下（ie, index[i] 为零）从 {{1} 开始的第二个循环迭代}} 直到 k = target.length - 1。因此，从 k = 1 数组中的元素数 n 和 index 数组中的元素数 m 开始。该算法的时间复杂度为 num。

如果假设 O(n * m) 那么可以说 m = n。

按给定顺序创建目标数组的算法的时间复杂度

2 个答案: