数据结构与算法14、剑指Offer8-从上往下打印二叉树（广度优先遍历）

这里其实涉及到深度优先遍历和广度优先遍历的问题。
其实深度优先遍历本质上可以理解为一种广义的概念，之前写的前后中序遍历的递归和迭代的算法代码其实本质上是属于深度优先遍历的；而广度优先遍历也属于一种广义的概念。

我们对这两个知识点进行具体的解释一下：

1.深度优先遍历

深度优先遍历（Depth First Search），简称DFS，其原则是，沿着一条路径一直找到最深的那个节点，当没有子节点的时候，返回上一级节点，寻找其另外的子节点，继续向下遍历，没有就向上返回一级，直到所有的节点都被遍历到，每个节点只能访问一次。

在算法实现的过程中，我们采用了栈（Stack）这种数据结构，它的特点是，最先压入栈的数据最后取出；还有可以使用递归的方法去实现，这在之前的前后中序遍历代码中已经写过了，链接中的这篇文章的代码要好好背背理解记忆！！！

(其实是二叉树的先序遍历)

2.广度优先遍历

广度优先遍历（Breadth First Search），简称BFS；广度优先遍历的原则就是对每一层的节点依次访问，一层访问结束后，进入下一层，直到最后一个节点，同样的，每个节点都只访问一次。遍历顺序就是从上到下，从左到右。

(其实是二叉树的层次遍历)

在算法实现过程中，我们使用的队列（Queue）这种数据结构，这种结构的特点是先进先出。

而今天的这道题就是属于广度优先遍历。

剑指 Offer 32 - I. 从上到下打印二叉树

所以我们利用队列，先进先出，每次根先进队列，然后根出队列，并且根的左右节点均进队列，然后此时根的左节点可以看做是一个根，则左节点处队列的同时，左节点的左右节点均进队列，重复这样的操作。
最后打印出来的结果就是广度遍历的结果。

看代码吧：(这题不是那种复杂的情况，就是简单的队列先进先出而已)

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        queue = [root]

        if root is None:
            return res

        while queue:
            node = queue.pop(0)
            res.append(node.val)
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)
        return res

剑指 Offer 32 - II. 从上到下打印二叉树 II

利用len(queue)，来将上一层的节点都放入tmp中！！！

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        queue = [root]

        if root is None:
            return res
            
        while queue:
        	tmp_list = []
            length = len(queue)
            
            for i in range(length):
                node = queue.pop(0)
                tmp_list.append(node.val)
                if node.left is not None:
                    queue.append(node.left)
                if node.right is not None:
                    queue.append(node.right)
            res.append(tmp_list)

        return res

剑指 Offer 32 - III. 从上到下打印二叉树 III

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        queue = [root]

        if root is None:
            return res

        count = 1
        while queue:
        	tmp_list = []
            length = len(queue)
            for i in range(length):
                node = queue.pop(0)
                tmp_list.append(node.val)
                if node.left is not None:
                    queue.append(node.left)
                if node.right is not None:
                    queue.append(node.right)
            if count % 2 == 0:
                res.append(tmp_list[::-1])
            else:
                res.append(tmp_list)
            count += 1

        return res