BM39-序列化二叉树

题目

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。

二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#）。

二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，可以根据层序遍历的方案序列化，如下图:

层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。

当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。

数据范围：节点数 n≤100n≤100，树上每个节点的值满足 0≤val≤1500≤val≤150

要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)。

示例1

输入：{1,2,3,#,#,6,7}

返回值：{1,2,3,#,#,6,7}

说明：如题面图

示例2

输入：{8,6,10,5,7,9,11}

返回值：{8,6,10,5,7,9,11}

---

思路

序列化 Serialize ：

借助队列，对二叉树做层序遍历，并将越过叶节点的 # 也打印出来。

• 特例处理： 若 root 为空，则直接返回空字符串 " " ；
• 初始化： 序列化字符串build；队列 queue （根节点 root 先入队）；
• 层序遍历： 当 queue 为空时跳出；

1. 节点出队，记为 t ；
2. 若 t 不为空：① 将 t 的左、右子节点入队，② 添加字符 t.val；
3. 否则（若 t 为空）：添加 "#" ；

• 返回值： build.toString()；

反序列化 Deserialize ：

利用队列按层构建二叉树，借助一个指针 i 指向节点 t 的左、右子节点，每构建一个 t 的左、右子节点，指针 i 就向右移动 1 位。

• 特例处理： 若 str 为空，直接返回 #；
• 初始化： 序列化字符串数组 s（用逗号隔开）；队列 queue（包含 root ）；根节点 root （值为 s[0] ）；指针 i = 1 ；
• 按层构建： 当 queue 为空时跳出；

1. 节点出队，记为 t；
2. 构建 t 的左子节点：t.left 的值为 s[i] ，并将 t.left 入队；执行 i++；
3. 构建 t 的右子节点：t.right 的值为 s[i] ，并将 t.right 入队；执行 i++；

• 返回值： 返回根节点 root 即可；

---

代码

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }
}
*/
public class Solution {
    String Serialize(TreeNode root) {
        if (root == null) {
            return "";
        }

        StringBuilder build = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode t = queue.poll();
            if (t != null) {
                queue.add(t.left);
                queue.add(t.right);
                build.append(t.val + ",");
            } else {
                build.append("#,");
            }
        }
        return build.toString();
    }

    TreeNode Deserialize(String str) {
        if (str == null || str.length() <= 0) {
            return null;
        }
        String[] s = str.split(",");
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode root = new TreeNode(Integer.parseInt(s[0]));
        queue.add(root);
        int i = 1;

        while (!queue.isEmpty()) {
            TreeNode t = queue.poll();
            //构建左子节点
            if (!s[i].equals("#")) {
                TreeNode left = new TreeNode(Integer.parseInt(s[i]));
                t.left = left;
                queue.add(left);
            }
            i++;
            //构建右子节点
            if (!s[i].equals("#")) {
                TreeNode right = new TreeNode(Integer.parseInt(s[i]));
                t.right = right;
                queue.add(right);
            }
            i++;
        }
        return root;
    }
}