算法

算法（Algorithm）：一个计算过程，解决问题的方法

递归

递归的两个特点：

• 调用自身
• 结束条件

def func3(x):
    if x > 0:
        print(x)
        func3(x - 1)
func3(3)

def func3(x):
    if x > 0:
        func3(x - 1)
        print(x)
func3(3)

![]
(http://images2017.cnblogs.com/blog/658994/201708/658994-20170825224958418-638409811.jpg)
![]
(http://images2017.cnblogs.com/blog/658994/201708/658994-20170825225002980-1149857509.jpg)

我的小鲤鱼
![]
(http://images2017.cnblogs.com/blog/658994/201708/658994-20170825225900949-574999163.png)

def func(depth):
    if depth == 0:
        print('我的小鲤鱼',end='')  # end = '' 代表不换行
    else:
        print('抱着',end='')
        func(depth-1)
        print('的我',end='')
func(3)

时间复杂度

评估算法运行效率的

时间复杂度是算法运行时间的式子

时间复杂度可以用表示时间复杂度的数和单位共同组成 ，单位就是n的几次方

O(1)
O(n)
O(n^2)
O(n^3)

![]
(http://images2017.cnblogs.com/blog/658994/201708/658994-20170825230649480-1075677653.jpg)

while循环 折半
O(log2n)

总结

时间复杂度是用来估计算法运行时间的一个式子（单位）。
一般来说，时间复杂度高的算法比复杂度低的算法慢。不同量级的不能比较

• 常见的时间复杂度（按效率排序）
  O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n2logn)<O(n^3)
• 不常见的时间复杂度（看看就好）
  O(n!) O(2n) O(nn) …

如何一眼判断时间复杂度？
循环减半的过程 O(logn)
几次循环就是n的几次方的复杂度

空间复杂度

内存占用大小

O(1)
Sn = O(n)

空间换时间 算法跑的快

列表查找

从列表中查指定元素

输出：元素下标或未找到元素

顺序查找

从头开始查找，直到查找到结果

二分查找

有序的列表查找

val < mid : high = mid -1
val > mid : low = mid +1

二分法和顺序查找测试

In [1]: import random
   ...: n = 10000
   ...: li = list(range(n))
   ...:
   ...: def bin_searhc(li, val):
   ...:     low = 0
   ...:     high = len(li) - 1
   ...:     while low <= high:
   ...:         mid = (low + high) // 2
   ...:         if li[mid] == val:
   ...:             return mid
   ...:         elif li[mid] < val:
   ...:             low = mid + 1
   ...:         else:
   ...:             high = mid - 1
   ...:     return None  # 单high < low 的时候不存在
   ...:

In [2]:

In [2]: %timeit bin_searhc(li,3200)
The slowest run took 4.12 times longer than the fastest. This could
 intermediate result is being cached.
100000 loops, best of 3: 5.08 µs per loop

In [3]: %timeit li.index(3200)
10000 loops, best of 3: 64.3 µs per loop

• index 的时间复杂度是O(n)
• bin_search的时间复杂度是O(logn)

2**64 仅仅查找64次
O(logn)

所以最后相差的会很大

尾递归的和二分速度差不多

尾递归没有在出栈的时候的保存，所以速度快

def bin_search_rec(data_set, value, low, high):
    if low <= high:
        mid = (low + high) // 2
        if data_set[mid] == value:
            return mid
        elif data_set[mid] > value:
            return bin_search_rec(data_set, value, low, mid - 1)
        else:
            return bin_search_rec(data_set, value, mid + 1, high)
    else:
        return

li =[
    {'id': 1001, 'name': "张三", 'age': 20},
    {'id': 1002, 'name': "李四", 'age': 25},
    {'id': 1004, 'name': "王五", 'age': 23},
    {'id': 1007, 'name': "赵六", 'age': 33}
]


def bin_searhc(li, val):
    low = 0
    high = len(li) - 1
    while low <= high:
        mid = (low + high) // 2
        if li[mid]['id'] == val:
            return li[mid]
        elif li[mid]['id'] < val:
            low = mid + 1
        else:
            high = mid - 1
    return None  # 单high < low 的时候不存在

res = bin_searhc(li,1002)
print(res)