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

题目

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

样例

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

返回：

[3,9,20,15,7]

思路分析

层序遍历即可
层序遍历：通过定义一个队列先进先出，然后进行打印
将需要打印的结果即该节点，存放到res列表中即可

代码实现

提供了常规数据的树的建立函数

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

import java.util.*;

public class Solution {

     TreeNode tree = new TreeNode();


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

        System.out.println(Arrays.toString(res));

    }


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

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


    /**
     * 树的建立，存在问题，对于null的节点无法建立，以及对于如果不是完整的二叉树，无法建立，需要优化
     * 适用于：常规数据进行测试
     * @param treeNode
     */
    public void buildTree(Integer[] treeNode){

        Queue<TreeNode> 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();
            }


    }


    /**
     * 思路分析：
     * 第一步：建立一个二叉树，直接就是传入一个树
     * 第二步：采用层序遍历的方式打印
     * 层序遍历，采用队列先进先出，对于每一个值进行输出
     *
     * @param root
     * @return
     */
    public int[] levelOrder(TreeNode root) {
        //增加一个对于0的判断
        if(root== null){
            return new int[0];
        }

        int n = 1000;
        List<Integer> res = new ArrayList();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()){
            TreeNode peek = queue.peek();
            TreeNode left = peek.left;
            TreeNode right = peek.right;

            int val = peek.val;

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

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

            queue.poll();
            res.add(val);
        }


        int size = res.size();

        int[] returnRes = new int[size];
        for (int i = 0; i < size; i++) {
            returnRes[i] = res.get(i);
        }

        return returnRes;
    }

}