Question

int a = 0;  //1 unit
for (int b = 0; b < N; b++) // (1 + N + N) = 2n + 1
    for (int c = b+2; c > 0; c--) //2 + (N+1) + N = 2N+3
        a += b*c; //3 units

收益率：1 + (2n+1)(2n+3) = 4n^2+8n+4

我是算法分析的新手，我不是100％确定这是正确的。任何人都可以帮助我，如果我这样做的话，让我知道吗？如果没有，请指出我出错的地方。

我差不多将最差情况下的运行时间计算为4n^2+8n+4

Answer 1

对于外循环中的每个b值，内循环执行b + 2次。因此内循环执行的总次数等于（2 + 3 + 4 + .... +（N + 2））。每次执行3个单位的工作。所以内循环执行的总时间是[（（N + 2）（N + 3）/ 2） - 1] * 3.

但通常我们会渐近地测量运行时间，这就是Big O（N ^ 2）

Answer 2

通常，使用big O Notation时，系数会被忽略，算法会按其增长最快的函数进行分类。在这种情况下，您有两个O(n)循环，它们是嵌套的。嵌套是乘法的，给出算法O(n²)又称“二次”复杂度。关于big O notation和computational complexity的维基百科文章可能会为您提供进一步阅读的起点。

Answer 3

如果你想说内循环中的语句需要3个单位，那么内循环需要（b + 2）* 3个单位。现在，如果我们让b的范围从0到N - 1并求和，我们得到

（0 + 2）* 3 +（1 + 2）* 3 +（2 + 2）* 3 + ... +（2 + N - 1）* 3

= 3 *（2 + 3 + 4 + 5 + ... +（N + 1））

= 3 *（（1 + 2 + ... + N + 1） - 1）

= 3 *（（（N +1）（N + 2）/ 2）-1）

= 3 *（N ^ 2 + 3 * N + 2 - 2）/ 2

= 3/2 * N ^ 2 + 9/2 * N

请注意，我没有将循环标头中执行的操作计为操作，通常不会这样做。实际上，通常只计算执行次数最多的最昂贵的操作（在这种情况下是乘法）。

顺便说一句，我使用了前n个整数之和为n（n + 1）/ 2

的事实

Answer 4

让我们考虑一下你的代码，

for (int b = 0; b < N; b++)
    for (int c = b+2; c > 0; c--) 
        a += b*c;

外循环执行N次，对于外循环的每次迭代，内循环执行b+2次。

因此，a += b*c;语句共执行2 + 3 + 4 + ... + N+2次。

因此，指令总共执行([1 + 2 + 3 + ... + N+2] - 1)次。

它等于[(N+2)(N+3)]/2-1，因为前N个整数的总和是N(N+1)/2。

给定代码片段的复杂性是Θ（（（N ² + 5N + 6）/ 2） - 1）这只是Θ（N ²）

Answer 5

你的例子：

int a = 0;  // 1

for (int b = 0; b < N; b++) // 1 + (N+1) + N
{
    for (int c = b+2; c > 0; c--) // 1 + (((N+2)*(N+3)/2)+1) + ..) * N
    {
        a += b*c; // 3 * ((N+2)*(N+3)/2) * N
    }
}

我们得到的数学：

= 1 + 1 + (N+1) + N + 1 + [(((N+2)*(N+3)/2)+1) + ((N+2)*(N+3)/2)) * N] + [3 * ((N+2)*(N+3)/2) * N]

= 4 + 2 N + 1/2 N^3 + 3 N^2 + 11/2 N + 4 + 9 N + 15/2 N^2 + 3/2 N^3

= 8 + 33/2 N + 21/2 N^2 + 2 N^3

给我们O(N^3)

这段代码的最坏情况分析是否正确？

5 个答案: