【leetcode】449. Serialize and Deserialize BST

题目如下：

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.

解题思路：我的序列化的方法是"根左右"的顺序进行遍历，每个节点的值之间以'#'分割。那么在反序列化的时候，首先把序列化的结果按'#'分割成数组，很显然数组的第一个元素是根节点，同时遍历数组，找到第一个比根节点值大的节点，这个节点左边的元素属于根节点的左子树，自身及右边的元素属于根节点的右子树。接下来分别对左右子树递归，直到所有节点的构造完成为止。

代码如下：

# 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
        """
        self.ser = ''
        def recurisve(node):
            if node == None:
                return
            self.ser += '#'
            self.ser += str(node.val)
            recurisve(node.left)
            recurisve(node.right)
        recurisve(root)
        return self.ser[1:]
        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if len(data) == 0:
            return None
        val_list = [int(i) for i in data.split('#')]
        root = TreeNode(-1)
        def build(node,path):
            if len(path) == 0:
                return
            rv = path[0]
            left = []
            inx = 0
            for i in range(1,len(path)):
                if path[i] < rv:
                    inx = i
                    left.append(path[i])
                else:
                    break
            right = path[inx+1:]
            node.val = rv
            if len(left) > 0:
                node.left = TreeNode(-1)
                build(node.left,left)
            if len(right) > 0:
                node.right = TreeNode(-1)
                build(node.right, right)
        build(root,val_list)
        return root
        

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