102. Binary Tree Level Order Traversal

来源：互联网发布：最长公共子序列c语言编辑：程序博客网时间：2024/04/28 11:47

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 1 BFS

3ms 13.3%

public class Solution {    public List<List<Integer>> levelOrder(TreeNode root) {        List<List<Integer>> lists = new ArrayList<List<Integer>>();        if(root == null){            return lists;        }        Queue<TreeNode> q = new LinkedList<TreeNode>();        q.add(root);        while(!q.isEmpty()){            int size = q.size();            List<Integer> list = new ArrayList<Integer>();            for(int i = 0; i < size; i++){                TreeNode node = q.poll();                list.add(node.val);                if(node.left != null){                    q.offer(node.left);                }                if(node.right != null){                    q.offer(node.right);                }            }            lists.add(list);        }        return lists;    }}

Solution 2 DFS

2ms 61.85%

public class Solution {    public List<List<Integer>> levelOrder(TreeNode root) {        List<List<Integer>> lists = new ArrayList<List<Integer>>();        getOrder(root, lists, 0);        return lists;    }    private void getOrder(TreeNode root, List<List<Integer>> lists, int level){        if(root == null){            return;        }        List<Integer> list;        if(lists.size() == level){            list = new ArrayList<Integer>();            lists.add(list);        }else{            list = lists.get(level);        }        list.add(root.val);        //lists.add(list);        //if statement can be removed        if(root.left != null){            getOrder(root.left, lists, level + 1);        }        if(root.right != null){            getOrder(root.right, lists, level + 1);        }    }}

Solution 3 Another DFS, not a good solution

5ms 3.39%

public class Solution {     public List<List<Integer>> levelOrder(TreeNode root) {        List<List<Integer>> results = new ArrayList<List<Integer>>();                if (root == null) {            return results;        }                int maxLevel = 0;        while (true) {            List<Integer> level = new ArrayList<Integer>();            dfs(root, level, 0, maxLevel);            if (level.size() == 0) {                break;            }                        results.add(level);            maxLevel++;        }                return results;    }        private void dfs(TreeNode root,                     List<Integer> level,                     int curtLevel,                     int maxLevel) {        if (root == null || curtLevel > maxLevel) {            return;        }                if (curtLevel == maxLevel) {            level.add(root.val);            return;        }                dfs(root.left, level, curtLevel + 1, maxLevel);        dfs(root.right, level, curtLevel + 1, maxLevel);    }}

Solution 4 BFS with two queues

// version 4: BFS. two queuespublic class Solution {    /**     * @param root: The root of binary tree.     * @return: Level order a list of lists of integer     */    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();        if (root == null) {            return result;        }                ArrayList<TreeNode> Q1 = new ArrayList<TreeNode>();        ArrayList<TreeNode> Q2 = new ArrayList<TreeNode>();        Q1.add(root);        while (Q1.size() != 0) {            ArrayList<Integer> level = new ArrayList<Integer>();            Q2.clear();            for (int i = 0; i < Q1.size(); i++) {                TreeNode node = Q1.get(i);                level.add(node.val);                if (node.left != null) {                    Q2.add(node.left);                }                if (node.right != null) {                    Q2.add(node.right);                }            }                        // swap q1 and q2            ArrayList<TreeNode> temp = Q1;            Q1 = Q2;            Q2 = temp;                        // add to result            result.add(level);        }                return result;    }}

Solution 5

// version 5: BFS, queue with dummy nodepublic class Solution {    /**     * @param root: The root of binary tree.     * @return: Level order a list of lists of integer     */    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();        if (root == null) {            return result;        }                Queue<TreeNode> Q = new LinkedList<TreeNode>();        Q.offer(root);        Q.offer(null); // dummy node                ArrayList<Integer> level = new ArrayList<Integer>();        while (!Q.isEmpty()) {            TreeNode node = Q.poll();            if (node == null) {                if (level.size() == 0) {                    break;                }                result.add(level);                level = new ArrayList<Integer>();                Q.offer(null); // add a new dummy node                continue;            }                        level.add(node.val);            if (node.left != null) {                Q.offer(node.left);            }            if (node.right != null) {                Q.offer(node.right);            }        }                return result;    }}

0 0