BFS与DFS练习：102二叉树的层序遍历、104二叉树的最大深度、111二叉树的最小深度

广度优先搜索BFS

先访问根节点，再逐层访问。从起点开始对于直接子孩子，地毯式搜索。申请一个队列实现。

树不会重复，但图和抽象结合有可能重复。

visited = set()
def BFS(graph,start,end):
    queue = []
    queue.append(start)
    visited.add(start)

    while queue:
        node = queue.pop()
        visited.add(node)

        process(node)
        modes = generate_related_nodes(node)
        queue.push(nodes)

深度优先搜索DFS

从根节点一直访问到叶子节点。栈的模式。一般用递归。

两者对比：

dfs实现结构：

visited = set()
def dfs(node,visited):
    visited.add(node)

    ...
    for next_node in node.children():
        if not next_node in visited:
            dfs(next_node,visited)

102.二叉树的层序遍历（中等）

题源： https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

题目： 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：

二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

思路1：这里比较常见的解题思路是BFS按层输出。

import collections
class Solution(object):
    def levelOrder(self,root):
        if not root: return []
        
        res =[]
        #这里使用双端队列，如果不用的话则pop的时候为pop(0)，不然默认输出最后一个
        queue = collections.deque()
        queue.append(root)
        
        #维护一个队列，队里始终是每一层的元素
        #如果这层就元素就pop输出此层
        #然后针对这一层中的每个元素，左右孩子判断，有的话就先左后右的加入队列尾部
        while queue:
            level_size  = len(queue)
            level = []

            for i in range(level_size):
                node = queue.popleft()
                level.append(node.val)
                #为下一层queue增加元素
                if node.left:queue.append(node.left)
                if node.right:queue.append(node.right)
            res.append(level)
        return res

104.二叉树的最大深度

题源：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

题目：

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

思路1：BFS解法。将整棵树使用BFS遍历一遍，使用队列，始终将一层的节点维护在队列内。遍历下一层时，一边父节点出队，一边将父节点的左右孩子加入队列，当这层的所有节点都出队，队列里的元素也都变成下一层的所有元素。

def maxDepth(root):
    if not root:return 0

    res = 0
    queue = []
    queue.append(root)

    while queue:
        num = len(queue)
        
		#当这queue里元素的num>0表示这一层还有节点
        #给层级res+1
        if num > 0:
            res += 1
        for i in range(num):
            node = queue.pop(0)
            if node.left:queue.append(node.left)
            if node.right:queue.append(node.right)
    return res

思路2：DFS解法。取节点的左右子树深度的值，取max，并加上当前节点的层级，即+1。（左右子树分治）

def maxDepth(self, root):
    """
        :type root: TreeNode
        :rtype: int
        """
    if not root:return 0
    return 1+max(self.maxDepth(root.left),self.maxDepth(root.right))

111.二叉树的最小深度

题源： https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/

题目：给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

	3
   / \
  9  20
    /  \
   15   7

返回它的最小深度 2.

思路1：BFS方法，将整棵树使用BFS遍历树，寻找第一个叶子节点。使用队列，始终将一层的节点维护在队列内。遍历下一层时，一边父节点出队，一边将父节点的左右孩子加入队列。如果发现某个节点没有孩子节点，则直接输出当前层级。

def minDepth(root):
    if not root:return 0

    res = 0
    queue = []
    queue.append(root)

    while queue:
        num = len(queue)

        if num>0:
            res += 1
        for i in range(num):
            node = queue.pop(0)
            if not node.left or node.right:return res
            if node.left:queue.append(node.left)
            if node.right:queue.append(node.right)