1. 二分法：一组n个数字（有序排列）找到一个准确的数字，用二分法最多只要找log2n次。
def binary_search(list, item):
low = 0
high = len(list) - 1
while low <= high:
mid = round((low + high) / 2)
guess = list[:mid]
if guess == mid:
return mid
if mid > item:
high = mid-1
continue
else:
low = mid + 1
continue
return None
my_list = [1,3,6,9,12,16,17,21,29,32]
print(binary_search(my_list, 3))
2. 选择排序：
在内存中，数组空间不够时，内存必须重新分配新的足够的空间给数组；但是列表不需要全部重新分配，只要分配多余的空间给新来的元素，并用随机的内存地址串在一起。
但是要读取列表时，不能直接读取后面的元素，必须先访问元素1，然后元素2，直到最后一个元素。数组可以随意访问。
选择排序或者叫冒泡排序：
def findSmallest(arr):
smallest = arr[0]
smallest_index=0
for i in range(1,len(arr)): #随机找到列表中的数
if arr[i]< smallest: #比较大小
smallest_index=i
return smallest_index
def selectionSort(arr):
newArr=[]
for i in range(len(arr)):
smallest=findSmallest(arr)
newArr.append(arr.pop(smallest)) #在每个最小的数之后添加一个比较大的数，好排序
return newArr
print(selectionSort([1,5,15,4,3,8,6,9,10]))
3. 递归:
递归函数是调用自己。
4. 快速排序：
def quicksort(array):
if len(array) <2:
return array
else:
pivot = array[0]
less=[i for i in array[1:] if i <= pivot] #由所有小于基准值的元素组成的子数组
greater=[i for i in array[1:] if i>pivot]
return quicksort(less)+[pivot]+quicksort(greater)
print quicksort([1,4,2,3])5. 散列表(字典)：
6. 广度优先搜索：
先在一度关系中搜索，没有结果之后再从二度关系中搜索。
队列是先进先出的，栈是后进先出的
from collections import deque
search_queue = deque() #创建一个队列
search_queue+=graph["you"] #将你的另据都加入到这个搜索队列中：
def person_is_seller(name):
return name[-1] == 'm' #判断这个人是否为想要的结果的函数。
while search_queue: #只要队列不为空
person=search_queue.popleft() #就取出其中第一人
if person_is_seller(person): #检查这个人是否是想要的
print (person+"is a xxx")
return True
else:
search_queue+=graph[person] #不是想要找的对象，将这个朋友加入到搜索队列
return False #如果到了这里，说明队列赵总没有想要的结果，队列已为空。广度优先搜索代码：
def search(name):
search_queue=deque()
search_queue+=graph[name]
searched=[] #这个数组用于记录检查过的人
while search_queue:
person=search_queue.popleft()
if not person in searched:
if person_is_seller(person):
print person+'is a xxxx'
return True
else:
search_queue+=graph[person]
searched.append(person)
retuen False7. 狄克斯特拉算法：
使用广度优先搜索，将得到数量最少的路径，但不一定是最快最方便的路径。
狄克斯特拉算法，相当于在广度优先算法的基础上加了权重。
关键理念： 找到最便宜的节点，并确保没有到该节点更便宜的路径。 如果有负权边，就不能试用此算法。
def find_lowest_cost_node(costs):
lowest_cost=float('inf')
lowest_cost_node= None
for node in costs:
cost=costs[node]
if cost< lowest_cost & node not in processed: #如果当前节点未处理，且成本更低
lowest_cost=cost
lowest_cost_node=node
return lowest_cost_node
node=find_lowest_cost_node(costs): #在未处理的节点找到开销最小的点
while node is not None: #这个循环在所有节点被处理过后结束
cost =costs[node]
neighbors = graph[node]
for n in neighbors.keys(): #遍历当前节点的所有邻居
new_cost=cost+nighbors[n]
if costs[n] > new_cost: #如果经过当前节点离邻居更近
costs[n] = new_cost #就更新改邻居的开销
parents[n]=node #同事将该邻居的父节点设置为当前节点
processed.append(node)
node=find_lowest_cost_node(costs) #找出接下来要处理的节点，并循环8. 贪婪算法：
每一步都采取最优的做法，最终得到的就是全局最优解。
9. 动态规划：
先解决子问题，再解决主问题。
10. K最近邻算法：
给一个对象分类，看离它最近的三个对象是什么类型，就是3最近邻算法。
可以用在推荐系统中，在每位用户注册时就让他们指出自己喜欢的对象和喜欢的程度。 用户给使用过的对象评分，哪一类的评分最高，就推荐哪一类的对象。
要挑选适当的指标，考虑回归性。
11. 二叉查找树
12. 反向索引： 一个散列表，将单词映射到包含它的页面。
13. 傅里叶变换：
14. 并行算法： 提高算法速度，让他们能够在多个内核中并行地执行。
15. MapReduce： 分布式算法， 用hadoop执行。 基于映射（map）函数和归并（reduce）函数。
归并函数是将一个数组转换成一个元素。
16. 布隆过滤器和HyperLogLog：
布隆过滤器是一种概率性数据结构，HyperLogLog是类似于布隆过滤器的算法， 这两者都不是准确的结果，但是是大概率的结果。
17. SHA算法： 安全散列算法： 用来判断两个文件是否相同
SHA是一个散列函数， 它生成一个散列值（一个较短的字符串），用于促成索引。，用散列值判断文件是否相同，检查密码。
18. Diffie-Hellman秘钥交换： 公钥和私钥。
19. 线性规划：
用于在给定约束条件下最大限度地改善指定的指标。
来源：oschina
链接：https://my.oschina.net/u/4324524/blog/3847784