Binary Tree Level Order Traversal 解答

Question

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

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

Solution -- Two Queues

Classic solution for BFS problem is to use two queues. One for current level, and the other for next level. This method is to visit tree level by level. Time complexity is O(n), space cost is O(n), n is the number of nodes in tree.

Deque (Java Interface)

ArrayDeque (Java Class)

 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> result = new ArrayList<List<Integer>>();
         if (root == null)
             return result;
         Deque<TreeNode> current = new ArrayDeque<TreeNode>();
         Deque<TreeNode> next;
         TreeNode tmpNode;
         current.addLast(root);
         while (current.size() > 0) {
             // Refresh next queue
             next = new ArrayDeque<TreeNode>();
             List<Integer> tmpList = new ArrayList<Integer>();
             while (current.size() > 0) {
                 tmpNode = current.pop();
                 if (tmpNode.left != null)
                     next.addLast(tmpNode.left);
                 if (tmpNode.right != null)
                     next.addLast(tmpNode.right);
                 tmpList.add(tmpNode.val);
             }
             // Refresh prev queue
             current = next;
             result.add(tmpList);
         }
         return result;
     }
 }

Simplied version

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        result = []
        if not root:
            return result
        queue = deque()
        queue.append(root)
        while queue:
            level = []
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(level)
        return result