Algorithm 大O估计|得到函数

我在理解如何估计大O时遇到了困难。关于这个问题，我们已经上过两次课，我唯一理解的是从函数中最大的多项式中取前导系数，并用一个O替换它，使它看起来像O（…）

在第一次演讲中，这一点被展示了出来

int i = length;
while (i>0) {
    i--;
    int j = i -1;
    while (j >= 0) {
        if (a[i] == a[j]) {
            return 1;
        }
        j--;
    }
}
return 0;

然后在下面的幻灯片上显示此选项

int i = length;                 // Counts as 1
while (i>0) {                   // Counts as N+1
    i--;                        // Counts as N
    int j = i -1;               // Coutns as N
    while (j >= 0) {            // Counts as i+1
        if (a[i] == a[j]) {     // Counts as i
            return 1;
        }
        j--;                    // Counts as i
    }
}
return 0;                       // Counts as 1

从这里，我想知道为什么

return 1;

不算作一步

在那张幻灯片之后，它告诉我们

外循环计数为3N+1 内环计数为3i+1；对于从0到N-1的所有可能i

我知道第二个[while]循环将出现N次，然后[if]将出现I次，其中I等于N-1，因为如果j<0，第二个while循环仍将被读取，但之后不会发生任何其他情况

幻灯片显示，来自内环的总数等于 3N^2-1/2N

总和等于3/2N^2+5/2N+3

---

想知道是否有人有时间教我如何获得像上面例子中那样的大O估计中使用的函数；我不知道3i+1是如何转化为3N^2-1/2N的，也不知道总计是如何计算的。

我将尝试解释您示例复杂性的计算

首先我们注意到，每个操作只需要恒定的时间，写为

O（1）

，这意味着运行时间不依赖于输入

int i = length;                 // O(1), executed only one time
while (i > 0) {                 // outer loop, condition needs O(1)
    i--;                        // O(1)
    int j = i - 1;              // O(1)
    while (j >= 0) {            // inner loop, condition needs O(1)
        if (a[i] == a[j]) {     // O(1)
            return 1;           // first return statement
        }
        j--;                    // O(1)
    }
}
return 0;                       // second return statement, executed only one time

每个循环中的操作数是恒定的，因此我们只需计算它们执行的频率

外部循环从

i=n

运行到

i=1

。对于每个

i

内部循环执行一次，并执行

i

恒定时间操作本身。我们总共得到

3 + Σ_i=0,...,n-13 + 3i + 1 = 3 + 4n + 3/2⋅(n-1)⋅n = 3/2⋅n² + 5/2⋅n + 3 (1) (2) (3) (4) (5) 3+∑i=0，…，n-13+3i+1=3+4n+3/2⋅（n-1）⋅n=3/2⋅n²+5/2⋅n+3 (1) (2) (3) (4) (5) 说明：

3包含第一行、最后一行和外部循环条件的附加执行。该条件的计算结果为

n

次为

true

，一次为

false

此

3

包含对外环和外环前两行条件的一次评估

i

前面的因子

3

包含一个对内循环条件的评估、对if语句的评估和内循环的最后一行

1

用于附加计算，其中内部循环条件的计算结果为

false

计算结果为

1/2⋅N⋅（n+1）

。注意这里的总和是从

0

到

n-1

，因此它的计算结果是

1/2⋅（n-1）⋅n

第一（内部）return语句不计算在内，因为如果执行，算法将终止。但我们要计算最大步数，即所谓的最坏情况。这种情况是算法尽可能晚地终止

注意：步骤的计算非常精确。这对于获得big-O复杂性是不必要的。可以这样说，每个循环都在O（n）中运行，而且由于它们是嵌套的，因此复杂性必须成倍增加，因此得到

O（n）⋅O（n）=O（n²）