102. 二叉树的层次遍历

递归：

用队列维护，当一层结点要出队列之前，要保存队列的长度也就是某一层的结点数。出队列时候只出保存的结点数个结点。

PythonJavaclass Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        levels = []
        if not root:
            return levels
        
        def helper(node, level):
            # start the current level
            if len(levels) == level:
                levels.append([])

            # append the current node value
            levels[level].append(node.val)

            # process child nodes for the next level
            if node.left:
                helper(node.left, level + 1)
            if node.right:
                helper(node.right, level + 1)
            
        helper(root, 0)
        return levels

 

整个过程就是先统计对列里的结点数，然后把这些结点出队列，在这些结点出队列的同时，把该结点的子结点入队列。

class Solution {
    List<List<Integer>> levels = new ArrayList<List<Integer>>();

    public void helper(TreeNode node, int level) {
        // start the current level
        if (levels.size() == level)
            levels.add(new ArrayList<Integer>());

         // fulfil the current level
         levels.get(level).add(node.val);

         // process child nodes for the next level
         if (node.left != null)
            helper(node.left, level + 1);
         if (node.right != null)
            helper(node.right, level + 1);
    }
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) return levels;
        helper(root, 0);
        return levels;
    }
}

迭代：

 

# 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):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        levels = []
        if not root:
            return levels
        
        level = 0
        # queue不操作的时候保存的是某一层的全部节点
        # 在当前queue节点出队列的同时，它的子节点入队列，全部父节点出完队列之后，
        # queue保存的就是下一层的全部节点
        queue = deque([root,])
        while queue:
            # start the current level
            # 添加上层的存储的列表
            levels.append([])

            # 结点弹出之前统计当前层的结点数
            level_length = len(queue)
            
            # 弹出层数里节点数个结点
            for i in range(level_length):
                # 结点出队列
                node = queue.popleft()
                # 把这层节点放到存储的列表里
                levels[level].append(node.val)
                
                # add child nodes of the current level
                # in the queue for the next level
                # 子结点入队列
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            # go to next level
            # 更新层数
            level += 1
        
        return levels

class Solution {
  public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> levels = new ArrayList<List<Integer>>();
    if (root == null) return levels;

    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.add(root);
    int level = 0;
    while ( !queue.isEmpty() ) {
      // start the current level
      levels.add(new ArrayList<Integer>());

      // number of elements in the current level
      int level_length = queue.size();
      for(int i = 0; i < level_length; ++i) {
        TreeNode node = queue.remove();

        // fulfill the current level
        levels.get(level).add(node.val);

        // add child nodes of the current level
        // in the queue for the next level
        if (node.left != null) queue.add(node.left);
        if (node.right != null) queue.add(node.right);
      }
      // go to next level
      level++;
    }
    return levels;
  }
}