LeetCode 二叉树的层次遍历

https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/description/

我的解决方案：
我的思路是把二叉树按照层次转换成列表，然后统计每一层有多少个节点，按照层次存储城数组形式，之后按照每层的节点个数对列表进行划分，将结果反转之后返回

class Solution { 
    public int levelSum(TreeNode root, int level){  
        if(root==null)
            return 0;
        if(1==level)  
            return 1;
        else
            return levelSum(root.left, level-1)+levelSum(root.right, level-1);
    } 

    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        return Integer.max(maxDepth(root.left), maxDepth(root.right))+1;
    }

    public ArrayList<Integer> treeToArray(TreeNode root) { 
        ArrayList<Integer> a = new ArrayList<Integer>();
        int front=0;
        int rear=1;
        TreeNode[] q = new TreeNode[10000];  
        q[front]=root;
        a.add(root.val);
        int m=10000; 
        while(front<rear) {
            TreeNode p=q[front];
            front=(front+1)%m; 
            if(p.left!=null) {
                q[rear]=p.left;
                a.add(p.left.val); 
                rear=(rear+1)%m;
            } 
            if(p.right!=null) {
                q[rear]=p.right;
                a.add(p.right.val); 
                rear=(rear+1)%m;
            } 
        }  
        return a;
    }
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new LinkedList<List<Integer>>();
        if(root==null) return res;
        ArrayList<Integer> a = new ArrayList<Integer>();
        a=treeToArray(root); 
        int depth = maxDepth(root);
        int[] level = new int[depth+1];
        for(int i=1;i<=depth;i++)  
            level[i]=levelSum(root, i); 
        System.out.println(a.size());
        for(int i=1; i<=depth;i++) {
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            for(int j=0;j<level[i];j++) 
                tmp.add(a.remove(0)); 
            res.add(tmp);
        }
        Collections.reverse(res);
        return res;
    }
}   

参考自提交记录中耗时最短的：

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> l = new LinkedList();
        if (root == null) return l;
        Queue<TreeNode> q = new LinkedList();
        Stack<List<Integer>> s = new Stack();
        q.offer(root);
        int i = q.size();
        List<Integer> list = new LinkedList();
        TreeNode p = null;
        while(q.size() > 0) {
            if (i == 0) {
                //这一个if语句的存在，可以将结果分成一层一层的
                l.addFirst(list);
                i = q.size();
                list = new LinkedList();
            }

            p = q.poll();
            list.add(p.val);

            --i;

            if (p.left != null) q.offer(p.left);
            if (p.right != null) q.offer(p.right);

        }

        l.addFirst(list);

        return l;
    }
}