0 时间复杂度

快：时间复杂度
省：空间复杂度

1. 时间复杂度分析

1.1 实例1

def get_sum(n):
    result = 0
    for i in range(1,n+1):
        result += i
    return result

假设每行代码对应的cpu执行时间一样，为一个时间单位unit_time
可以看到该函数第2、5行执行1次，第3、4行执行n次
总共执行时间为：
T(n)=2 * unit_time+2 * n * unit_time=(2+2n) * unit_time

1.2 实例2

def print_matrix(n):
    for i in range(n):
        for j in range(n):
            print("*",end="")
        print()

假设每行代码对应的cpu执行时间一样，为一个时间单位unit_time
可以看到该函数第2、5行执行n次，第3、4行执行n*n次
总共执行时间为：
T(n)=2 * n * unit_time+2 * n² * unit_time=(2n+2n²) * unit_time

1.3 总结

通过以上两个实例可知，代码的执行时间与执行次数n程正比
我们将这个规律总结成公式
T(n) = O(f(n))
T(n)：代码的总执行时间
n：数据规模
f(n)：每行代码执行的次数总和
O：表示T(n)与f(n)成正比关系

大O时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度，简称时间复杂度。
当n很大时，公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。
我们只需要记录一个最大量级就可以，如果用大O表示法表示上述两实例的时间复杂度，就可以记为：
实例一：T(n) = O(n)
实例二：T(n) = O(n²)
注意：即便某一行代码循环执行1000次、10000次，只要是一个已知的数，跟n无关，照样也是常量级的执行时间。当n无限大的时候，就可以忽略。

1.4 实战

1. 总复杂度等于量级最大的那段代码的复杂度

def getsum_and_printmatrix(n):
    result = 0
    #求和
    for i in range(1,n+1):
        result += i
    #打印矩阵   
    for i in range(n):
        for j in range(n):
            print("*",end="")
        print()    
    return result

求和的时间复杂度为O(n)
打印矩阵的时间复杂度为O(n²)
只关注影响最大的因子，所以这段代码的时间复杂度为O(n²)

2. 嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

def printmatrix(n):
    for i in range(n):
        for j in range(n):
            for k in range(n):
                print("*",end="")
            print()
        print()

乘积法则：关注执行次数最多的那段代码，因此这段代码的时间复杂度为O(n³)

2. 几种常见的时间复杂度分析

多项式量级：
常量阶O(1)
对数阶O(logn)
线性阶O(n)
线性对数阶O(nlogn)
平方阶O(n²) 立方阶O(n³) k次方阶O(n^k)
非多项式量级：
指数阶O(2ⁿ)
阶乘阶O(nⁿ)

2.1 非多项式量级

数据规模n越大，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法是非常低效的算法。

2.2 常量阶O(1)

O(1)只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如下面这段代码，即便是有5行，它的时间复杂度也是O(1)

print(1)
print(2)
print(3)
print(4)
print(5)

2.3 对数阶O(logn)

对数阶时间复杂度非常常见，但是难以分析

def getResult(n):
    i = 1
    while i<n:
        i = i*2

每次i乘以2后就距离n更近了一分。也就是说，有多少个2相乘后大于n，则会退出循环。2^i=n，i=logn，所以时间复杂度为O(logn)

2.4 线性对数阶O(nlogn)

def getResult(n):
    result = 0
    for i in range(1,n+1):        #O(n)
        while i<n:                     #O(logn)
            i = i*2
            print("i= ",i)
        result += i
        print("result= ",result)
    return result

2.5 O(m+n)

def calc(m,n):
    result1 = 0
    result2 = 0
    for i in range(m):
        result1 += i
    for j in range(n):
        result2 +=i
    
    return result1,result2

m,n表示两个数据规模。我们无法事先评估哪个量级大，所以时间复杂度为O(m+n)

2.6 O(m*n)

def calc(m,n):
   result = 0
   for i in range(m):
       temp = 0
       for j in range(n):
           temp += j
       result += temp
   
   return result

m,n表示两个数据规模。我们无法事先评估哪个量级大，所以时间复杂度为O(m*n)