[leetcode]中级算法——设计

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

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

Example:

You may serialize the following tree:

    1
   / \
  2   3
     / \
    4   5

as "[1,2,3,null,null,4,5]"

Code(By myself):

# 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
        """
        s = ''
        if not root:
            return s
        queue = [root]
        while queue:
            if queue.count('null') == len(queue):
                break
            temp = queue.pop(0)
            if temp == 'null':
                s = s + 'null' + ','
            else:
                s = s + str(temp.val) + ','
                if not temp.left and temp.right:
                    queue.append('null')
                    queue.append(temp.right)
                elif not temp.right and not temp.left:
                    queue.append('null')
                    queue.append('null')
                elif temp.right and temp.left:
                    queue.append(temp.left)
                    queue.append(temp.right)
                else:
                    queue.append(temp.left)
                    queue.append('null')
        return '[' + s[:-1] + ']'
        
        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data:
            return None
        data = data[1:-1].split(',')
        root = TreeNode(int(data.pop(0)))
        last = root
        queue = [root]
        while data:
            parent = queue.pop(0)
            node = TreeNode(data.pop(0))
            parent.left = node if node.val != 'null' else None
            if data:
                node = TreeNode(data.pop(0))
                parent.right = node if node.val != 'null' else None
            if parent.left:
                queue.append(parent.left)
            if parent.right:
                queue.append(parent.right)
        return root    
            
                
        

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

Code(others):

class Codec:
    """auther: lucylqe"""

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if not root:
            return ""
        
        lis=[root]
        i=j=0
        while i<=j:
            node = lis[i]
            if node:
                lis.append(node.left)
                lis.append(node.right)
                j += 2
            i += 1
        while lis[j] is None: 
            j -= 1
        return ",".join([str(node and node.val) for node in lis[:j+1]])
                

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data:
            return None
        
        nodes=[(TreeNode(val) if val != 'None' else None) for val in data.split(",") ]
        n = len(nodes)
        i,j=0,1
        while j<n:
            node=nodes[i]
            if node:
                node.left = nodes[j] if j<n else None
                node.right = nodes[j+1] if j+1<n else None
                j+=2
            i+=1
        return nodes[0]

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        return root

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        return data