每日一题---从上到下打印二叉树

从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

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

   3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

提示：

1. 节点总数 <= 1000

今日未能解答。

以下为参考题解所写的Java代码。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public int[] levelOrder(TreeNode root) {
    if (root == null) return new int[0];
    Queue<TreeNode> treeNodes = new LinkedList<TreeNode>(){{add(root);}};
    List<Integer> list = new ArrayList<>();
    while (!treeNodes.isEmpty()) {
      TreeNode treeNode = treeNodes.poll();
      list.add(treeNode.val);
      if (treeNode.left != null) treeNodes.add(treeNode.left);
      if (treeNode.right != null) treeNodes.add(treeNode.right);
    }
    int[] res = new int[list.size()];
    for (int i = 0; i < res.length; i++) {
      res[i] = list.get(i);
    }
    return res;
}

以下为python3代码：

class Solution:
    def levelOrder(self: TreeNode) -> List[int]:
        if not self: return []
        res, queue = [], collections.deque()
        queue.append(self)
        while queue:
            node = queue.popleft()
            res.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return res

if __name__ == '__main__':
    root = TreeNode(1)
    root.left = TreeNode(2)
    print(Solution.levelOrder(root))

---

解题思路：

1. 巧妙的利用了队列的特性—先进先出，将每个节点的非空子节点从左到右存放到队列中，并遍历队列。题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。
2. 解题思路：
   • 当TreeNode为空时，返回空数组
   • 将root节点的TreeNode放入队列中，当队列不为空时，获取队列顶端数据的值存入数组中；同时，将非空左节点和非空右节点放入队列。利用队列先进先出的特性，实现获取每个节点的val值。

参考题解来源：leetcode

广度优先搜索（BFS）： 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里，其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中（例如队列或是链表），而被检验过的节点则被放置在被称为 closed 的容器中。

与BFS相对应的是深度优先算法，深度优先主要依赖与栈来实现。

深度优先和广度优先的对比：

	深度优先	广度优先
实现方式	栈（stack）	队列（queue
实现原理	1、把根节点压入栈中。2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。3、找到所要找的元素时结束程序。4、如果遍历整个树还没有找到，结束程序。	1、把根节点放到队列的末尾。2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。3、找到所要找的元素时结束程序。4、如果遍历整个树还没有找到，结束程序。
	整个过程可以想象成一个倒立的树形	整个过程也可以看做一个倒立的树形