算法初探

最近在看《算法图解》，但是里面的算法都是用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 data

6.广度优先搜索

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算法