如何确定以下算法的时间复杂度？

问题描述

明天我有一个期中考试，很难理解以下时间复杂性问题。

1。

Algorithm foo(n)
     i←0
     j←0
     while i<n do {
         if j=i then j←j+1
         else if j=2i then i←n−j
         else {
             i←i+1
             j←j+1
         }
     }

哪个是O（1）

2。

Algorithm foo(n)
     i←0
     j←0
     while i<n do {
         if i=k then {
             A[i]←k
             k←k+1
             i←1
         }
     }
     else i←i+1

哪个是O（n ^ 2）

因此，基本上，我一直在解决这些类型的问题的方法是找到算法中执行恒定数量操作的部分。对于算法1，这将是变量以及循环中的内容：

C1：

i←0
j←0

C2：

if j=i then j←j+1
         else if j=2i then i←n−j
         else {
             i←i+1
             j←j+1

然后，我计算循环的迭代次数n，并将其添加到公式中：

f（n）= C1 + nC2是O（n）（错误的答案）

我可以说，我的问题是我在错误计算这两个循环的迭代次数。如果有人让我知道我的思维过程是否完全错误和/或我应该如何计算循环迭代次数，将不胜感激。

解决方法

您是否实现了算法，只是看发生了什么？您应该，如果还没有的话。

示例1

def bigo_one(n):
    print(f"n == {n}")
    i = 0
    j = 0
    while i<n:
        if j==i:
            j = j + 1
        elif j == 2 * i:
            i = n - j
        else:
            i = i + 1
            j = j + 1
        print(i,j)

bigo_one(10)
bigo_one(100)
bigo_one(1000)

输出：

n == 10
0 1
1 2
8 2
9 3
10 4
n == 100
0 1
1 2
98 2
99 3
100 4
n == 1000
0 1
1 2
998 2
999 3
1000 4

从输出中很容易看到总是发生什么，而与n无关：

1. j增加到2
2. 我跳到n-2
3. i增加到n

总是5步-> O（1）

示例2

def bigo_nsquare(n):
    print(f"n == {n}")
    i = 0
    j = 0
    while i<n:
        if j==i:
            j = j + 1
            i = 1
        else:
            i = i + 1
        print(i,j)
        
bigo_nsquare(2)
bigo_nsquare(4)
bigo_nsquare(10)

输出：

n == 2
1 1
1 2
2 2
n == 4
1 1
1 2
2 2
1 3
2 3
3 3
1 4
2 4
3 4
4 4
n == 10
1 1
1 2
2 2
1 3
2 3
[...]

此循环逐步遍历方矩阵的下三角，因此它具有O（n²）复杂度是可能的。