谷歌面经 Tree Serialization

http://www.careercup.com/question?id=4868040812396544

 

You should transform an structure of multiple tree from machine A to machine B. It is a serialization and deserialization problem, but i failed to solve it well. 

You could assume the struct is like this:

 

struct Node{
    string val;
    vector<Node*> sons;
}

 

and in machine A, you will given the point to root Node, and in machine B,you should return a pointer to root Node.

 

class Node:
    def __init__(self, val):
        self.val = val
        self.sons = []

class Solution:
    def __init__(self, root):
        self.sequence = str(root.val)
        cur = [root]
        while cur:
            next = []
            for i in cur:
                self.sequence += str(len(i.sons))
                for ii in i.sons:
                    next.append(ii)
                    self.sequence += str(ii.val)
            cur = next

    def de_serial(self):
        strs = self.sequence
        # print strs
        idx = 1
        cur = [Node(int(strs[0]))]
        root = cur[0]
        while cur and idx < len(strs):
            next = []
            for i in cur:
                num = int(strs[idx])
                # print 'num', num
                idx += 1  # notice this, idx increment not in while but in for
                for j in range(num):
                    tmp = Node(int(strs[idx]))
                    # print tmp.val
                    i.sons.append(tmp)
                    next.append(tmp)
                    idx += 1

            cur = next
            # print map(lambda x: x.val, next)
        return root

if __name__ == "__main__":
    tree = Node(1)
    two = Node(2)
    three = Node(3)
    four = Node(4)
    five = Node(5)
    six = Node(6)
    seven = Node(7)
    tree.sons = [two, three, four]
    two.sons = [five]
    three.sons = [six, seven]
    a = Solution(tree)
    print a.de_serial()

 

 

先序遍历+中序遍历 唯一确定一棵树, 前提是树是二叉树，树的所有节点值不同

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

class Solution:
    def __init__(self):
        self.pre = []
        self.ino = []

    def preorder(self, root, list):
        if not root:  return
        list.append(root.val)
        self.preorder(root.left, list)
        self.preorder(root.right, list)

    def inorder(self, root, lists):
        if not root:  return
        self.inorder(root.left, lists)
        lists.append(root.val)
        self.inorder(root.right, lists)

    def serialization(self, root):
        self.preorder(root, self.pre)
        self.inorder(root, self.ino)

    def de_serial(self):
        return self.de_serialization(self.pre, self.ino)

    def de_serialization(self, pre, inorder):
        if not pre:  return None
        root = Node(pre[0])
        i = 0
        while i < len(inorder):
            if pre[0] == inorder[i]:
                break
            i += 1

        root.left = self.de_serialization(pre[1:i+1], inorder[:i])
        root.right = self.de_serialization(pre[i+1:], inorder[i+1:])
        return root


if __name__ == "__main__":
    a = Solution()
    tree = Node(0)
    tree.left = Node(1)
    tree.right = Node(2)
    a.serialization(tree)
    root = a.de_serial()
    print root.val, root.left.val, root.right.val