Question

I need help with the following problems on determining what the Big O is of each function.

For problem one, I've tried O(log(n)) and O(n). I figured the function was linear or in other words, for N elements we will require N iterations.

For problem two, I've tried O(n^2). I figured for this kind of order, the worst case time (iterations) is the square of the number of inputs. The time grows exponentially related to the number of inputs.

For problem three, I've tried O(n^2) and O(1).

Problem One:

function foo(array){
  let sum = 0;
  let product = 1;
  for (let i = 0; i < array.length; i++){
    sum += array[i]
  }
  for(let i = 0; i < array.length; i++){
    product *= array[i];
  }

  consle.log(sum + ", " + product);
}

Problem Two:

function printUnorderedParis(array){
  for(let i = 0; i < array.length; i++){
    for(let j = i + j; j < array.length; j++){
      console.log(array[i] + ", " + array[j]);
    }
  }
}

Problem Three:

function printUnorderedPairs(arrayA, arrayB){
  for(let i = 0; i < arrayA.length; i++){
    for(let j = 0; i < arrayB.length; j++){
      for(let k = 0; k < 100000; k++){
        console.log(arrayA[i] + ", " + arrayB[j]);
      }
    }
  }
}

I expected my initial thoughts to be right, but maybe I'm having a hard time grasping Big O.

Answer 1

您正确的是它是1000。您有两个循环，每个循环执行O(n)个迭代。您甚至可以将它们组合成一个循环，使其更加明显。
```
array.length
```
您是正确的，它是for (let i = 0; i < array.length; i++) { sum += array[i]; product *= array[i]; }。嵌套循环执行O(n^2)个迭代。
编辑-请参阅上面的我的评论，询问是否正确复制了此问题。
这也是array.length * array.length。嵌套循环的第三级不会改变复杂性，因为它执行固定数量的迭代。由于这不取决于输入的大小，因此将其视为常量。就Big-O而言，这相当于问题2。

Answer 2

好吧，您已经回答了您的问题，但是我们开始：

在第一个问题中，您有两个for循环，每个循环遍历整个数组。对于大小为n的常规数组，您将拥有O(2n)或仅拥有O(n)，因为我们可以放开常量。没有任何理由将其设为O(log(n))。
对于第二个，我认为有一个错误。语句j = i + j无效，您将得到Uncaught ReferenceError: j is not defined。但是，假设该语句实际上是let j = i。然后，我们有：
- i，遍历整个数组，从第一个元素开始，一直到最后一个元素
- j，从i开始一直到最后一个元素

有了这些信息，我们知道对于i = 0，j将从0迭代到n（n是数组的长度），所以n步。对于i=1，j将从1变为n，因此n-1步骤。概括地说，我们将得到一个总和：n + (n - 1) + (n - 2) + ... + 1 + 0 = n * (n + 1) / 2 = 1/2 * (n^2 + n)。因此，复杂度为O(1/2 * (n^2 + n) = O(n^2 + n) = O(n)。所以你是对的。

对于第三个问题，答案是O（n ^ 2）而不是O（1）。推理与我为第二个推理所做的非常接近。基本上，内部k将为每个j迭代执行100000次，但是迭代次数不取决于n（数组的大小）。

很容易看到：

对于i = 0，j将从0变为n（将为其执行j主体的最后一个值为j = n - 1）。
- 对于j = 0，我们将进行10万次迭代
- 对于j = 1，又进行了10万次迭代
- ...
- 对于j = n - 1，又进行了10万次迭代

整个j循环将进行n * 100000 = 100000n个迭代。

对于i = 1，相同的行为：
- 对于j = 0，我们将进行10万次迭代
- 对于j = 1，又进行了10万次迭代
- ...
- 对于j = n - 1，又进行了10万次迭代，

再获得100000n个迭代。

最后，我们以100000n + 100000n + ... + 100000n (n times) = sum(i = 0, n, 100000n) = n * 100000n = 100000 * n^2结尾。因此，大O为O(100000 * n^2) = O(n^2)。

干杯！

What is the Big O for the following functions:

2 个答案: