这是一道 困难 题

https://leetcode.cn/problems/serialize-and-deserialize-binary-tree/

题目

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

示例 1：

输入：root = [1,2,3,null,null,4,5]
输出：[1,2,3,null,null,4,5]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

提示：

• 树中结点数在范围 $[0,10^4]$ 内
• $-1000<=Node.val<=1000$

---

深度优先搜索（前序遍历）

通过常规前序遍历序列，我们可以直接知道根节点（即第一个节点），但是无法知道接下来的第二个节点是在根节点的左边还是右边。

如上图给定的前序序列 [1, 2, 3, 4, 5]，我们只能明确根节点就是 1，接下来的 节点2 是在左边还是右边就无法确定了。

上图只画了其中的两种结果，实际上还有很多种其他可能。

既然常规前序序列无法确定后面的节点是在左边还有右边，我们就需要想办法对其进行增强。

其中一种方式就是补 null 值，不管是左边还是右边为空，序列化的时候统统补个 null。这样在反序列化的时候，只要遇到 null 就说明这条路径结束了。

如下图所示：

前序序列化结果为 "1,2,null,null,3,4,null,null,5,null,null"。

反序列化的时候，第一个元素为根节点，接下来都是按照前序遍历的顺序，先走左边，直到遇到 null 结束，然后换另一边。

序列化和反序列化都是递归的实现，其中序列化有做过对应的题目 【算法题解】42. 二叉树的前序遍历 。

反序列化见代码实现。

Java 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        dfs(sb, root);
        return sb.toString();
    }

    private void dfs(StringBuilder sb, TreeNode root){
        if(sb.length() != 0){
            sb.append(",");
        }

        // 边界条件
        if (root == null){
            sb.append("null");
            return;
        }

        sb.append(root.val);
        dfs(sb, root.left);
        dfs(sb, root.right);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] vals = data.split(",");
        return decode(vals);
    }

    private int desIndex = 0;

    private TreeNode decode(String[] vals){
        String nodeVal = vals[desIndex++];
        // 边界条件
        if(nodeVal.equals("null")){
            return null;
        }

        TreeNode node = new TreeNode(Integer.valueOf(nodeVal));

        node.left = decode(vals);
        node.right = decode(vals);

        return node;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

Go 代码实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

type Codec struct {
    
}

func Constructor() Codec {
    return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
    sb := &strings.Builder{}
    var dfs func(*TreeNode)
    dfs = func(node *TreeNode) {
        if len(sb.String()) != 0 {
            sb.WriteString(",")
        }
        if node == nil {
            sb.WriteString("null")
            return
        }
        sb.WriteString(strconv.Itoa(node.Val))
        dfs(node.Left)
        dfs(node.Right)
    }
    dfs(root)
    return sb.String()

}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {   
    vals := strings.Split(data, ",") 

    var decode func() *TreeNode

    decode = func() *TreeNode {
        nodeVal := vals[0]  
        vals = vals[1:]
        if nodeVal == "null" {
            return nil
        }

        Val, _ := strconv.Atoi(nodeVal)
        
        node := &TreeNode{Val, decode(), decode()}
        return node
    }

    return decode()
}


/**
 * Your Codec object will be instantiated and called as such:
 * ser := Constructor();
 * deser := Constructor();
 * data := ser.serialize(root);
 * ans := deser.deserialize(data);
 * 
 */

复杂度分析

时间复杂度：$O(N)$，N 为二叉树的节点个数。其中序列化的时候需要遍历二叉树中的每一个节点，时间复杂度为$O(N)$。反序列化的时候同样每个节点遍历一次，时间复杂度为$O(N)$。总和为$O(2N)$，忽略常数后为$O(N)$。

空间复杂度：$O(N)$，N 为二叉树的节点个数。序列化和反序列化的调用栈深度都是最大为 N。 序列化后生成的字符串数组，除了 null 值外剩余的就是 N 个节点的值。

---

广度优先搜索（层序遍历）

广度优先搜索的解法思路和深度优先搜索类似，都是在序列化的时候补 null 值。

以上图为例，序列化结果为："1,2,3,null,null,4,5,null,null,null"。

反序列化步骤为：

1. 将序列化字符串转换为字符串数组，命名为 vals 。
2. 第一个节点为根节点，如果是“null”，就直接返回 null，反序列化结束。否则就用第一个值创建根节点，并入队。此时 vals 的第一个值已使用，下一次将从第二个值取值，以此类推，每次取值都往后挪一位。
3. 从队列中出队一个节点，然后分别从 vals 数组中取两个值用来构建左右节点。同样的，如果是“null”，就直接跳过；否则就用对应的值分别创建左右节点，并依次入队。
4. 重复步骤3，直到队列为空。

Java 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    private Queue<TreeNode> queue = new LinkedList<>();

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        
        queue.offer(root);
        while(!queue.isEmpty()){
            if(sb.length() != 0){
                sb.append(",");
            }

            TreeNode node = queue.poll();
            if(node == null){
                sb.append("null");
            }else{
                sb.append(node.val);
                queue.offer(node.left);
                queue.offer(node.right);
            }
        }
        return sb.toString();
    }


    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] vals = data.split(",");
        if(vals[0].equals("null")){
            return null;
        }
        
        TreeNode root = new TreeNode(Integer.valueOf(vals[0]));
        queue.offer(root);
        int index = 1;
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();

            String leftVal = vals[index++];
            if(!leftVal.equals("null")){
                TreeNode leftNode = new TreeNode(Integer.valueOf(leftVal));
                node.left = leftNode;
                queue.offer(leftNode);
            }

            String rightVal = vals[index++];
            if(!rightVal.equals("null")){
                TreeNode rightNode = new TreeNode(Integer.valueOf(rightVal));
                node.right = rightNode;
                queue.offer(rightNode);
            }
        }
        
        return root;
    }

}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

Go 代码实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

type Codec struct {
    
}

func Constructor() Codec {
    return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
    sb := &strings.Builder{}

    queue := []*TreeNode{root}

    for len(queue) > 0 {
        node := queue[0]
        queue = queue[1:]
        if node == nil {
            sb.WriteString("null,")
        }else {
            sb.WriteString(strconv.Itoa(node.Val))
            sb.WriteString(",")
            queue = append(queue, node.Left)
            queue = append(queue, node.Right)
        }
    }
    return sb.String()

}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {   
    vals := strings.Split(data, ",") 

    if vals[0] == "null" {
        return nil
    }

    Val, _ := strconv.Atoi(vals[0])
    vals = vals[1:]
    root := &TreeNode{Val, nil, nil}
    queue := []*TreeNode{root}
    
    for len(queue) > 0 {
        node := queue[0]
        queue = queue[1:]

        // 左节点
        if vals[0] != "null" {
            leftVal, _ := strconv.Atoi(vals[0])
            leftNode := &TreeNode{leftVal, nil, nil}
            node.Left = leftNode
            queue = append(queue, leftNode)
        }
        vals = vals[1:]

        // 右节点
        if vals[0] != "null" {
            rightVal, _ := strconv.Atoi(vals[0])
            rightNode := &TreeNode{rightVal, nil, nil}
            node.Right = rightNode
            queue = append(queue, rightNode)
        }
        vals = vals[1:]

    }
 

    return root
    
}


/**
 * Your Codec object will be instantiated and called as such:
 * ser := Constructor();
 * deser := Constructor();
 * data := ser.serialize(root);
 * ans := deser.deserialize(data);
 */

复杂度分析

时间复杂度：$O(N)$，N 为二叉树的节点个数。其中序列化的时候需要遍历二叉树中的每一个节点，时间复杂度为$O(N)$。反序列化的时候同样每个节点遍历一次，时间复杂度为$O(N)$。

空间复杂度：$O(N)$，N 为二叉树的节点个数。序列化和反序列化时队列最大长度都是 N。序列化后生成的字符串数组，除了 null 值外剩余的就是 N 个节点的值。

---

后序遍历

和前序遍历（深度优先搜索）的思路一样，序列化的时候补 “null”。

不同的是反序列化的时候最后一个元素为根节点，然后倒着往前取值且先构建右节点，直到遇到“null”值结束。

Java 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {


    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        dfs(sb, root);
        return sb.toString();
    }

    private void dfs(StringBuilder sb, TreeNode node){
        
        if(node == null){
            if(sb.length() != 0){
                sb.append(",");
            }
            sb.append("null");
            return;
        }

        dfs(sb, node.left);
        dfs(sb, node.right);
        sb.append(",");
        sb.append(node.val);
    }

    private int index = 0;
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] vals = data.split(",");

         // 最后一个是根节点
        index = vals.length - 1;
        return decode(vals);
    }

    private TreeNode decode(String[] vals){

        String nodeVal = vals[index--];
        if(nodeVal.equals("null")){
            return null;
        }

        TreeNode node = new TreeNode(Integer.valueOf(nodeVal));
        node.right = decode(vals);
        node.left = decode(vals);

        return node;

    }

}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

Go 代码实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

type Codec struct {
    
}

func Constructor() Codec {
    return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
    sb := &strings.Builder{}

    var dfs func(node *TreeNode)

    dfs = func(node *TreeNode){
        if node == nil {
            if len(sb.String()) != 0 {
                sb.WriteString(",")
            }
            sb.WriteString("null")
            return
        }
        dfs(node.Left)
        dfs(node.Right)
        sb.WriteString(",")
        sb.WriteString(strconv.Itoa(node.Val))
    } 
    dfs(root)
    return sb.String()

}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {   
    vals := strings.Split(data, ",") 
    var decode func() *TreeNode

    decode = func() *TreeNode {
        nodeVal := vals[len(vals) - 1]  
        vals = vals[:len(vals) - 1]
        if nodeVal == "null" {
            return nil
        }

        Val, _ := strconv.Atoi(nodeVal)
        
        node := &TreeNode{Val, nil, nil}
        node.Right = decode()
        node.Left = decode()
        return node
    }

    return decode()
    
}


/**
 * Your Codec object will be instantiated and called as such:
 * ser := Constructor();
 * deser := Constructor();
 * data := ser.serialize(root);
 * ans := deser.deserialize(data);
 */

复杂度分析

同前序遍历一样。

其他思路

通过 (前序 + 中序) 或者 (后序 + 中序) 来还原二叉树

前面解过 从前序与中序遍历序列构造二叉树 和 从中序与后序遍历序列构造二叉树 这两道题，通过 前序 + 中序 或者 后序 + 中序 可以构造出二叉树。

也就是说只要我们序列化的时候生成了 前序 + 中序 或者 后序 + 中序 这种结构的数据，那么我们就可以反序列化还原二叉树。

但是，上述这种解法要求二叉树中的节点必须没有重复项，因为我们需要通过中序遍历序列来划分左右子树，划分位置就是通过根节点来确定的。如果有另一个节点和根节点的值一样，那么我们就无法确认中序遍历中哪个是根节点，也就无法划分左右子树，从而也就无法还原二叉树了。