[Leetcode]层次遍历二叉树

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

掌握层次遍历模板：使用队列、双循环，可解决层次遍历、求最大深度

层次遍历，从下到上，从左到右

public List<List<Integer>> levelOrderBottom(TreeNode root) {
             //最后的返回结果
            List<List<Integer>> result = new ArrayList<>();
    		//队列实现层次访问
            Queue<TreeNode> queue = new LinkedList<>();
    		//用栈来存放结果，最后依次退栈，即可得到我们的结果
            Stack<List<Integer>> stack = new Stack<>();
            if (root == null) return result;
            int size;
            queue.offer(root);
            while (!queue.isEmpty()) {
                int i = 0;
                List<Integer> levelresult = new ArrayList<>();
                size = queue.size();
                while (i < size) {
                    TreeNode p = queue.poll();
                    i++;
                    levelresult.add(p.val);
                    if (p.left != null)
                        queue.offer(p.left);
                    if (p.right != null)
                        queue.offer(p.right);
                }
                //进栈
                stack.push(levelresult);

            }
            while (!stack.isEmpty()) {
                List<Integer> tmp = stack.pop();
                result.add(tmp);
            }
            return result;


        }

求二叉树的最大深度

public int maxDepth(TreeNode root) {
            int deepth = 0;
            if (root == null) return deepth;
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            int psize;
            while (!queue.isEmpty()) {
                int i = 0;
                psize = queue.size();
                while (i < psize) {
                    //遍历当前层的元素
                    TreeNode p = queue.poll();
                    i++;
                    if (p.left != null)
                        queue.offer(p.left);
                    if (p.right != null)
                        queue.offer(p.right);
                }
                //遍历结束一次，层次加1
                deepth++;
            }
            return deepth;


        }