2022-2-24剑指offer day14

题1：

JZ78 把二叉树打印成多行

描述

给定一个节点数为 n 二叉树，要求从上到下按层打印二叉树的 val 值，同一层结点从左至右输出，每一层输出一行，将输出的结果存放到一个二维数组中返回。例如：
给定的二叉树是{1,2,3,#,#,4,5}

该二叉树多行打印层序遍历的结果是 [ [1], [2,3], [4,5] ] 数据范围：二叉树的节点数

\le n \le 10000≤n≤1000，0 \le val \le 10000≤val≤1000

要求：空间复杂度

输入描述：

给定一个二叉树的根节点

 1 import java.util.*;
 2 
 3 
 4 /*
 5 public class TreeNode {
 6     int val = 0;
 7     TreeNode left = null;
 8     TreeNode right = null;
 9 
10     public TreeNode(int val) {
11         this.val = val;
12 
13     }
14 
15 }
16 */
17 public class Solution {
18     ArrayList > Print(TreeNode pRoot) {
19         ArrayList> ans=new ArrayList<>();
20         if (pRoot==null) return ans;
21         Queue queue=new LinkedList<>();
22         queue.offer(pRoot);
23         while (!queue.isEmpty()){
24             int size=queue.size();
25             ArrayList list=new ArrayList<>();
26             for (int i=0;i) {
27                 TreeNode p=queue.poll();
28                 list.add(p.val);
29                 if (p.left!=null) queue.offer(p.left);
30                 if (p.right!=null) queue.offer(p.right);
31             }
32             ans.add(list);
33         }
34         return ans;
35     }
36     
37 }

思路：队列实现层序遍历。

题2：

JZ37 序列化二叉树

描述

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#）

二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。例如，可以根据层序遍历的方案序列化，如下图:

层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。数据范围：节点数

\le 100n≤100，树上每个节点的值满足 0 \le val \le 1500≤val≤150

要求：序列化和反序列化都是空间复杂度

 1 import java.util.*;
 2 /*
 3 public class TreeNode {
 4     int val = 0;
 5     TreeNode left = null;
 6     TreeNode right = null;
 7 
 8     public TreeNode(int val) {
 9         this.val = val;
10 
11     }
12 
13 }
14 */
15 public class Solution {
16     TreeNode emptyNode=new TreeNode(101);
17     String Serialize(TreeNode root) {
18         if (root==null) return "";
19         StringBuffer sb=new StringBuffer();
20         Queue queue=new LinkedList<>();
21         queue.offer(root);
22         while (!queue.isEmpty()) {
23             TreeNode temp=queue.poll();
24             sb.append(temp.val+"_");
25             if (!temp.equals(emptyNode)){
26                 queue.offer(temp.left==null?emptyNode:temp.left);
27                 queue.offer(temp.right==null?emptyNode:temp.right);
28             }
29          }
30         System.out.print(sb.toString());
31         return sb.toString();
32     }
33     TreeNode Deserialize(String str) {
34         if (str.equals("")) return null;
35         String[] s=str.split("_");
36         Queue queue=new LinkedList<>();
37         TreeNode root=new TreeNode(Integer.parseInt(s[0]));
38         queue.offer(root);
39         for (int i=1;i){
40             TreeNode temp=queue.poll();
41             int a=Integer.parseInt(s[i]),b=Integer.parseInt(s[i+1]);
42             if (a!=101) {
43                 temp.left=new TreeNode(a);
44                 queue.offer(temp.left);
45             }
46             if (b!=101) {
47                 temp.right=new TreeNode(b);
48                 queue.offer(temp.right);
49             }
50         }
51         return root;
52     }
53 }

思路：层序遍历实现序列化。注意要分隔符来处理val>10的情况，emptyNode处理空节点的情况。

每日一题练习

2022-2-24剑指offer day14

描述

输入描述：

描述

相关

标签