转自https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/r84gmi/
本文针对原文简化了一些书写,并且加入了自己的理解。
算法复杂度旨在计算在输入数据量 N 的情况下,算法的「时间使用」和「空间使用」情况;体现算法运行使用的时间和空间随「数据大小 N 」而增大的速度。
算法复杂度主要可从 时间 、空间 两个角度评价:
「输入数据大小N」指算法处理的输入数据量;根据不同算法,具有不同定义,例如:
根据定义,时间复杂度指输入数据大小为 N 时,算法运行所需花费的时间。需要注意:
时间复杂度有最差、平均、最佳三种情况,符号分别为 O , Θ , Ω表示。
例子:为了找到数组中是否有7
def find_seven(nums):
for num in nums:
if num == 7:
return True
return False
大 O 是最常使用的时间复杂度评价渐进符号,下文示例与本 LeetBook 题目解析皆使用 O 。
根据从小到大排列,常见的算法时间复杂度主要有:
O ( 1 ) < O ( l o g N ) < O ( N ) < O ( N l o g N ) < O ( N 2 ) < O ( 2 N ) < O ( N ! ) O(1)
运行次数与 NN 大小呈常数关系,即不随输入数据大小 NN 的变化而变化。
def algorithm(N):
a = 1
b = 2
x = a * b + N
return 1
#或者
def algorithm(N):
count = 0
a = 10000
#循环与N无关
for i in range(a):
count += 1
return count
循环运行次数与 N 大小呈线性关系,时间复杂度为O(N) 。
def algorithm(N):
count = 0
for i in range(N):
count += 1
return count
#或者
def algorithm(N):
count = 0
a = 10000
for i in range(N):
#循环与N无关
for j in range(a):
count += 1
return count
两层循环相互独立,都与 N 呈线性关系,因此总体与 N 呈平方关系,时间复杂度为 O(N2) 。
def algorithm(N):
count = 0
for i in range(N):
for j in range(N):
count += 1
return count
#或者
#冒泡排序
def bubble_sort(nums):
N = len(nums)
#复杂度为O(N)
for i in range(N - 1):
#从n-1次到1次,平均循环次数为1,2,...,(n-1) = n/2,复杂度为O(N)
for j in range(N - 1 - i):
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
return nums
生物学科中的细胞分裂即是指数级增长。初始状态为1个细胞,分裂一轮后为2个,分裂两轮后为4个,…,分裂N轮后有2N个细胞。算法中,指数阶常出现于递归。
def algorithm(N):
if N <= 0: return 1
#计算1个-N 变成 计算2个-N-1
count_1 = algorithm(N - 1)
count_2 = algorithm(N - 1)
return count_1 + count_2
阶乘阶对应数学上常见的 “全排列” 。即给定 N 个互不重复的元素,求其所有可能的排列方案,则方案数量为:
N × ( N − 1 ) × ( N − 2 ) × ⋯ × 2 × 1 = N ! N×(N−1)×(N−2)×⋯×2×1=N! N×(N−1)×(N−2)×⋯×2×1=N!
阶乘常使用递归实现,算法原理:第一层分裂出 N 个,第二层分裂出 N−1 个,…,直至到第N层时终止并回溯。
def algorithm(N):
if N <= 0: return 1
count = 0
#N的时候,需要递归N次;N-1的时候,需要递归N-1次;...;1的时候,需要递归1次
#因此需要N*N-1*...*1 = N!
for _ in range(N):
count += algorithm(N - 1)
return count
对数阶与指数阶相反,指数阶为 “每轮分裂出两倍的情况” ,而对数阶是 “每轮排除一半的情况” 。对数阶常出现于「二分法」、「分治」等算法中,体现着 “一分为二” 或 “一分为多” 的算法思想。
设循环次数为m,则输入数据大小N与 2 m 2^m 2m呈线性关系,两边同时取 l o g 2 log_2 log2对数,则得到循环次数m与 l o g 2 N log_2 N log2N呈线性关系,则时间复杂度为 O ( l o g N ) O(logN) O(logN)。
def algorithm(N):
count = 0
i = N
while i > 1:
#每次都将范围缩小1/2
i = i / 2
count += 1
return count
#或
def algorithm(N):
count = 0
i = N
a = 3
while i > 1:
#每次都将范围缩小1/a
i = i / a
count += 1
return count
第2个的形式是m与 l o g a N log_a N logaN呈线性关系,时间复杂度为 O ( l o g a N ) = O ( l o g 2 N ) O ( l o g 2 a ) = O ( l o g N ) O(log_a N) = \frac{O(log_2 N)}{O(log_2 a)} = O(logN) O(logaN)=O(log2a)O(log2N)=O(logN)。
两层循环相互独立,第一层和第二层时间复杂度分别为O(logN)和O(N),则总体时间复杂度为O(N logN)
def algorithm(N):
count = 0
i = N
while i > 1:
#logN
i = i / 2
#N
for j in range(N):
count += 1
#嵌套为N logN
线性对数阶常出现于排序算法,例如「快速排序」、「归并排序」、「堆排序」等
空间复杂度涉及的空间类型有:
通常情况下,空间复杂度指在输入数据大小为 N 时,算法运行所使用的**「暂存空间」+「输出空间」的总体大小**。
而根据不同来源,算法使用的内存空间分为三类:
指令空间:
编译后,程序指令所使用的内存空间。
数据空间:
算法中的各项变量使用的空间,包括:声明的常量、变量、动态数组、动态对象等使用的内存空间。
class Node:
def __init__(self, val):
self.val = val
self.next = None
def algorithm(N):
num = N # 变量
nums = [0] * N # 动态数组
node = Node(N) # 动态对象
栈帧空间:
程序调用函数是基于栈实现的,函数在调用期间,占用常量大小的栈帧空间,直至返回后释放。如以下代码所示,在循环中调用函数,每轮调用 test() 返回后,栈帧空间已被释放,因此空间复杂度仍为O(1) 。
def test():
return 0
def algorithm(N):
for _ in range(N):
test()
算法中,栈帧空间的累计常出现于递归调用。如以下代码所示,通过递归调用,会同时存在 N 个未返回的函数 algorithm() ,此时累计使用 O(N) 大小的栈帧空间。
def algorithm(N):
if N <= 1: return 1
return algorithm(N - 1) + 1
通常情况下,空间复杂度统计算法在 “最差情况” 下使用的空间大小,以体现算法运行所需预留的空间量,使用符号 O 表示。
最差情况有两层含义,分别为「最差输入数据」、算法运行中的「最差运行点」。例如以下代码:
def algorithm(N):
num = 5 # O(1)
nums = [0] * 10 # O(1)
if N > 10:
nums = [0] * N # O(N)
输入整数 N ,取值范围 N≥1 ;
nums
的长度恒定为10,空间复杂度为O(10)=O(1);nums
长度为N,空间复杂度为O(N);nums= [0] * 10
时,算法仅使用O(1)大小的空间;nums = [0] * N
时,算法使用O(N)的空间;根据从小到大排列,常见的算法空间复杂度有:
O ( 1 ) < O ( l o g N ) < O ( N ) < O ( N 2 ) < O ( 2 N ) O(1)
示例节点类Node
、函数test()
:
# 节点类 Node
class Node:
def __init__(self, val):
self.val = val
self.next = None
# 函数 test()
def test():
return 0
普通常量、变量、对象、元素数量与输入数据大小 NN 无关的集合,皆使用常数大小的空间。
def algorithm(N):
#这些初始化都与N无关
num = 0
nums = [0] * 10000
node = Node(0)
dic = { 0: '0' }
#或
def algorithm(N):
for _ in range(N):
#立即返回了,无累计栈帧空间使用,因此复杂度为O(1)
test()
元素数量与 N 呈线性关系的任意类型集合(常见于一维数组、链表、哈希表等),皆使用线性大小的空间。
def algorithm(N):
nums_1 = [0] * N
nums_2 = [0] * (N // 2)
nodes = [Node(i) for i in range(N)]
dic = {}
for i in range(N):
dic[i] = str(i)
#或
#此递归调用期间,会同时存在 N 个未返回的 algorithm() 函数,因此使用O(N) 大小的栈帧空间。
def algorithm(N):
if N <= 1: return 1
return algorithm(N - 1) + 1
如图,直到algorithm(1)
才开始取消递归。
元素数量与 NN 呈平方关系的任意类型集合(常见于矩阵),皆使用平方大小的空间。
def algorithm(N):
#2维数组
num_matrix = [[0 for j in range(N)] for i in range(N)]
#2维数组
node_matrix = [[Node(j) for j in range(N)] for i in range(N)]
#或
def algorithm(N):
if N <= 0: return 0
nums = [0] * N
return algorithm(N - 1)
在第2个代码中:
注意:这里是有两种解释。
指数阶常见于二叉树、多叉树。
求和可以通过等比序列求和公式2算出来,满3叉树求和为 3 0 + 3 1 + . . . + 3 N − 1 = 1 ∗ ( 1 − 3 N ) 1 − 3 = 1 2 ( 3 N − 1 ) 3^0 + 3^1 + ... + 3^{N-1} = \frac{1*(1-3^N)}{1-3} = \frac{1}{2}(3^N -1) 30+31+...+3N−1=1−31∗(1−3N)=21(3N−1),复杂度为 O ( 3 N ) = O ( 2 N ) O(3^N) = O(2^N) O(3N)=O(2N)
对数阶常出现于分治算法的栈帧空间累计、数据类型转换等,例如
对于算法的性能,需要从时间和空间的使用情况来综合评价。优良的算法应具备两个特性,即时间和空间复杂度皆较低。而实际上,对于某个算法问题,同时优化时间复杂度和空间复杂度是非常困难的。降低时间复杂度,往往是以提升空间复杂度为代价的,反之亦然。
由于当代计算机的内存充足,通常情况下,算法设计中一般会采取「空间换时间」的做法,即牺牲部分计算机存储空间,来提升算法的运行速度。