算法8：LeetCode_二叉树的层序遍历

LeetCode原题：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

此题比较简单，直接上代码

package code.code_04;

import java.util.*;

/**
 * https://leetcode.cn/problems/binary-tree-level-order-traversal-ii
 * 题目：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
 *
 * 解题思路：
 * 1. 逐层搜集，首先收集根节点，并存入队列
 * 2. 获取队列元素, 再逐个从队列中取出, 放入数组中； 然后将当前节点的左节点和右节点存入队列
 * 3, 最后将数组存入linklist的首节点中
 *
 * 4. 然后再次遍历队列，取出每个节点的数值放入数组中，然后再将每个节点的左节点和右节点放入队列
 * 5. 最后将数组存入linklist的首节点中
 * 6. 依次类推，直到遍历完所有的节点
 */
public class Code01_BinaryTreeLevelNodeTraversall {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<>();
        //边界值判断
        if (root == null) {
            return ans;
        }

        //逐层搜集，首先收集根节点，并存入队列。印证思路第1步
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            //动态队列，队列的长度是会一直发生变化的，所以需要提前记录下长度
            //因为队列是先进先出，所以有了长度就可以直到每一层节点需要弹出的次数
            int size = queue.size();
            ArrayList<Integer> arrayList = new ArrayList();
            //获取队列元素, 再逐个从队列中取出, 放入数组中； 然后将当前节点的左节点和右节点存入队列
            //印证解题思路第2步
            for (int i = 0; i < size; i++) {
                TreeNode node = (TreeNode) (queue.poll());
                arrayList.add(node.val);

                if (node.left != null) {
                    queue.add(node.left);
                }

                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            //最后将数组存入linklist的首节点中,印证解题思路第3步
            //这一步实现了节点从下往上存储
            ans.add(0, arrayList);
        }

        return ans;
    }


    public static void main(String[] args) {
        Code01_BinaryTreeLevelNodeTraversall test = new Code01_BinaryTreeLevelNodeTraversall();
        //构造数组[3,9,20,null,null,15,7], 输出值应该为[[15,7],[9,20],[3]]
        TreeNode node1 = test.new TreeNode(3);
        TreeNode left2 = test.new TreeNode(9);
        TreeNode righ2 = test.new TreeNode(20);

        node1.left = left2;
        node1.right = righ2;

        TreeNode left3 = test.new TreeNode(15);
        TreeNode righ3 = test.new TreeNode(7);
        righ2.left = left3;
        righ2.right = righ3;

        List<List<Integer>> ans = test.levelOrderBottom(node1);
        for (int i = 0; ans != null && i < ans.size(); i++) {
            List<Integer> list = ans.get(i);
            for (int j = 0; j < list.size(); j++) {
                System.out.print(list.get(j) + "  ");
            }
            System.out.println(" ");
        }
    }
}