从上到下打印二叉树（双括号初始化、实例初始化块）

最新推荐文章于 2022-08-10 15:04:41 发布

.西瓜.

最新推荐文章于 2022-08-10 15:04:41 发布

阅读量129

点赞数

分类专栏：算法文章标签：数据结构算法 java

本文链接：https://blog.csdn.net/lllllljr/article/details/120843400

版权

算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

打印二叉树Ⅰ

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

例如:

给定二叉树: [3,9,20,null,null,15,7],
   3  
  / \
 9  20
 /   \    
15    7

[3,9,20,15,7]

bfs广度优先

    class Solution {
        public int[] levelOrder(TreeNode root) {
            if(root == null)return new int[0];
            //bfs广度优先
            Queue<TreeNode> queue = new LinkedList<>(){{add(root);}};  //双括号初始化
            ArrayList<Integer> ans = new ArrayList<>();
            while(!queue.isEmpty()){
                TreeNode node = queue.poll();   //队列接口的poll()方法返回并移除容器前面的元素。它删除容器中的元素。当Queue为空时，该方法不会引发异常，而是返回null。
                ans.add(node.val);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
            }
            int[] res = new int[ans.size()];
            for(int i = 0; i < ans.size(); i++){
                res[i] = ans.get(i);  //get() 方法通过索引值获取动态数组中的元素
            }
            return res;
        }
    }

}

双括号初始化

例子
1. 新建一个列表并赋初值A、B、C

ArrayList<String> list = new ArrayList<String>() {{
    add("A");
    add("B");
    add("C");
}};

	2.  还有其他集合比如HashMap的初始化：

Map map = new HashMap() {{ 
　　put("Name", "Unmi"); 
　　put("QQ", "1125535"); 
}};

这里以ArrayList的例子解释，首先第一层花括号定义了一个继承于ArrayList的匿名内部类 (Anonymous Inner Class)：

定义了一个继承于ArrayList的类，它没有名字

new ArrayList(){ //在这里对这个类进行具体定义 };

第二层花括号实际上是这个匿名内部类实例初始化块 (Instance Initializer Block)（或称为非静态初始化块）：

new ArrayList(){ {
//这里是实例初始化块，可以直接调用父类的非私有方法或访问非私有成员
}

种方法一定程度上使代码更简洁，但同时可能降低可读性；还可能会造成内存泄露，在序列化时可能也会出现一些问题（未测试）。

实例初始化块

Java 语言中，存在三种操作：方法、构造函数和初始化块。其中初始化块又分为实例初始化块 ( IIB ) 和静态初始化块
实例初始化块用于初始化实例变量。
实例初始化块会在初始化类的一个实例时执行，而且在构造函数之前就执行。并且每次创建类的对象时它们都会执行。
实例化块的语法

实例初始化块一般放在构造函数之前，使用大括号 {} 扩起来的代码。语法结构一般如下

class JavaTester
{
    // 实例化块
    { 
        System.out.println("IIB block");
    }
    // 构造函数
    JavaTester()
    {
        System.out.println("Constructor Called");
    }
    public static void main(String[] args)
    {
        JavaTester a = new JavaTester();
    }
}

注意，实例化块并不是类的必须。只是一个可选项。用于抽出构造函数的公共部分单独执行而已。

一个类中包含多个实例初始化块
类中的实例初始化块并不是类所必须的，而且，不限数量。一个类既可以没有实例初始化块，也可以有多个实例初始化块。
如果一个类有多个实例初始化块，那么它们会按照顺序从上到下依次执行，也就是说，定义在类顶部的实例初始化块最先执行。
父类的实例初始化块在子类的构造函数中调用 super() 之后立即运行。编译器会在执行当前类的实例初始化块之前先执行父类的实例初始化块。
- 因此，在继承体系中，实例初始化块和构造函数的执行顺序如下：

执行父类的实例初始化块

执行父类的构造函数

执行当前类的实例初始化块

执行当前类的构造函数

总结：每次创建新实例时都会运行实例初始化块
初始化块按它们在类中出现的顺序运行
如果存在父类，则首先会实例化父类然后在调用当前类的实例初始化块，最后再调用当前类的构造函数。

打印二叉树Ⅱ

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

例如:

给定二叉树: [3,9,20,null,null,15,7],
    3    
  /   \   
 9    20
/       \    
15       7

返回其层次遍历结果：

[ [3], [9,20], [15,7] ]

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root != null){
            queue.add(root);
        }
        while(!queue.isEmpty()){       //每次遍历队列里储存的都是同一层的
            List<Integer> tmp = new ArrayList<>();
            //for循环从高到低秀到我了，完美避免size的大小改变
            for(int i = 0; i < queue.size(); i++){   //同一层的  ，每个i代表当层的一个点 
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) queue.add(node.left);      //把该点的左右子节点都加入下一层
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
}

关于数组变量嵌套写法：

List＜List＜Integer＞＞ res=new ArrayList＜＞()；

其实就是在List中存放List: 可以理解示例中的为向res中继续加list

 List<List<Integer>> res = new ArrayList<ArrayList<Integer>>();
 List<Integer> list = new ArrayList<Integer>(); list.add(1);
 list.add(2); res.add(list);

注意题中queue的size随时会改变，所以要for循环从高到低，完美避免size的大小改变

打印二叉树Ⅲ

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:

给定二叉树: [3,9,20,null,null,15,7],
   3   
  / \   
 9  20
 /   \
15    7

返回其层次遍历结果：

[ [3], [20,9], [15,7] ]

提示：

节点总数 <= 1000

方法一：层序遍历 + 倒序

层序遍历，遇到符合条件的先将List反转再加入总List中
这个方法是把这一层的数组都记录完后整体反转

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> res = new ArrayList<>();
            Queue<TreeNode> queue = new LinkedList<>();
            if(root != null){
                queue.add(root);
            }
            //不能用count = 0,因为这个循环的次数和当前层数的节点数有关
            //应该用res.size()来判断这是第几层
            while(!queue.isEmpty()){
                List<Integer> ans = new ArrayList<>();
                for(int i = queue.size(); i > 0; i--){
                        TreeNode node = queue.poll();
                        ans.add(node.val);
                        if(node.left != null){
                            queue.add(node.left);
                        }    
                        if(node.right != null){
                            queue.add(node.right);
                        }    
                }
                if(res.size() % 2 == 1){
                            Collections.reverse(ans);       //如果是第二层就把当前的List先反转再加入
                        }
                res.add(ans);
            }
            return res;
        }
}

方法二：层序遍历 + 双端队列

奇数层则添加至 ans尾部，
偶数层则添加至 ans头部
- 这个方法是在当前层的list插入每个数是，就按照当前层数正序插入或者倒叙插入。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> res = new ArrayList<>();
            Queue<TreeNode> queue = new LinkedList<>();
            if(root != null){
                queue.add(root);
            }
            while(!queue.isEmpty()){
                LinkedList<Integer> ans = new LinkedList<>();       //ArrayList和LinkedList有很多不同之处，比如之下用的addFirst等函数就只有LinkedList有，一个注重排序查询，一个注重删除修改。
                for(int i = queue.size(); i > 0; i--){
                    TreeNode node = queue.poll();
                    //如果是正序的话就放在队列后面（此时的ans代表的当层的）
                    if(res.size() % 2 == 0){
                        ans.addLast(node.val);
                    }else{
                        ans.addFirst(node.val);//反之如果倒叙的话加到队列最前面
                    }
                    if(node.left != null){
                        queue.add(node.left);
                    }
                    if(node.right != null){
                        queue.add(node.right);
                    }
                }
                res.add(ans);
            }
            return res;
    }
}

方法三：层序遍历 + 双端队列（奇偶层逻辑分离）

BFS 循环：循环打印奇 / 偶数层，当 deque 为空时跳出；
打印奇数层：从左向右打印，先左后右加入下层节点；
若 deque 为空，说明向下无偶数层，则跳出；
打印偶数层：从右向左打印，先右后左加入下层节点

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) deque.add(root);
        while(!deque.isEmpty()) {
            // 打印奇数层
            List<Integer> tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从左向右打印 (顺序打印)
                TreeNode node = deque.removeFirst();
                tmp.add(node.val);
                // 先左后右加入下层节点(Last先左后右 整体是顺序储存)
                if(node.left != null) deque.addLast(node.left);
                if(node.right != null) deque.addLast(node.right);
            }
            res.add(tmp);
            if(deque.isEmpty()) break; // 若为空则提前跳出

            // 打印偶数层
            tmp = new ArrayList<>();
            for(int i = deque.size(); i > 0; i--) {
                // 从右向左打印 (取队列最后面的，因为前面的是顺序储存，所以要从后往前选数)
                TreeNode node = deque.removeLast();
                tmp.add(node.val);
                // 先右后左加入下层节点 (先右后左 向队头插入 （整体也是顺序，不过是把下层节点顺序储存在这层节点的前面，原因是因为这一层的节点可能还没取完，放到队尾可能被当前层读出）)
                if(node.right != null) deque.addFirst(node.right);
                if(node.left != null) deque.addFirst(node.left);
            }
            res.add(tmp);
        }
        return res;
    }
}

.西瓜.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从上到下打印二叉树（双括号初始化、实例初始化块）

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回：[3,9,20,15,7]bfs广度优先 class Solution { public int[] levelOrder(TreeNode root) { if(root == null)return new int[.
复制链接

扫一扫