Question

void smiley (int n) { 

 for (int i = 0; i < n * n; ++i) { 
    for (int k = 0; k < i; ++k) 
      System.out.println(”k = ” + k); 
    for (int j = n; j > 0; j--) 
      System.out.println(”j = ” + j); 
   } 
}

如您所见，有两个内环和一个外环。运行时间为n^4。我得到n * n使其n^2，但两个内部循环如何使总运行时间n^4？

PS

此处有一个类似的案例，其运行时间为n^2。我也不明白。它有三个循环吗？

void smiley (int n, int sum) { 
 for (int i = 0; i < n * 100; ++i) { 
    for (int j = n; j > 0; j--) 
       sum++; 
    for (int k = 0; k < i; ++k) 
       sum++; 
    } 
}

Answer 1

在第一个示例中，第一个内部循环受i限制，n^2本身受n^4限制。我怀疑这可能是你正在寻找的{{1}}。

Answer 2

这里发生的是N（N + N）= 2N ^ 2。所以代码大约为2N ^ 2。三个嵌套循环将给出N ^ 3运行时间N（N（N））。

Answer 3

对于第一个，你正在迭代(int i = 0; i < n * n; ++i)，所以基本上n^2，没关系 - 你知道的。在该循环中，您正在迭代(int k = 0; k < i; ++k) ...最终，i此处将升至n*n（n^2）。因此，您的算法复杂度已经为O(n^4)：

overall complexity =
    outer loop complexity: n^2
    *
    (
        1st inner loop complexity: up to n^2
        +
        2nd inner loop complexity: n
    )

你不关心这里的第二个内部循环，因为与第一个循环添加的操作相比，它只增加了一小部分操作（n^2 + n仍大致等于n^2 ，从算法复杂性的角度来看）。

关于你的第二段代码：

overall complexity =
    outer loop complexity: n
    *
    (
        1st inner loop complexity: n
        +
        2nd inner loop complexity: up to n
    )

哪个是O(n^2)。

Answer 4

运行时间不是循环结构数量的函数，而是代码循环次数的函数。因此，如果循环执行100次并且它包含执行100次的内循环，则内循环执行10,000次。

对于第一种情况，外环为O（n ^ 2），第一内环为O（n ^ 2 * n ^ 2），第二内环为O（n ^ 2 * n），因此总顺序为O（n ^ 2 + n ^ 4 + n ^ 3），减少为O（n ^ 4）。

对于第二种情况，外环为O（n），第一内环为O（n * n），第二内环为O（n * n），因此总顺序为O（n + n ^ 2 + n ^ 2），减少到O（n ^ 2）。

Answer 5

void smiley (int n) { 

 for (int i = 0; i < n * n; ++i) { 
    for (int k = 0; k < i; ++k) 
      System.out.println(”k = ” + k); 
    for (int j = n; j > 0; j--) 
      System.out.println(”j = ” + j); 
   } 
}

对于i我们将得到0~n ^ 2并且对于每个值i，我们也得到从0到i的k循环，并且j从n到0 我们会得到

∑_(i=0)^(n^2)* (∑_(j=0)^(i^2)+ ∑_(k=0)^n)  ≅ ∑_(i=0)^(n^2)* (∑_(j=0)^(i^2))  ≅∑_(i=0)^(n^2)* (∑_(j=0)^(n^2))  ≅ n^4

这个：

void smiley (int n, int sum) { 
 for (int i = 0; i < n * 100; ++i) { 
    for (int j = n; j > 0; j--) 
       sum++; 
    for (int k = 0; k < i; ++k) 
       sum++; 
    } 
}

我们将得到n *（n + n）= 2 * n ^ 2~ = n ^ 2，这意味着我们只是用caluate：loop in loop我们使用乘法;循环循环我们使用添加;忽略不变的部分。

也许你可以看一下：http://en.wikipedia.org/wiki/Time_complexity

Answer 6

重构这样的循环：

void smiley (int n) { 

 for (int i = 0; i < n * n; i++) { 
    for (int k = i+1; k < n*n; k++); 
    for (int j = 0; j < n; j++); 
   } 
}

外环运行N2次。对于外环的每个循环，第一内环运行N2-i。 i = 0，k循环N2-0; i = 1，k循环N2-1; ......; i = N2-1，k循环0次。

所花费的时间是 N2-0 + N2-1 + ... + 0 = N2 *（0 + N2）/ 2 = N4 / 2

第二个内循环更简单：j不依赖于i。对于每个i循环，我循环N2次并且j循环N次。

第二个内循环花费的时间是 N2 * N = N3

作为输入大小函数的运行时间 T（N）= N4 / 2 + N3

但渐近时间为N4，删除任何常数和低功率变量。

两个内部嵌套循环运行时

6 个答案: