算法图解

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 False

7. 狄克斯特拉算法：
使用广度优先搜索，将得到数量最少的路径，但不一定是最快最方便的路径。
狄克斯特拉算法，相当于在广度优先算法的基础上加了权重。
关键理念： 找到最便宜的节点，并确保没有到该节点更便宜的路径。 如果有负权边，就不能试用此算法。

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. 线性规划：
用于在给定约束条件下最大限度地改善指定的指标。