基础算法（一）

1、二分查找

前提数据必须是有序的，算法的时间是 O(logN)（2为底）

代码：

def binary_search(list, item):
  low = 0    （以下2行）low和high用于跟踪要在其中查找的列表部分
  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) # => 1  ←--------------------别忘了索引从0开始，第二个位置的索引为1
print binary_search(my_list, -1) # => None  ←--------------------在Python中，None表示空，它意味着没有找到指定的元素

2、 数组和链表

除了存储位置的区别，数组是所有的数据集中在一块并且数组种所有的元素类别都必须相同，如果那块内存不够，要挪到其他位置，或者预先设置数组的长度，但是会造成空间的浪费，并且一旦数组长度超过，还是会挪位置，链表则是可以不连续的，每个元素的尾巴跟上下一个元素的位置信息，他们的操作时间的差别如下图：

3、选择排序

选择排序是每次遍历数组，放入新的位置，在下一次遍历数据的时候变成（n-1）个数据，所以算下来最终遍历次数是（n/2），并且要检查n次，所以选择排序的时间是O(nn/2) ,在通常情况下，算法里面的常数去掉，所以一般写成O(nn) 代码如下：

# 找到最小值
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])

4、快速排序

快速排序的时间最糟糕的情况是O(n*n) ，快速排序的速度取决于选取的基准值是啥，代码如下：

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([10, 5, 2, 3])

5、递归

递归就是不断的调用自身，达到循环，但是在这个过程中必须有个停止的条件，不然会一直执行下去。
所以在函数中我们会有两个条件 1、基线条件 2、递归条件

6、栈

1、所有的函数调用都进入递归栈

7 散列函数

散列函数的查找时间是O (1),散列函数是将无论输入什么，映射出来的是一个数字（散列表、映射、字典、关联数组）Python种是字典

7 广度优先搜索

已经被check的数据要标记一下，不然会无线循环
队列：先进先出，栈：先进后出

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
search("you")

8 贪婪算法

背包能装4斤重的物品，我们要将装进背包中的东西总计最贵。
现有4样可以拿

西瓜	冬瓜	柚子	榴莲
2斤50元	2斤50块	1斤 20元	3斤 60元

贪婪算法根据名字就知道是贪婪的思维，我们一开始会选择最贵的榴莲 60块 还剩下一斤的空间 ，再加入柚子 20，总计80元。

9 动态规划

动态规划相对于贪狼，更多的是从最小组合最优到最后合并最优。 明显动态优化最后的结果是最优的100块。