[leetcode]Binary Tree Level Order Traversal

题目描述如下：

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]
]

本人的解题思路是类似广度优先算法，则使用一个队列，自定义一个新的数据结构包含节点和节点的深度，每一次与当前的深度currtLevel做比较，如果两个值不同，说明当前已经进入到下一层，重新分配空间并把上一个list加入。代码实现如下：

public class Solution {   public List<List<Integer>> levelOrder(TreeNode root) {        List<List<Integer>> resList = new ArrayList<List<Integer>>();     //   List<Integer> subList = new ArrayList<Integer>();        if(root == null) return resList;        Queue<myTreeNode> queue = new LinkedList<>();        myTreeNode theRealRoot = new myTreeNode(root, 0);        myTreeNode tmp;        List<Integer> tmpList = new ArrayList<Integer>();        queue.add(theRealRoot);        int currtLevel = 0;        while (!queue.isEmpty()){            tmp = queue.poll();            if(currtLevel != tmp.level){                resList.add(tmpList);                List<Integer> subList = new ArrayList<Integer>();                tmpList = subList;                tmpList.add(tmp.node.val);                currtLevel =  tmp.level;            }else   {               int t = tmp.node.val;                tmpList.add(tmp.node.val);            }            if(tmp.node.left != null){                myTreeNode left = new myTreeNode(tmp.node.left, tmp.level + 1);                queue.add(left);            }            if(tmp.node.right != null){                myTreeNode right = new myTreeNode(tmp.node.right, tmp.level + 1);                queue.add(right);            }        }        resList.add(tmpList);        return resList;    }    class myTreeNode{        TreeNode node;        int level;        myTreeNode(TreeNode node, int l){            this.node  = node;            this.level = l;        }    }}

实现还是比较繁琐的，用了4ms的时间。

然后看到了一个仅用1ms的实现方法：

public class Solution {    public List<List<Integer>> levelOrder(TreeNode root) {        List<List<Integer>> result = new ArrayList<>();        if (root != null) {            levelOrderR(root, 0, result);        }        return result;    }    public void levelOrderR(TreeNode p, int level, List<List<Integer>> result) {        if (p == null) {            return;        }        ArrayList<Integer> current;        if (level >= result.size()) {            current = new ArrayList<>();            result.add(current);        } else {            current = (ArrayList<Integer>) result.get(level);        }        current.add(p.val);        levelOrderR(p.left, level + 1, result);        levelOrderR(p.right, level + 1, result);    }}

利用一个前序遍历来实现，也是用了level进行标记，但不用新定义数据结构，因此不用队列操作，节省大量时间。

题目链接：https://leetcode.com/problems/binary-tree-level-order-traversal/