python算法的时间复杂度怎么算 python in 复杂度

简介

在编写Python中的自定义函数或算法时，减低时间复杂度和空间复杂度，会大大提升Python自定义函数或算法的整体性能，提升性能的几个书写好习惯：

• 尽量不要写循环，最好是一次就输出结果
• 如果写循环，尽量写一层循环就能有结果
• 避免嵌套

时间复杂度

时间复杂度是用来估计自定义函数或算法运行时间的一个式子（单位）,时间复杂度常用“O”表述，而且时间复杂度可被称为是渐近的，它考察当输入值大小趋近 $\infin$

时间复杂度为 O(1)的例子

print('Hello!')
print(1)

时间复杂度为 O(n)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n)
for i in range(n): 
    print('Hello!')

时间复杂度为O(n^2)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^2)
for i in range(n):
    for j in range(n):
        print('Hello!')

for i in range(n): 
    print('Hello!')
    for j in range(n):
        print('Hello!')

for i in range(n): 
    for j in range(i):
        print('Hello!')

时间复杂度为O(n^3)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^3)
for i in range(n):
    for j in range(n):
        for k in range(n):
            print('Hello!')

由上述时间复杂度O(n)的变化可以得出这样的结论：O(n)中n的几次方取决于自定义函数或算法中存在几个循环。

时间复杂度为O(n^n)的例子

# 其中range(n) 换成range(length(n))或者直接换成n，其时间复杂度都为 O(n^n)
for i in range(n):
    for j in range(n):
        for k in range(n):
        	for l in range(n):
        	.
        	.
        	.
        		for o in range(n):
            		print('Hello!')

时间复杂度为O($log_2n$)的例子

n = 128
while n > 1:
    print(n)
    n = n // 2 # //表示整除法

计算上述问题的时间复杂度步骤：

1. $2^7 = 128$
2. $log_2128 = 7$
3. 循环减半的时间复杂度为O($log_2128$)，即O($log_n128$) = O(7)

复杂度为O($log_2n$)

n = n
while n > 1:
    print(n)
    n = n // 2 # //表示整除法

常见的时间复杂度高低排序：O(1)<O($log_n$)<O(n)<O($nlog_n$)<O($n^2$)<O($n^2log_n$)<O($n^3$)

空间复杂度

空间复杂度：用来评估自定义函数或算法内存占用大小

空间复杂度为 1的例子

p = 'Python'
l = 'like'
m = 'me'

空间复杂度为 n

p = [1,2,3,....,n]

空间复杂度为 n*n

p_n = [[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]]

空间复杂度为 n * n * n

p_n = [[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]],
[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]],
....,
[[1,2,3,....,n],[1,2,3,....,n],.....,[1,2,3,....,n]]

空间复杂度却决于：

• 变量的长度
• 变量的个数
• 变量的复杂程度

示例展示

自定义方差（variance）函数简化，以及计算其对应的时间复杂度和空间复杂度

def variance (*args): # *args不限定输入的可变量，这里输入的数量为n
    total = 0 #时间复杂度为 1；空间复杂度为 1
    average = float(sum(args))/len(args) 
    # 时间复杂度为 n+1 其中sum（args）为n，len(args)为 1
    # 空间复杂度为 1
    for val in args:
        total +=(val-average)**2
    # 时间复杂度为 n，即进行了n次循环
    # 空间复杂度为 n，即存储了n次total
    return total/len(args) # 时间复杂度为 1；空间复杂度为 1

时间复杂度：1+n+1+n+1 = 2n+1
空间复杂度：1+1+n+1 = n+3