Binary Tree Level Order Traversal

Java

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */


public class Solution {
    /*
     * @param root: A Tree
     * @return: Level order a list of lists of integer
     */
    public List<List<Integer>> levelOrder(TreeNode root) {
        // write your code here
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        queue.offer(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < size; i++){
                TreeNode vertices = queue.poll();
                if (vertices.left != null){
                    queue.add(vertices.left);
                }
                if (vertices.right != null){
                    queue.add(vertices.right);
                }
                level.add(vertices.val);
            }
            result.add(level);
        }
        return result;
    }
}

Python

class Solution:
    def levelOrder(self, root):
        if not root: return []
        res = []
        self.dfs(root,0,res)
        return res
    def dfs(self, root, level, res):
        if not root:
            return 
        if len(res) < level +1:
            res.append([])
        res[level].append(root.val)
        self.dfs(root.left,level + 1, res)
        self.dfs(root.right, level+1, res)

JavaScript

var levelOrder = function(root) {
    const queue = [];
    queue.push(root);
    const result = [];
    while (queue.length) {
        const len = queue.length;
        const level = [];
        for (let i = 0; i < len; i++) {
            const node = queue.shift();
            if (!node) {
                continue;
            }
            level.push(node.val);
            queue.push(node.left);
            queue.push(node.right);
        }
        if (level.length) {
            result.push(level);
        }
    }
    return result;
};