二叉树的序列化与反序列化_Python实现

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

'''
前序遍历实现
'''
class Solution:
    def serialize(self, root):
        if root is None: return 'None'
        return str(root.val) + ','\
            + str(self.serialize(root.left))\
            + ',' + str(self.serialize(root.right))
    def deserialize(self, data):
        def dfs(data_list):
            val = data_list.pop(0)
            if val == 'None': return None
            root = TreeNode(int(val))
            root.left = dfs(data_list)
            root.right = dfs(data_list)
            return root
    data_list = data.split(',')
    return dfs(data_list)
'''
后续遍历实现
'''
class Solution:
    def serialize(self, root):
        if root is None: return 'None'
        return str(self.serialize(root.left))\
            + ',' + str(self.serialize(root.right))\
            + ',' + str(root.val)
        
    def deserialize(self, datalist):
        def dfs(data_list):
            val = data_list.pop()
            if val = 'None': return None
            root = TreeNode(val)
            root.right = dfs(data_list)
            root.left = dfs(data_list)
            return root
        datalist = data.split(',')
        return dfs(datalist)
'''
中序遍历可以实现的二叉树的序列化，
但是无法进行反序列化，
因为与前序遍历和后序遍历不同的是：
    中序遍历无法确定树的根节点
'''
'''
层级遍历的解法实现序列化和反序列化
'''
# 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
        """
        def traverse(root):
            tmp_list = [root]
            ans = ''
            while len(tmp_list) > 0:
                cur_node = tmp_list.pop(0)
                if cur_node is None:
                    ans = ans + "None" + ','
                    continue

                ans = ans + str(cur_node.val) + ','
                
                tmp_list.append(cur_node.left)
                tmp_list.append(cur_node.right)
            return ans
        res = traverse(root)
        return res

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if len(data) == 0: return []
        data_list = data[0:-1].split(',')
        print(data)
        print(data_list)
        if data_list[0] == 'None': return []
        root = TreeNode(data_list[0])
        tmp_list = [root]
        i = 0
        n = len(data_list) 
        while i < n-2:
            if len(tmp_list) == 0: break
            parent = tmp_list.pop(0)
            i += 1
            left = data_list[i]
            if left == 'None':
                parent.left = None
            else:
                parent.left = TreeNode(int(left))
                tmp_list.append(parent.left)
            i += 1
            right = data_list[i]
            if right == 'None':
                parent.right = None
            else:
                parent.right = TreeNode(int(right))
                tmp_list.append(parent.right)
        return root

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