算法图解是一本非常简单入门的算法书，算法基于python语言，简单易懂，非常好学。不到200页，学习压力也不大，入门第一步就是它了。

算法图解

二分法查找

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,3,5,7,9]
print(binary_search(my_list,3))
print(binary_search(my_list,9))

1.1 128个名字的有序列表二分法需要log128 = 7

1.2 翻倍之后需要8

大O表示法

大O表示法指出了最糟情况下的运行时间，算法的快慢指的是并非时间，而是操作数的增加；谈论算法的速度时，我们说随着输入的增加，其运行时间以什么样的速度增加。
O(n!)在面对旅行者挑选最优解的时候遇到的算法是非常快的增加，这个我们提出来非常高的难度。
大O表示法通常会把常数省略掉

数组和链表

O	数组	链表
删除	O(n)	O(1)
读取	O(1)	O(n)
插入	O(n)	O(1)

链表擅长插入和删除，而数组擅长随机访问。

Facebook使用的是一种混合数据结构：链表数组

选择排序

选择排序的O(n^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
print(selectionSort([5,3,6,2,10]))

递归

递归需要注意：基线条件和递归条件；
所有的函数调用都进入调用栈，调用栈可能很长，占用大量的内存空间(注意)；
使用尾递归（高级算法）；
循环要比递归运算更加快速，递归更加易懂

>>> def fact(x):
	if x == 1:
		return x
	else:
		return x*fact(x-1)

快速排序(review)

设计数组递归的时候，通常基线的设置在于[]或者只含有一个元素。

O(nlogn)

def sum(arr):
	if len(arr) == 0:
		return 0
	return arr[0]+sum(arr[1:])

def count(list):
	if list == []:
		return 0
	return 1+count(list[1:])

def quicksort(arr):
    if len(arr)<2:
        return  arr
    pivot = arr[0]
    less = [i for i in arr[1:] if i <= pivot] 
    greater = [i for i in arr[1:] if i > pivot]
    return  quicksort(less) + [pivot] + quicksort(greater)
print(quicksort([10,5,2,3]))
# wow,amazing i love python so much in this way