python交互式程序设计导论答案第五周_MIT6.00.1X 计算机科学和PYTHON编程导论第五周...-CSDN博客

第九讲效率和增长量级

我们的首要目标就是让代码正常运行，能够计算出正确的答案。尽管如此，我们还是希望代码能够达到第二个目标，即高效地进行计算。通常而言，第一个目标更加重要，但有时候第二个目标也十分重要，同时我们需要平衡计算的复杂度和理解代码的复杂度。

复杂度 :

我们假设一个基本步骤就是一个操作，而这个操作的用时总是一样的，之后我们只需专注于数清楚计算函数时所执行的基本步骤即可。测量复杂度我们只关心增幅最快的项，并且忽略系数。

例：

def f(x):

for i in range(1000):

ans = i

for i in range(x):

ans += 1

for i in range(x):

for j in range(x):

ans += 1

#这一段代码的步骤总数为1000+2x+2x^2,对于其复杂度我们只关心增长最快的项即2x^2，

#同时我们不关心系数就得到该函数的复杂度x^2。对于复杂度我们使用大写的O表示，

#则该函数的复杂度表示为O(n^2)

常见的复杂度（耗时，由低到高）：

O(1) 常数时间算法，运算时间不随运算量的增加而增加

O(log n) 对数时间算法

O(n) 线性时间算法

O(n * log n) 对数-线性时间算法

O(n^c) 多项式时间算法

O(c^n) 指数时间算法

# 对数时间算法

def intToStr(i):

digits = '0123456789'

if i == 0:

return '0'

result = ''

while i > 0:

result = digits[i%10] + result

i = i/10

return result

# 运算步骤 log10(i) 复杂度 O(log(i))

# 线性时间算法

def addDigits(s):

val = 0

for c in s:

val += int(c)

return val

#总步骤 len(s) 复杂度O(len(s))

def fact(n):

if n == 1:

return 1

else:

return n*fact(n-1)

#总步骤 n 复杂度O(n)

# 多项式时间算法

def isSubset(L1, L2):

for e1 in L1:?

matched = False

for e2 in L2:

if e1 == e2:

matched = True

break

if not matched:

return False

return True

# 总步骤为 len(L1)*len(L2) 这里我们只考虑最坏的情况即 len(L1) == len(L2)

# 所以这个算法的复杂度为 O(len(L1)^2)

def intersect(L1, L2):

tmp = []

for e1 in L1:

for e2 in L2:

if e1 == e2:

tmp.append(e1)

res = []

for e in tmp:

if not(e in res):

res.append(e)

return res

# 总步骤为 len(L1)*len(L2) + len(L1) 我们只关心增长最快的项，

# 所以这个算法的复杂度为O(len(L1)^2)

# 指数时间算法

def genSubsets(L):

res = []

if len(L) == 0:

return [[]] #list of empty list

smaller = genSubsets(L[:-1])

# get all subsets without last element

extra = L[-1:]

# create a list of just last element

new = []

for small in smaller:

new.append(small+extra)

# for all smaller solutions, add one with last element

return smaller+new

# combine those with last element and those without

# 总步骤为 2^(n-1)+..+...+2^0, 所以该算法的复杂度为O(2^n)

第十讲内存和查找

我们可以同过间接索引的办法来查找需要的数据。

一般的对于无序列表的查找，时间复杂度为O(n)，而有序列表可通过二分查找将时间复杂度缩短为O(log(n))，所以我们可以通过对列表排序，使其变成有序的，再使用二分查找，只要我们找到一种排序算法使得 sort(L) + log(len(L)) < len(L) 则运算效率将会更高，而且对于多次查找，效率的提升就更加明显了。

# 选择排序

def selSort(L):

for i in range(len(L) - 1):

minIndx = i

minVal= L[i]

j = i + 1

while j < len(L):

if minVal > L[j]:

minIndx = j

minVal= L[j]

j += 1

temp = L[i]