剑指offer32 - ||从上到下打印二叉树

题目

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

样例

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

思路分析

本题思路：在层序遍历的基础上对于每一层进行区分
参考最佳思路：添加一个for循环，循环的次数就是每一层的个数(len(queue))，很巧妙地表示了当前层的个数
这样出队的个数，就是每等于每一层的个数，表示的含义就是，就是队列只出当前层

本人思路：在每一层结束的时候，增加一个null节点来判断这一层结束，从而new 一个新的level来记录当前层的数据

代码实现

package 剑指offer.搜索与回溯.offer32B;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {


    TreeNode tree = new TreeNode();

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
        TreeNode() {
        }



    }


    public static void main(String[] args) {
        Solution solution = new Solution();
        Integer[] test = {1,2,3,4,5,6,7};
        solution.buildTree(test);
        List<List<Integer>> lists = solution.levelOrder(solution.tree);

        System.out.println(lists);
    }


    public void buildTree(Integer[] treeNode){

        LinkedList<TreeNode> treeNodes = new LinkedList<>();

        treeNodes = new LinkedList<>();

        int size = treeNode.length;


        int index = 0;
        tree.val = treeNode[index];
        treeNodes.offer(tree);
        while (!treeNodes.isEmpty()){


            int val = treeNode[index];

            if(++index >=size){
                break;
            }
            int leftVal = treeNode[index];

            if(++index >=size){
                break;
            }

            int rightVal = treeNode[index];

           TreeNode peek = treeNodes.peek();
            peek.left = new TreeNode(leftVal);
            peek.right = new TreeNode(rightVal);
            treeNodes.offer(peek.left);
            treeNodes.offer(peek.right);

            treeNodes.poll();
        }


    }

    /**
     * 思路分析：
     * 层序遍历的基础上，增加了对于层数的判断
     *
     * 思路：队列中增加一个特殊的节点，用来标记层数，划分不同的层，特殊节点
     * 正常队列中不可能扔null进去，如果扔了null表示该层结束
     *
     * 思路二：
     * 使用for循环来实现弹出，可以记录当前有多少个，所以出队多少次，新入队的不用管，因为只会出之前那么多次
     *
     *
     *
     * @param root
     * @return
     */
    public List<List<Integer>> levelOrder(TreeNode root) {

        if(root==null){
            return new ArrayList<>(new ArrayList<>(0));
        }


        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        queue.offer(null);
        List<Integer> resPart = new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();


        while (!queue.isEmpty()){

            TreeNode peek = queue.peek();

            if(peek==null){



                res.add(resPart);
               resPart = new ArrayList<Integer>();
               queue.poll();
               queue.offer(null);

                if(queue.size()==1){
                    break;
                }

               continue;
            }



            int val = peek.val;

            TreeNode left = peek.left;

            TreeNode right = peek.right;

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

            if(right!=null){
                queue.offer(right);
            }

            resPart.add(val);

            queue.poll();


        }


return res;

    }
}