[Java]LeetCode297. 二叉树的序列化与反序列化 | Serialize and Deserialize Binary Tree
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10693873.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.
Example:
You may serialize the following tree:1/ \2 3/ \4 5as "[1,2,3,null,null,4,5]"
Clarification: The above format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
示例:
你可以将以下二叉树：1/ \2 3/ \4 5序列化为 "[1,2,3,null,null,4,5]"
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。
0.5ms
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 public class Codec {
11
12 private TreeNode n;
13
14 // Encodes a tree to a single string.
15 public String serialize(TreeNode root) {
16 this.n = root;
17 return null;
18 }
19
20 // Decodes your encoded data to tree.
21 public TreeNode deserialize(String data) {
22 return n;
23 }
24 }
25
26 // Your Codec object will be instantiated and called as such:
27 // Codec codec = new Codec();
28 // codec.deserialize(codec.serialize(root));1ms
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 public class Codec {
11 List<Integer> lstNums = new ArrayList<>();
12 int ix = 0;
13
14 // Encodes a tree to a single string.
15 public List<Integer> serialize(TreeNode root){
16 if(root == null){
17 lstNums.add(null);
18 return lstNums;
19 }
20
21 lstNums.add(root.val);
22 serialize(root.left);
23 serialize(root.right);
24
25 return lstNums;
26 }
27
28 // Decodes your encoded data to tree.
29 public TreeNode deserialize(List<Integer> data){
30 if(ix >= data.size() || data.get(ix) == null){
31 ix++;
32 return null;
33 }
34
35 TreeNode t = new TreeNode(data.get(ix));
36 ix++;
37
38 t.left = deserialize(data);
39 t.right = deserialize(data);
40
41 return t;
42 }
43 }
44
45 // Your Codec object will be instantiated and called as such:
46 // Codec codec = new Codec();
47 // codec.deserialize(codec.serialize(root));2ms
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 public class Codec {
11
12 // Encodes a tree to a single string.
13 public String serialize(TreeNode root) {
14 StringBuilder sb = new StringBuilder();
15 traverse(root , sb);
16 sb.deleteCharAt(sb.length() - 1);
17 return sb.toString();
18 }
19
20 // Decodes your encoded data to tree.
21 public TreeNode deserialize(String data) {
22 int[] index = new int[1];
23 return buildTree(data , index);
24 }
25
26 public void traverse(TreeNode root , StringBuilder sb) {
27 if (root == null) {
28 sb.append("#,");
29 return;
30 }
31 Integer val = root.val;
32 sb.append(val.toString());
33 sb.append(',');
34 traverse(root.left , sb);
35 traverse(root.right , sb);
36 }
37
38 public TreeNode buildTree (String data , int[] index) {
39 if (index[0] >= data.length()) {
40 return null;
41 } else if (data.charAt(index[0]) == '#') {
42 index[0] += 2;
43 return null;
44 }
45 TreeNode node = new TreeNode(getValue(data , index[0]));
46 while(data.charAt(index[0]) != ',') {
47 index[0] ++;
48 }
49 index[0]++;
50 node.left = buildTree (data , index);
51 node.right = buildTree (data , index);
52 return node;
53 }
54
55 public int getValue(String data ,int index) {
56 int sign = data.charAt(index) == '-' ? -1 : 1;
57 int sum = data.charAt(index) == '-' ? 0 : data.charAt(index) - '0';
58 index++;
59 while(data.charAt(index) != ',') {
60 sum = sum * 10 + data.charAt(index) - '0';
61 index++;
62 }
63 return sum * sign;
64 }
65 }3ms
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 public class Codec {
11
12 // Encodes a tree to a single string.
13 public String serialize(TreeNode root) {
14 if (root == null) {
15 return "";
16 }
17
18 StringBuilder sb = new StringBuilder();
19 serialize(root, sb);
20
21 return sb.toString();
22 }
23
24 public void serialize(TreeNode node, StringBuilder sb) {
25 sb.append(node.val);
26 sb.append(",");
27
28 if (node.left != null) {
29 serialize(node.left, sb);
30 }
31 else {
32 sb.append("/");
33 }
34
35 if (node.right != null) {
36 serialize(node.right, sb);
37 }
38 else {
39 sb.append("/");
40 }
41 }
42
43 private char chs[];
44 private int start;
45
46 // Decodes your encoded data to tree.
47 public TreeNode deserialize(String data) {
48 chs = data.toCharArray();
49 start = 0;
50
51 return deserialize();
52 }
53
54 private TreeNode deserialize() {
55 TreeNode root = null;
56 StringBuilder sb = new StringBuilder();
57 int i;
58
59 for (i = start; i < chs.length; i++) {
60 if (chs[i] == ',') {
61 break;
62 }
63
64 if (chs[i] == '/') {
65 break;
66 }
67
68 sb.append(chs[i]);
69 }
70
71 start = i + 1;
72
73 if (sb.length() == 0) {
74 return root;
75 }
76
77 root = new TreeNode(Integer.valueOf(sb.toString()));
78 root.left = deserialize();
79 root.right = deserialize();
80
81 return root;
82 }
83 }
84
85 // Your Codec object will be instantiated and called as such:
86 // Codec codec = new Codec();
87 // codec.deserialize(codec.serialize(root));4ms
1 public class Codec {
2 public String serialize(TreeNode root) {
3 StringBuilder builder = new StringBuilder();
4 serialize(root, builder);
5 return builder.toString();
6 }
7
8 private void serialize(TreeNode node, StringBuilder builder) {
9 if (builder.length() > 0) builder.append(',');
10 if (node == null) {
11 builder.append('#');
12 return;
13 }
14 builder.append(node.val);
15 serialize(node.left, builder);
16 serialize(node.right, builder);
17 }
18
19 public TreeNode deserialize(String data) {
20 return deserialize(data, new int[]{0});
21 }
22
23 private TreeNode deserialize(String data, int[] i) {
24 int left = i[0], right = i[0];
25 while (right < data.length() && data.charAt(right) != ',') right++;
26 TreeNode node = right > left ? fromValue(data.substring(left, right)) : null;
27 i[0] = ++right;
28 if (node != null) {
29 node.left = deserialize(data, i);
30 node.right = deserialize(data, i);
31 }
32 return node;
33 }
34
35 private TreeNode fromValue(String value) {
36 return "#".equals(value) ? null : new TreeNode(Integer.valueOf(value));
37 }
38 }5ms
1 /**
2 * Definition for a binary tree node.
3 * public class TreeNode {
4 * int val;
5 * TreeNode left;
6 * TreeNode right;
7 * TreeNode(int x) { val = x; }
8 * }
9 */
10 public class Codec {
11
12 int index = 0;
13 // Encodes a tree to a single string.
14 public String serialize(TreeNode root) {
15 StringBuilder sb = new StringBuilder();
16 serialize(root, sb);
17 System.out.println(sb);
18 return sb.toString();
19 }
20 public void serialize(TreeNode root,StringBuilder sb) {
21 if(root==null){
22 sb.append("#,");
23 return;
24 }
25 sb.append(root.val+",");
26 serialize(root.left,sb);
27 serialize(root.right,sb);
28 }
29
30 // Decodes your encoded data to tree.
31 public TreeNode deserialize(String data) {
32 index = 0;
33 return deserialize1(data);
34 }
35
36 public TreeNode deserialize1(String data){
37 if(index>=data.length()) return null;
38 if(data.charAt(index)=='#'){
39 index+=2;
40 return null;
41 }
42 int cIndex = data.indexOf(',',index);
43 if(cIndex==-1)cIndex = data.length();
44 //System.out.printf("index %d cIndex %d \n",index,cIndex);
45 TreeNode node = new TreeNode(Integer.valueOf(data.substring(index,cIndex)));
46 index = cIndex+1;
47 node.left = deserialize1(data);
48 node.right = deserialize1(data);
49 return node;
50 }
51 }
52
53 // Your Codec object will be instantiated and called as such:
54 // Codec codec = new Codec();
55 // codec.deserialize(codec.serialize(root));转载于:https://www.cnblogs.com/strengthen/p/10693873.html
[Java]LeetCode297. 二叉树的序列化与反序列化 | Serialize and Deserialize Binary Tree相关推荐
- 297. Serialize and Deserialize Binary Tree
Title 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据. 请设计一个算 ...
- LeetCode 297 Serialize and Deserialize Binary Tree
题目描述 Serialization is the process of converting a data structure or object into a sequence of bits s ...
- lc 297. Serialize and Deserialize Binary Tree
使用任意方法序列化一个二叉树. https://leetcode.com/problems/serialize-and-deserialize-binary-tree/ 原来带有None作为结束标志的 ...
- Java实现 LeetCode 297 二叉树的序列化与反序列化
297. 二叉树的序列化与反序列化 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得 ...
- LeetCode Java刷题笔记—297. 二叉树的序列化与反序列化
297. 二叉树的序列化与反序列化 请实现两个函数,分别用来序列化和反序列化二叉树.这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化 ...
- 【LeetCode】【HOT】297. 二叉树的序列化与反序列化（BFS）
[LeetCode][HOT]297. 二叉树的序列化与反序列化 文章目录 [LeetCode][HOT]297. 二叉树的序列化与反序列化 package hot;import java.util. ...
- 【leetcode】二叉树，297二叉树的序列化与反序列化
297. 二叉树的序列化与反序列化 前言 题目难度:困难 一.题目描述 二.前序遍历解法 三.后序遍历解法 四.中序遍历解法 五.层级遍历解法 前言 如果你看过下面这几篇,那这道题应该对你来说信手拈来 ...
- python代码实现二叉树的序列化和反序列化
python代码实现二叉树的序列化和反序列化 二叉树的序列化 二叉树的序列化是指:把一棵二叉树按照某种遍历方式的结果以某种格式保存为字 符串,从而使得内存中建立起来的二叉树可以持久保存. 二叉树的反序 ...
- 二叉树的序列化与反序列化
题目: 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据. 请设计一个算法来 ...
最新文章
- ecilpse连接oracle ojdbc驱动
- GPU 2014年4月 性能排名
- android设置title_所见即所得的 Android 自动化神器，用 Automate 一键收藏文章
- Exchange2013恢复已删除用户邮箱
- Swift基础语法: 25 - Swift的类和结构体
- 如何在钉钉上开发自己的应用_对企业来说无代码开发平台是否安全
- 基于LSTM网络的藏头诗和古诗自动生成（附完整代码和数据）
- mysql索引失效的常见原因
- 学习是对自己最好的投资
- Java将文件转换成二维码
- 欢迎清风艾艾在ITPUB博客安家!
- XMind2TestCase 库的使用及自定义导出文档的格式
- 气质妈妈“特色”制胜巧心计 情系旗袍书画淘宝梦
- 144个stm32开发相关的问题，看你了解几个
- MUR860D-ASEMI快恢复二极管的作用
- Java-JWT Utils
- 南京理工计算机科学与技术怎样,南京理工大学计算机科学与技术学院
- 雅克比行列式补充和曲面的参数方程求导表示法向量
- 微信小程序录音上传php代码,小程序实现录音上传功能
- 什么app可以查车停车记录_捷停车app怎么查具体停车场
热门文章
- idea中如何打开RunDashboard窗口，微服务最实用设置
- 使用JPA进行update操作时，报org.springframework.beans.factory.BeanCreationException: Error creating bean with
- docker一步安装mysql，docker的魅力就在于此
- 2022-2028中国工作服市场现状及未来发展趋势
- 2022-2028年中国镀金属膜行业市场研究及前瞻分析报告
- 经常使用的npm命令
- docred数据集情况笔记
- Pytorch - GPU ID 指定 pytorch gpu 指定
- Pytorch: 命名实体识别: BertForTokenClassification/pytorch-crf
- python any()和all()用法