LeetCode：102. 二叉树的层序遍历队列实现和递归实现

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

实现思路：
方法一：使用队列实现层序遍历，遍历时每次从队列中取出该层节点个数（即每次队列的大小）的元素，即为一层

实现代码：

public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> tree = new ArrayList<>();
        if (root == null) return tree;
        List<Integer> level = new ArrayList<>(); // 某一层
        Queue<TreeNode> queue = new LinkedList<>(); // 遍历队列
        queue.offer(root);
        int levelSize = 0; // 当前某一层的节点个数
        TreeNode node;
        while (!queue.isEmpty()) {
            levelSize = queue.size();
            while (levelSize > 0) {
                node = queue.poll();
                if (node != null) {
                    level.add(node.val); // 访问该节点
                    queue.offer(node.left);
                    queue.offer(node.right);
                }
                levelSize--;
            }
            if (!level.isEmpty()) tree.add(level);
            level = new ArrayList<>();
        }
        return tree;
    }

方法二：使用递归实现，每次记录每一个节点的层数，将该元素放入对应层数即可

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    List<List<Integer>> lists = new ArrayList();
    public List<List<Integer>> levelOrder(TreeNode root) {

        if(root == null) return lists;

        process(root,0);
        return lists;
    }

    public void process(TreeNode root,int level){
        if(root == null) return ;
        if(lists.size() <= level){
            lists.add(new ArrayList());
        }
        lists.get(level).add(root.val);

        process(root.left,level+1);
        process(root.right,level+1);


    }
}