LeetCode 449. Serialize and Deserialize BST

Problem Statement

(Source) 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 search tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary search tree can be serialized to a string and this string can be deserialized to the original tree structure.

The encoded string should be as compact as possible.

Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

Tags: Tree.

Solution

# 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 = []
        d = collections.deque([root])
        while d:
            node = d.popleft()
            if not node:
                res.append('#')
            else:
                res.append(str(node.val))
                d.append(node.left)
                d.append(node.right)
        while res[-1] == '#':
            res.pop()
        return ','.join(res)


    def deserialize(self, data):
        """Decodes your encoded data to tree.

        :type data: str
        :rtype: TreeNode
        """
        if data == '#':
            return None

        values = data.split(',')
        j, n = 1, len(values)
        root = TreeNode(int(values[0]))
        d = collections.deque([root])
        while d:
            node = d.popleft()
            if node and j < n:
                left = self.make_node(values[j])
                node.left = left
                d.append(left)
                j += 1
                if j < n:
                    right = self.make_node(values[j])
                    node.right = right
                    d.append(right)
                j += 1
        return root


    def make_node(self, s):
        return TreeNode(int(s)) if s != '#' else None



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