[剑指Offer] 37_序列化二叉树

题目

请实现两个函数，分别用来序列化和反序列化二叉树

例：

树：
        1
       / \
      2   3
     /   / \
    4   5   6
序列化：
[1, 2, 4, $, $, $, 3, 5, $, $, 6, $, $]

---

思路

1. 容易发现序列化其实就是带None的前序遍历。所以题目就是完成一个前序遍历将节点值存入列表，遍历列表按前序生成一棵二叉树。
   1. 时间复杂度：O(n)
   2. 空间复杂度：O(n)

---

代码

思路1：时间复杂度：O(n)，空间复杂度：O(n)

from datstru import TreeNode

def serialize(root):
    """    
    :param root:tree root 
    :return:pre-order val list 
    """
    def preorder(root):
        if not root:
            seq.append('$')
            return
        seq.append(root.val)
        preorder(root.left)
        preorder(root.right)
        return seq
    seq = []
    preorder(root)
    return seq


def deserialize(sequence):
    """    
    :param sequence:pre-order val list 
    :return: tree root
    """
    def rebuild(seqence, i):
        val = seqence[i]
        if val == '$':
            return None
        root = TreeNode(val)
        root.left = rebuild(seqence, i+1)
        root.right = rebuild(seqence, i+2)
        return root

    if not sequence:
        return None
    return rebuild(sequence, 0)

---

思考

1. 这个代码实现serialize函数的时候采用列表append的方法添加值，在列表很长的时候，append方法会让列表复制并扩展后再添加，速度很慢。如果使用链表，可能会好很多。
2. deserialize函数一开始也使用了列表pop方法，一样pop会修改列表。不如直接索引值来的快，这一点可以在后面LeetCode题上测试。

相似的题目

LeetCode 297. 二叉树的序列化与反序列化

题目

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

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

示例:

你可以将以下二叉树：
    1
   / \
  2   3
     / \
    4   5

序列化为 “[1,2,3,null,null,4,5]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。

代码

# 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
        """
        l_node = [root]
        seq = []
        ni = 0
        while ni < len(l_node):
            cur = l_node[ni]
            if cur:  
                seq.append(str(cur.val))
                l_node.extend([cur.left, cur.right])
            else:
                seq.append('null')
            ni += 1
        return '['+','.join(seq)+']'
            
        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """        
        data = data[1:-1].split(',')
        root_val = data[0]
        if root_val == 'null':
            return []
        else:
            root = TreeNode(root_val)
        node = [root]
        di = 1
        ni = 0
        while di < len(data):
            cur = node[ni]
            if cur:
                val_l = data[di]
                val_r = data[di+1]
                cur.left = TreeNode(int(val_l)) if val_l != 'null' else None
                cur.right = TreeNode(int(val_r)) if val_r != 'null' else None
                node.extend([cur.left, cur.right])
                di += 2
            ni += 1
        return root
            
            
        
        

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