数据结构 时间空间复杂度 汉诺塔递归问题 查找算法

时间复杂度——小结

1.时间复杂度使用来估计算法运行时间的一个单位

2.时间复杂度高的算法比低的算法慢

3.常见时间复杂度（按效率排序）
O(1)< O(logn)< O(n)< O(nlogn)< O(n方)< O(n三方)

#如何快速判断算法复杂度
# 1.确定问题规模n
# 2.循环减半过程——logn
# 3.K层关于n的循环——n的k方
# 4.复杂情况：根据算法执行过程具体判断

‘’’
/时间比空间重要/——空间换时间
空间复杂度：用来评估算法内存占用大小的式子
‘’’

‘’’
递归的两个特点：
1.调用自身
2.结束条件

**

汉诺塔问题：

n个盘子时：
1.把n-1个圆盘从A经过C移动到B(把上面n-1个盘子看成一个整体)
2.把第n个圆盘从A移动到C
3.把n-1个圆盘从B经过A移动到C
‘’’

#sum = 0
def hanoi(n, a, b, c):
# global sum
if n > 0:
hanoi(n - 1, a, c, b)
sum += 1
print(‘moving from %s to %s’ % (a, c))
hanoi(n - 1, b, a, c)
# print(sum)

hanoi(4, ‘A’, ‘B’, ‘C’)

‘’’

查找：在一些数据元素中，通过一定的方法找出与给定关键字相同的数据元素的过程

1.顺序查找（Linear search）

‘’’
from cal_time import *

@cal_time
def linear_search(li,val):
for ind,v in enumerate(li):
if v == val:
return ind
else:
return None

#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
#同时列出数据和数据下标，一般用在 for 循环当中

2.二分查找（Binary Search）O(logn)

@cal_time
def binary_search(li,val):
left = 0
right = len(li)-1
while left <= right:
mid = (left + right)//2
if li[mid] == val:
return mid
elif li[mid] > val:
right = mid - 1
else:
left = mid + 1
else:
return None

#li = [1,2,3,4,5,6,7,8,9,10]
li = list(range(10000))
linear_search(li,3)
binary_search(li,3809)

——————————————————

算法时间计算函数模块

import time

def cal_time(func):
def wraper(*args,**kwargs):
t1 = time.time()
result = func(*args,**kwargs)
t2 = time.time()
print(’%s running time %s　s’ % (func.name, t2-t1))
return result
return wraper