算法

常见算法：
分治法，递归法，贪心法，动态规划法，迭代法，枚举法，回溯法
数据结构的种类：
1.数组： 一排紧密相连的可数内存 一维数组 二维数组 多维数组等
2.链表：
3.堆栈： 后进先出， 压栈，出栈，
4.队列： 先进先出，
5.树形结构
6.图
7.哈希表

1章
1.1
算法是一组完成任务的指令，任何代码片段都可视为算法
二分查找（二分查找的时间为对数时间，low,high,mid ）
时间复杂度：T(n)=T(n/2)+o(1)
只适合有序列表
高低指标 一次折叠一半

代码:

import math
def bin_search(arr, item):
    low = 0
    high = len(arr)-1
    while low <= high:                       //循环结束条件 数组只剩一个元素
        mid = math.floor((low+high)/2)
        guess = arr[mid]
        if guess == item:
            return mid
        elif guess > item:
            high = mid-1
        else:
            low = mid+1
    return None

1.2大O表示法（最糟糕情况下运行时间，n为操作数，旅行商问题）

2章
冒泡排序法：
冒泡排序法又称为交换排序法，原理是从第一个元素开始，比较相邻元素的大小，若大小顺序有误，则对调后再进行下一个元素的比较。 核心：比n-1次，每次比n-1-j下。

def sort(arr):
    for j in range(len(arr)-1):
        for i in range(len(arr)-1-j):
             t = 0
             if arr[i]>arr[i+1]:
                 t = arr[i]
                 arr[i] = arr[i+1]
                 arr[i+1] = t
    return arr

2.1数组和链表(数组适合查找,链表适合增删)
2.2选择排序
反复从未排序的数列中取出最小的元素，加入到另一个数列中，最后的结果即为已排序的数列。
一次找一个最值，旧列表减值，新列表加值

代码：

def select_sort(array):          
    lis = []
    while len(array) > 0:
        pos = array[0]
        for value in array:
            if value > pos:
                pos = value
        array.remove(pos)
        lis.append(pos)
    return lis

3章
每个递归函数都有两部分：
基线条件和递归条件
递归条件指的是函数调用自己，而基线条件指的是函数不再调用自己，从而避免形成无限循环

计算机在内部使用被称为 调用栈 的栈。

def greet(name):
    print("hello")
    function1()
    print("hi")                 
    function2()     

递归调用栈
计算阶乘

def function(num)：
    if num == 1:
        return 1
    else:
        return num*function(num-1)  

4章
分而治之（divide and conquer D&C）
快速排序：
1.选择基准值 2.将数组分成两个子数组：小于基准值的元素和大于基准值的元素
3.对这两个子数组进行快速排序
时间复杂度 一般为n*logn 最差情况下为n^2.
代码：
找一基准值，大小放两边

def quicksort(array):
    if len(array)<2:
        return array
    else:
        p = array[0]          //p为基准值
        low = [i for i in array[1:] if i<=p]
        big = [i for i in array[1:] if i>p]
        return quicksort(low) + [p] + quicksort(big)

归并排序
时间复杂度：T(n)=2T(n/2)+o(n) 子问题数目子问题规模 n*logn

def merge_sort(arr):
    if len(arr)<=1:
        return arr
    mid = len(arr)//2
    left=merge_sort(arr[:mid])
    right=merge_sort(arr[mid:])
    return merge(left, right)
def merge(a, b):
    c=[]
    h=j=0
    while j<len(a) and h<len(b):
        if a[j]<b[h]:
            c.append(a[j])
            j+=1
        else:
            c.append(b[h])
            h+=1
    if j==len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)
    return c

5章
散列表（将输入映射到数字,由键和值组成）
python提供的散列表实现为字典，可使用函数dict来创建散列表
（1.用于查找 模拟映射关系，
2.防止重复dict.get(’ '),
3.用作缓存（网站将数据记住，不再重新计算））

def get_page(url):
    if cache.get(url):
        return cache[url]
    else:
        data = get_data_from_server(url)
        cache[url] = data
        return data

冲突：给两个键分配的位置相同

填装因子 散列表包含的元素数 / 位置总数 填装因子越低，发生冲突的可能性越小，散列表的性能越高。
一旦填装因子大于0.7，调整散列表的长度

6章 图
解决 最短路径问题 的问题算法被称为 广度优先搜索 《队列 先进先出 first in first out 的数据结构》
1：从节点A出发，有前往节点B的路径吗？
2：从节点A出发，前往节点B的哪条路径最短？

from collections import deque
search_deque = deque()
search_deque += graph[''you'']
searched = [ ]                  //使用一个列表来记录检查过的人
while search_queue:
   person = search_queue.popleft()
   if person not in searched:
       if person_is_seller(person):
           print(' ')
           return True
       else:
           search_queue += graph[person]
           searched.append(person)
return False 

def person_is_seller(name):
    return name == 'mmmm'

运行时间 广度优先搜索的运行时间为O （V+E） V为定点数 E为边数

第7章
缔结特斯拉 算法 （只适应于有向无环图）
权重 带权重的图为加权图 不带权重的图为非加权图

（…）

第8章
贪婪算法
（每步都采取最优的做法）
背包问题：
集合覆盖问题
代码：

states_needed = set( ['m','w','o','i','n','u'] )  //要覆盖的集合   集合类似于列表，同样的元素只能出现一次
stations['  '] = set( ['m','o','i'] )         键为广播台名称 ， 值为覆盖的集合
while states_needed:
    best_station = None
    states_covered = set()
    for station,states_for_station in stations.items():
        covered = states_needed & states_for_station
        if len(covered) > len(states_covered):
            best_station =station
            states_covered =covered
    states_needed-=states_covered
    final_stations.add(best_station) 

np完全问题

9章：动态规划
（动态规划先解决子问题，再逐步解决大问题）
背包问题：