[LeetCode] 297. Serialize and Deserialize Binary Tree

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.

Clarification: The input/output 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.

Example 1:

Input: root = [1,2,3,null,null,4,5]
Output: [1,2,3,null,null,4,5]

Example 2:

Input: root = []
Output: []

Constraints:

• The number of nodes in the tree is in the range [0, 104].
• -1000 <= Node.val <= 1000

二叉树的序列化和反序列化。

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

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

提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/serialize-and-deserialize-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目即是题意，序列化是需要把二叉树convert成一个字符串；同时这个字符串也可以被convert回对应的二叉树。影子题449题。这道题有两种思路，一种是BFS层序遍历，一种是preorder前序遍历。

首先是BFS。序列化的部分是按照level order traversal的思路遍历树的节点。如果当前节点为NULL则存入"null"；若不是，则正常存入当前节点，再遍历当前节点的左孩子和右孩子。记得存入每个节点之后加一个空格，这样方便接下来的反序列。

反序列化是将一个字符串的input转换成树的结构。首先将字符串中第一个node拿到，当做根节点。之后还是根据BFS的思路遍历input，如果不为"null"则做成一个节点并加入queue；但是这里反序列化可以跳过null，不需要把null也转换成一个空的节点放入二叉树。

时间O(n)

空间O(n)

Java实现

public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null)
            return "";
        StringBuilder res = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if (cur == null) {
                res.append("null ");
                continue;
            }
            res.append(cur.val + " ");
            queue.offer(cur.left);
            queue.offer(cur.right);
        }
        return res.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data == "")
            return null;
        String[] str = data.split(" ");
        TreeNode root = new TreeNode(Integer.parseInt(str[0]));
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        for (int i = 1; i < str.length; i++) {
            TreeNode cur = queue.poll();
            if (!str[i].equals("null")) {
                cur.left = new TreeNode(Integer.parseInt(str[i]));
                queue.offer(cur.left);
            }
            i++;
            if (!str[i].equals("null")) {
                cur.right = new TreeNode(Integer.parseInt(str[i]));
                queue.offer(cur.right);
            }
        }
        return root;
    }
}

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

 

JavaScript实现

/**
 * Encodes a tree to a single string.
 *
 * @param {TreeNode} root
 * @return {string}
 */
var serialize = function (root) {
    let stack = [];
    let serialize = [];
    if (root == null) return [];
    stack.push(root);
    while (stack.length > 0) {
        let cur = stack.shift();
        serialize.push(cur ? cur.val : null);
        if (cur != null) {
            stack.push(cur.left);
            stack.push(cur.right);
        }
    }
    return serialize;
};

var deserialize = function (data) {
    if (data[0] == null) return null;
    let node = new TreeNode(data.shift());
    let queue = [node];
    while (queue.length > 0) {
        let node = queue.shift();
        left = data.shift();
        right = data.shift();
        node.left = (left == null) ? null : new TreeNode(left);
        node.right = (right == null) ? null : new TreeNode(right);
        if (node.left != null) {
            queue.push(node.left);
        }
        if (node.right != null) {
            queue.push(node.right);
        }
    }
    return node;
};

/**
 * Your functions will be called as such:
 * deserialize(serialize(root));
 */

 

再来是前序遍历的思路。既然是前序遍历，那么还是先处理当前节点，再处理他的左孩子和右孩子。序列化的部分，还是需要对空节点记录，我这里还是记录成"null" + 一个空格，然后调用helper函数递归处理左孩子和有孩子。反序列化的时候，除了一开始需要把data分开，同时需要把data分开的内容放入一个queue，这样每弹出一个元素，我们还是可以通过一个helper函数递归处理左孩子和右孩子节点。这个做法比之前BFS的做法稍稍快一点。

时间O(n)

空间O(n)

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();
        helper(root, sb);
        return sb.toString();
    }

    private void helper(TreeNode root, StringBuilder sb) {
        if (root == null) {
            // sb.append("#").append(",");
            sb.append("null ");
        } else {
            sb.append(root.val).append(" ");
            helper(root.left, sb);
            helper(root.right, sb);
        }
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        // corner case
        if (data == null) {
            return null;
        }
        // normal case
        String[] strs = data.split(" ");
        Queue<String> queue = new LinkedList<>();
        Collections.addAll(queue, strs);
        return helper(queue);
    }

    private TreeNode helper(Queue<String> queue) {
        if (queue.isEmpty()) {
            return null;
        }
        String s = queue.poll();
        if (s.equals("null")) {
            return null;
        }
        TreeNode root = new TreeNode(Integer.parseInt(s));
        root.left = helper(queue);
        root.right = helper(queue);
        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));

 

相关题目

297. Serialize and Deserialize Binary Tree

428. Serialize and Deserialize N-ary Tree

449. Serialize and Deserialize BST

LeetCode 题目总结