模板，记住这5个：
（1）针对树的BFS
1.1 无需分层遍历
    from collections import deque
	
    def levelOrderTree(root):
        if not root:
            return 
             
        q = deque([root])
        while q:
            head = q.popleft()
			do something with this head node...
            if head.left:                
                q.append(head.left)
			if head.right:
                q.append(head.right)                
        return xxx
1.2 需要分层遍历
    def levelOrderTree(root):
        if not root:
            return
                 
        q = [root]
        while q:
            new_q = []
            for node in q: # 和上面代码相比 差异就在这里 和 deque
                do something with this layer nodes...
                if node.left:
                    new_q.append(node.left)
                if node.right:
                    new_q.append(node.right)            
            q = new_q
        return xxx
		
（2）针对图的BFS
2.1 无需分层遍历
  from collections import deque
  
  def bfs_graph(root):	
    if not root: 
	    return
	
	queue = deque([root])
	seen = set([root])  
	while queue:
		head = queue.popleft()
		do something with this head...
		for neighbor in head.neighbors:
			if neighbor not in seen: # 和tree的区别无非就是多了一个是否访问过的判断
				seen.add(neighbor)
				queue.append(neighbor)
　　return xxx

上述代码中：
neighbor 表示从某个点 head 出发，可以走到的下一层的节点。
set/seen 存储已经访问过的节点（已经丢到 queue 里去过的节点）
queue 存储等待被拓展到下一层的节点
set/seen 与 queue 是一对好基友，无时无刻都一起出现，往 queue 里新增一个节点，就要同时丢到 set 里。
需要分层遍历的宽度搜先搜索

2.2 需分层遍历

    def bfs_graph(root):
        if not root:
            return []
                 
        q = [root]
		seen = set([root])
        while q:
            new_q = []
            for node in q:
                do something with this layer nodes...				
				for neighbor in node.neighbors:
				    if neighbor not in seen: # 和tree的区别无非就是多了一个是否访问过的判断
					    seen.add(neighbor)
						new_q.append(neighbor)           
            q = new_q
        return xxx


（3）拓扑排序

记住下面的代码
class Solution:
    """
    @param graph: A list of Directed graph node
    @return: Any topological order for the given graph.
    """
    def topSort(self, graph):
        node_to_indegree = self.get_indegree(graph)
 
        # bfs
        order = []
        start_nodes = [n for n in graph if node_to_indegree[n] == 0]
        queue = collections.deque(start_nodes)
        while queue:
            node = queue.popleft()
            order.append(node)
            for neighbor in node.neighbors:
                node_to_indegree[neighbor] -= 1
                if node_to_indegree[neighbor] == 0:
                    queue.append(neighbor)
                 
        return order
     
    def get_indegree(self, graph):
        node_to_indegree = {x: 0 for x in graph}
 
        for node in graph:
            for neighbor in node.neighbors:
                node_to_indegree[neighbor] += 1
                 
        return node_to_indegree

算法流程
拓扑排序的算法是典型的宽度优先搜索算法，其大致流程如下：
统计所有点的入度，并初始化拓扑序列为空。
将所有入度为 0 的点，也就是那些没有任何依赖的点，放到宽度优先搜索的队列中
将队列中的点一个一个的释放出来，放到拓扑序列中，每次释放出某个点 A 的时候，就访问 A 的相邻点（所有A指向的点），并把这些点的入度减去 1。
如果发现某个点的入度被减去 1 之后变成了 0，则放入队列中。
直到队列为空时，算法结束		


一些实际案例：
https://www.cnblogs.com/bonelee/p/11724346.html

　

BFS宽度优先搜索
模板：
https://www.cnblogs.com/bonelee/p/11724346.html
BFS模板：
    def levelOrder(self, root):
        # write your code here
        if not root:
            return []
             
        q = [root]
        result = []
        while q:
            children = []
            q2 = []
            for node in q:
                children.append(node.val)
                if node.left:
                    q2.append(node.left)
                if node.right:   
                    q2.append(node.right)
            result.append(children)
            q = q2
        return result
		
BFS 递归实现		
q= [root]		
result = []

def levelOrder(q):
  if not q:
     return
  q2 = []
  for node in q:
     xxxx
	 if node.left: q2.append(node.left)
	 if node.right: q2.append(node.right)
  levelOrder(q2)
	 

		
1. BFS VS DFS
https://www.geeksforgeeks.org/difference-between-bfs-and-dfs/

2. 什么时候使用BFS
图的遍历 Traversal in Graph
• 层级遍历 Level Order Traversal
• 由点及面 Connected Component
• 拓扑排序 Topological Sorting
最短路径 Shortest Path in Simple Graph
• 仅限简单图求最短路径
• 即，图中每条边长度都是1，或者边长都相等
非递归的方式找所有方案 Iteration solution for all possible results
• 这一点我们将在后面 DFS 的课上提到

3. 题型与算法的对应关系
最短路径
简单图 → BFS
复杂图 → Dijkstra, SPFA, Floyd（一般面试不考这个）
最长路径
图可以分层 → Dynamic Programming
分层：比如走到第i一定会经过第 i-1 层（棋盘格子图是典型的例子）
不可以分层 → DFS

4.主要内容
• 二叉树上的 BFS
• 图上的 BFS
• 矩阵上的 BFS
• 拓扑排序 Topological Sorting


5. 二叉树上的 BFS
5.1 二叉树层级遍历
5.1.1 非递归实现方法讲解
https://blog.csdn.net/sinat_20177327/article/details/78285495
5.1.2 题目和非递归python实现
https://blog.csdn.net/yurenguowang/article/details/76906620
5.1.3 DFS递归方法和java实现
https://blog.csdn.net/crazy1235/article/details/51507485

5.2 二叉树的序列化
5.2.1 什么是序列化(P11)
将“内存”中结构化的数据变成“字符串”的过程
序列化：object to string
反序列化：string to object
5.2.2 什么时候需要序列化(P12)
1. 将内存中的数据持久化存储时
内存中重要的数据不能只是呆在内存里，这样断电就没有了，所需需要用一种方式写入硬盘，在需要的
时候，能否再从硬盘中读出来在内存中重新创建
2. 网络传输时
机器与机器之间交换数据的时候，不可能互相去读对方的内存。只能讲数据变成字符流数据（字符串）后
通过网络传输过去。接受的一方再将字符串解析后到内存中。
5.2.3 序列化算法（P13)
一些序列化的例子：
• 比如一个数组，里面都是整数，我们可以简单的序列化为”[1,2,3]”
• 一个整数链表，我们可以序列化为，”1->2->3”
• 一个哈希表(HashMap)，我们可以序列化为，”{\”key\”: \”value\”}”
序列化算法设计时需要考虑的因素：
• 压缩率。对于网络传输和磁盘存储而言，当然希望更节省。
• 如 Thrift, ProtoBuf 都是为了更快的传输数据和节省存储空间而设计的。
• 可读性。我们希望开发人员，能够通过序列化后的数据直接看懂原始数据是什么。
• 如 Json，LintCode 的输入数据
5.2.4 使用BFS序列化
题目
https://www.lintcode.com/problem/serialize-and-deserialize-binary-tree/description
python BFS解答
https://www.jiuzhang.com/solutions/binary-tree-serialization/#tag-highlight-lang-python

5.3 二叉树上的BFS相关题目
5.3.1 Binary Tree Level Order Traversal II
题目：
http://www.lintcode.com/en/problem/binary-tree-level-order-traversal-ii/
解答：
https://blog.csdn.net/coder_orz/article/details/51583729
http://www.jiuzhang.com/solutions/binary-tree-level-order-traversal-ii/
5.3.2 Binary Tree Zigzag Order Traversal
http://www.lintcode.com/en/problem/binary-tree-zigzag-level-order-traversal/
http://www.jiuzhang.com/solutions/binary-tree-zigzag-level-order-traversal/
5.3.3 Convert Binary Tree to Linked Lists by Depth
http://www.lintcode.com/en/problem/convert-binary-tree-to-linked-lists-by-depth/
http://www.jiuzhang.com/solutions/convert-binary-tree-to-linked-lists-by-depth/

leetcode
lintcode（大部分提供解答）