[NeetCode 150] Serialize and Deserialize Binary Tree

Serialize and Deserialize Binary Tree

Implement an algorithm to serialize and deserialize a binary tree.

Serialization is the process of converting an in-memory structure into a sequence of bits so that it can be stored or sent across a network to be reconstructed later in another computer environment.

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. There is no additional restriction on how your serialization/deserialization algorithm should work.

Note: The input/output format in the examples is the same as how NeetCode serializes a binary tree. You do not necessarily need to follow this format.

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:

复制代码
0 <= The number of nodes in the tree <= 1000.
-1000 <= Node.val <= 1000

Solution

A classic problem to rebuild a tree from serialized data is building a tree from pre-order traversal and in-order traversal. To do this, we can use recursion function to dive into the subsequence of pre-order and in-order traversal. The first node in pre-order sequence must the root, and the sequence on the left of root in the in-order sequence must be the left child tree of the root, so as the sequence on the right.

However, if we rethink about the process. Why cannot we rebuild the tree only from pre-order traversal? That's because we cannot divide the sequences of the left child tree and right child tree. So, we need to mark where the left child tree ends by adding none nodes. If meet none nodes in DFS, it is time to return. By doing this, we can know where the left child tree ends and start to DFS the right child tree.

Code

Rebuild from pre-order and in-order traversal.

py 复制代码
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Codec:
    
    # Encodes a tree to a single string.
    def serialize(self, root: Optional[TreeNode]) -> str:
        if not root:
            return ''
        preo = []
        ino = []
        def inorder(node):
            if node.left:
                inorder(node.left)
            ino.append(str(node.val))
            if node.right:
                inorder(node.right)
        
        def preorder(node):
            preo.append(str(node.val))
            if node.left:
                preorder(node.left)
            if node.right:
                preorder(node.right)
        
        preorder(root)
        prestr = ','.join(preo)
        inorder(root)
        instr = ','.join(ino)
        return prestr+'#'+instr

        
    # Decodes your encoded data to tree.
    def deserialize(self, data: str) -> Optional[TreeNode]:
        if len(data) == 0:
            return None
        preorder = data.split('#')[0].split(',')
        inorder = data.split('#')[1].split(',')
        pre_map = {}
        in_map = {}
        for i in range(len(preorder)):
            pre_map[preorder[i]] = i
            in_map[inorder[i]] = i
        
        def dfs(prele, preri, inle, inri):
            if prele == preri:
                return TreeNode(int(preorder[prele]), None, None)
            if prele > preri:
                return None
            root = preorder[prele]
            inrootpos = in_map[root]
            ls_size = inrootpos-inle
            rs_size = inri-inrootpos
            ls = dfs(prele+1, prele+ls_size, inle, inrootpos-1)
            rs = dfs(prele+ls_size+1, preri, inrootpos+1, inri)
            return TreeNode(int(root), ls, rs)
        
        return dfs(0, len(preorder)-1, 0, len(inorder)-1)

Rebuild by adding none node to pre-order traversal.

py 复制代码
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Codec:
    
    # Encodes a tree to a single string.
    def serialize(self, root: Optional[TreeNode]) -> str:
        res = []

        def dfs(node):
            if not node:
                res.append("N")
                return
            res.append(str(node.val))
            dfs(node.left)
            dfs(node.right)

        dfs(root)
        return ",".join(res)
        
    # Decodes your encoded data to tree.
    def deserialize(self, data: str) -> Optional[TreeNode]:
        vals = data.split(",")
        self.i = 0

        def dfs():
            if vals[self.i] == "N":
                self.i += 1
                return None
            node = TreeNode(int(vals[self.i]))
            self.i += 1
            node.left = dfs()
            node.right = dfs()
            return node

        return dfs()
相关推荐
涡能增压发动积4 分钟前
Browser-Use Agent使用初体验
人工智能·后端·python
JustNow_Man1 小时前
【LLM】 BaseModel的作用
数据库·人工智能·python·uv
hans汉斯2 小时前
【建模与仿真】二阶邻居节点信息驱动的节点重要性排序算法
人工智能·python·算法·分类·数据挖掘·排序算法·xca
青衫客362 小时前
Python中的sys.path与PYTHONPATH全解析:模块导入路径的底层机制与最佳实践
python
御水流红叶2 小时前
安卓加固脱壳
android·开发语言·python
AI Echoes2 小时前
ChatGPT、Playground手动模拟Agent摘要缓冲混合记忆功能
人工智能·python·langchain
热心不起来的市民小周3 小时前
基于 Flask 和 MySQL 的期货数据分析系统
python·mysql·flask
万粉变现经纪人3 小时前
如何解决pip安装报错ModuleNotFoundError: No module named ‘scikit-learn’问题
人工智能·python·plotly·pycharm·flask·scikit-learn·pip
西猫雷婶3 小时前
python学智能算法(三十一)|SVM-Slater条件理解
人工智能·python·算法·机器学习·支持向量机