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

---

一、leetcode 297

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

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

二、为什么要反序列化？

1、给定一个二叉树的列表，需要转换成我们熟悉的链表存储形式，就能方便递归解题。
2、反序列化后可以方便本地IDE调试二叉树题。

二叉树列表：[0,1,2,None,4,None,6,7]

对应的树的结构如下：

即：链表形式

三、反序列化设计

二叉树的定义

# 树的定义
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

算法流程：

1. 特例处理： 若 data 为空，直接返回 null ；
2. 初始化： 指针 i = 1 ，根节点 root （值为 vals[0] ），队列 queue（包含 root ）
3.按层构建：

当 queue 为空时跳出；节点出队，记为 node ；

构建 node 的左子节点：node.left 的值为 data[i] ，并将 node.left 入队；
执行 i += 1 ；

构建 node 的右子节点：node.left 的值为 data[i] ，并将 node.left 入队；
执行 i += 1 ；

4.返回值： 返回根节点 root 即可；

class Codec:
    def deserialize(self, data):
        if not data:
            return
        vals, i = data, 1
        root = TreeNode(vals[0])
        queue = [root]
        
        while queue:
            node = queue.pop(0)
            
            "当指针超出列表时，子节点值为NONE，直接出循序即可"
            if i > len(data) - 1:break
            if vals[i]:
                node.left = TreeNode(vals[i])
                queue.append(node.left)

            i += 1
            "当指针超出列表时，子节点值为NONE，直接出循序即可"
            if i > len(data) - 1:break
            if vals[i]:
                node.right = TreeNode(vals[i])
                queue.append(node.right)
                
            i += 1
            
        return root
        
tree = [0, 1, 2, None, 4, None, 6, 7]
code = Codec()
root = code.deserialize(tree)

通过前序遍历，查看构建的结果是否正确：

res = []
def dfs(root):
    if not root:
        return
    res.append(root.val)
    dfs(root.left)
    dfs(root.right)

dfs(root)
print(res)

执行结果正确：

四、序列化设计

    def serialize(self, root):
        if not root:
            return []
        queue = [root]
        res = []
        while queue:
            node = queue.pop(0)
            if node:
                res.append(node.val)
                queue.append(node.left)
                queue.append(node.right)
            else:
                res.append(None)
        return res

print(code.serialize(root))

结果如下：

与输入的树的列表相比，多了以下五个None值。

五、leetcode 297题

题解类似，需要把列表进行字符串化：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if not root:
            return "[]"
        res = []
        quence = [root]
        while quence:
            r = quence.pop(0)
            if r:
                res.append(str(r.val))
                quence.append(r.left)
                quence.append(r.right)
            else:
                res.append("None")

        return "[" + ",".join(res) + "]"

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if data == "[]":
            return
        data = data[1:-1].split(',')
        i = 1
        root = TreeNode(val=int(data[0]))
        quence = [root]

        while quence:
            node = quence.pop(0)
            if not data[i] == "None":
                node.left = TreeNode(int(data[i]))
                quence.append(node.left)
            i += 1
            if not data[i] == "None":
                node.right = TreeNode(int(data[i]))
                quence.append(node.right)
            i += 1
        
        return root

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