【剑指Offer】个人学习笔记_32_从上到下打印二叉树 I&II&III

刷题日期：19:5225 星期四2021年4月8日

个人刷题记录，代码收集，来源皆为leetcode

经过多方讨论和请教，现在打算往Java方向发力

主要答题语言为Java

I

题目：

剑指 Offer 32 - I. 从上到下打印二叉树

难度中等79

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

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

    3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

提示：

1. 节点总数 <= 1000

题目分析

首先因为树的深度不确定，所以返回数组的长度也不一定，可以考虑用一个链表先存放数据，然后遍历链表定义数组返回。要么就得用类似于add这种添加命令不断加上新的子树节点。

其次因为是树的问题，首先想到递归解决，不断获取左右子树的节点内容，存储到返回数组。

层序遍历，又称广度优先搜索

初始解答：

因为暂时想不到解决数组长度的办法，而且这种遍历方式记的也不是很清楚，参考书和其他人的解答。

书上提到了用队列来解决问题，因为每次提出数据都需要先把它的左右子树放入队列。

层序遍历，参考了方法一

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
   
    public int[] levelOrder(TreeNode root) {
   
        //先考虑特殊情况
        if (root == null) return new int[0];
        //定义队列
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        //定义数组
        List<Integer> list = new ArrayList<Integer>();
        //先把根节点放进去
        que.add(root); //入队，这里不放root.val，因为入队的就是节点
        while(!que.isEmpty()){
    //这种特殊类型的数据是不是都有这个方法
            TreeNode node = que.poll(); //出队操作，建立树节点存放当前节点
            list.add(node.val); //列表的add属性，不用知道长度
            if(node.left != null) que.add(node.left); //先左
            if(node.right != null) que.add(node.right); //再右
            //所有节点都进入队列
        }
        //出队完毕，转换列表为数组
        return list.stream().mapToInt(Integer::intValue).toArray();
        //将Integer类型list复制为int数组 只不过使用了java8的stram新特性 
        //建议去了解一下stream 当然也可以直接写循环复制
        //流方法，不深究了

    }
}

效率比较低 执行结果：通过

显示详情

执行用时：4 ms, 在所有 Java 提交中击败了17.35%的用户

内存消耗：39 MB, 在所有 Java 提交中击败了5.02%的用户

参考了K神方法三后更直观的写法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
   
    public int[] levelOrder(TreeNode root) {
   
        //先考虑特殊情况
        if (root == null) return new int[0];
        //定义队列，直接赋值写法，第二个尖括号里面的内容可省
        Queue<TreeNode> que = new LinkedList<>(){
   {
    add(root); }};
        //定义数组
        ArrayList<Integer> list = new ArrayList<>();
        while(!que.isEmpty()){
    //这种特殊类型的数据是不是都有这个方法
            TreeNode node = que.poll(); //出队操作，建立树节点存放当前节点
            list.add(node.val); //列表的add属性，不用知道长度
            if(node.left != null) que.add(node.left); //先左
            if(node.right != null) que.add(node.right); //再右
            //所有节点都进入队列
        }
        //出队完毕，转换列表为数组
        //更直观的写法
        //定义数组
        int[] res = new int[list.size()];//确定长短
        //列表数据转移到数组
        for(int i = 0; i < list.size(); i++) res[i] = list.get(i);
        return res;

    }
}

大概是没有调用流的原因，速度快了很多。执行结果： 通过

显示详情

执行用时：1 ms, 在所有 Java 提交中击败了99.74%的用户

内存消耗：38.7 MB, 在所有 Java 提交中击败了17.31%的用户

大家的思路都差不多，学习，主要还是队列这种的基本初始化都不清楚。

再默写一遍记忆写法，尤其是队列和列表的定义方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
   
    public int[] levelOrder(TreeNode root) {
   
        if (root == null) return new int [0];
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        ArrayList<Integer> l = new ArrayList<>();
        while (!q.isEmpty()) {
   
            TreeNode node = q.poll();
            l.add(node.val);
            if (node.left != null) q.offer(node.left);
            if (node.right != null) q.offer(node.right);
        }
        int [] res = new int[l.size()];
        for (int i = 0; i < l.size(); i++) res[i] = l.get(i);
        return res;
    }
}

学习他人：

方法一:

AmmoMercyL1 2020-04-08

简单的层序遍历

class Solution {
   
    public int[] levelOrder(TreeNode root) {
   
        if(root==null)return new int[0];
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        List<Integer> list=new ArrayList<Integer>();
        queue.add(root);
        while(!queue.isEmpty()){
   
            TreeNode node=queue.poll();
            list.add(node.val);
            if(node.left!=null)queue.add(node.left);
            if(node.right!=null)queue.add(node.right);
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

方法二：

wydxry 1 天前

执行结果： 通过 显示详情 执行用时： 1 ms , 在所有 Java 提交中击败了 99.74% 的用户 内存消耗： 38.5 MB , 在所有 Java 提交中击败了 76.48% 的用户

class Solution {
   
    public int[] levelOrder(TreeNode root) {
   
        List<Integer> res_=new ArrayList<Integer>();
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        if(root==null){
   
            int[] res=new int[0];
            return res;
        }
        q.offer(root);
        while(q.peek()!=null){
   
            TreeNode tmp=q.poll();
            if(tmp.left!=null){
   
                q.offer(tmp.left);
            }
            if(tmp.right!=null){
   
                q.offer(tmp.right);
            }
            res_.add(tmp.val);
        }
        int[] res=new int[res_.size()];
        for(int i=0;i<res.length;i++){
   
            res[i]=res_.get(i);
        }
        return res;
    }
}

方法三：

题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。

BFS 通常借助 队列 的先入先出特性来实现。

K神 作者：jyd
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/mian-shi-ti-32-i-cong-shang-dao-xia-da-yin-er-ch-4/
来源：力扣（LeetCode）