最近在看《算法图解》，但是里面的算法都是用python2.7编写的，我准备一边看，一边自己用python3重写一遍。一方面为了加深印象，另一方面也为了以后复习查找更加的方便。
里面各种算法的用途或者工作原理就不写了，直接上代码部分。
————————持续更新中————————
1.二分查找
def binary_search(list,item):
low=0
high=len(list)-1
while low<=high:
mid=(low+high)//2
guess=list[mid]
if guess==item:
return mid
if guess>item:
high=mid-1
else:
low=mid+1
return None
my_list=[1,2,3,4,5,6,7,8,9,10]
print(binary_search(my_list,4))2.选择排序（讲数组元素按从小到大排列）
def findSmallest(arr):
smallest=arr[0]
smallest_index=0
for i in range(1,len(arr)):
if arr[i]<smallest:
smallest=arr[i]
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
my_list=[12,45,5152,131,1313,13525,131313]
print(selectionSort(my_list))3.递归
用递归写一个简单的阶乘函数
def fact(x):
if x==1:
return 1
else:
return x*fact(x-1)
print(fact(5))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)
my_list=[12,15,0,2,9,54]
print(quicksort(my_list))5.散列表的应用
（1）将散列表用于查找
phone_book=dict()
phone_book["Jack"]=123456
phone_book["emergency"]=110
print(phone_book["Jack"])（2）防止重复
voted=dict()
def check_voter(name):
if voted.get(name):
print("Kick them out!")
else:
voted[name]=True
print("let them vote!")
check_voter("tom")
check_voter("mike")
check_voter("tom")结果：
let them vote!
let them vote!
Kick them out!(3)将散列表用作缓存
cache=dict()
def get_page(url):
if cache.get(url):
return cache[url]
else:
data=get_data_from_server(url)
cache[url]=data
return data6.广度优先搜索
from collections import deque
graph=dict()
def search(name):
search_queue=deque()
search_queue+=graph[name]
searched=[]
while search_queue:
person=search_queue.popleft()
if person not in searched:
if person_is_seller(person):
print(person+" is a mango seller!")
return True
else:
search_queue+=graph[person]
searched.append(person)
return False
def person_is_seller(name):
return name[-1]=='m'
graph["you"]=["alice","bob","claire"]
graph["bob"]=["anuj","peggy"]
graph["alice"]=["peggy"]
graph["claire"]=["thom","jonny"]
graph["anuj"]=[]
graph["peggy"]=[]
graph["thom"]=[]
graph["jonny"]=[]
search("you")7.狄克斯特拉算法
计算如图所示的起点到终点的最短时间
graph=dict()
graph["start"]={}
graph["start"]["a"]=6
graph["start"]["b"]=2
graph["a"]={}
graph["a"]["fin"]=1
graph["b"]={}
graph["b"]["a"]=3
graph["b"]["fin"]=5
graph["fin"]={}
infinity=float("inf")
costs=dict()
costs["a"]=6
costs["b"]=2
costs["fin"]=infinity
parents=dict()
parents["a"]="start"
parents["b"]="start"
parents["fin"]=None
processed=[]
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 and 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+neighbors[n]
if costs[n]>new_cost:
costs[n]=new_cost
parents[n]=node
processed.append(node)
node=find_lowest_cost_node(costs)
print(cost)8.贪婪算法
在下图的广播台中找出最小的集合，使其覆盖所有的州
states_needed=set(["mt","wa","or","id","nv","ut","ca","az"])
stations={}
stations["kone"]=set(["id","nv","ut"])
stations["ktwo"]=set(["wa","id","mt"])
stations["kthree"]=set(["or","nv","ca"])
stations["kfour"]=set(["nv","ut"])
stations["kfive"]=set(["ca","az"])
final_stations=set()
while states_needed:
best_station = None
states_covered = set()
for station,states in stations.items():
covered=states_needed & states
if len(covered)>len(states_covered):
best_station=station
states_covered=covered
states_needed-=states_covered
final_stations.add(best_station)
print(final_stations)9.接下来要看的算法
（1）树：二叉查找树（B树），红黑树，堆，伸展树
（2）反向索引
（3）并行算法
（4）SHA算法