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

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

题目

已知二叉树节点值类型为32位整型，序列化和反序列化该树。

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

BST

class BST():
    def __init__(self, root=None):
        self.root = root

    def insert_recursive(self, val):
        def recursive(node, val):
            if not node:
                return TreeNode(val)

            if val < node.val:
                node.left = recursive(node.left, val)
                node.left.parent = node
            elif val > node.val:
                node.right = recursive(node.right, val)
                node.right.parent = node

            return node

        self.root = recursive(self.root, val)

    def print_tree(self):
        def preorder(node):
            if not node:
                return '#'

            s = str(node.val)
            if node.left or node.right:
                s += '('
                s += preorder(node.left)
                s += ', '
                s += preorder(node.right)
                s += ')'

            return s

        return preorder(self.root)

思路1: 先序遍历

如上图的二叉树按先序遍历，序列化为：5|3|#|#|#

    def serialize(self):
        def preorder(node):
            if not node:
                return '#|'

            res = str(node.val) + '|'
            res += preorder(node.left)
            res += preorder(node.right)
            return res

        return preorder(self.root)

    def deserialize(self, pre_order_str):
        def reconstruct(q):
            s = q.pop(0)
            if s == '#':
                return None

            node = TreeNode(int(s))
            node.left = reconstruct(q)
            node.right = reconstruct(q)
            return node

        q = pre_order_str.split('|')
        self.root = reconstruct(q)

思路2: 分层遍历

按分层序列化为5|3|6|2|#|7|#|#|#|#|#|

    def serialize_by_level(self):
        if not self.root:
            return '#|'

        s = str(self.root.val) + '|'
        q = [self.root]
        while q:
            node = q.pop(0)
            if node.left is not None:
                s += str(node.left.val) + '|'
                q.append(node.left)
            else:
                s += '#|'
            if node.right is not None:
                s += str(node.right.val) + '|'
                q.append(node.right)
            else:
                s += '#|'

        return s

    def deserialize_by_level(self, level_str):
        def build_node(s):
            if s == '#':
                return None
            return TreeNode(int(s))

        if not level_str:
            self.root = None
            return

        splits = level_str.split('|')
        root = build_node(splits.pop(0))
        if root is None:
            return

        q = [root]
        while q:
            node = q.pop(0)
            node.left = build_node(splits.pop(0))
            if node.left is not None:
                q.append(node.left)

            node.right = build_node(splits.pop(0))
            if node.right is not None:
                q.append(node.right)

        self.root = root

测试

import unittest
import random
import bst
import operator


class TestSerializeAndDeserializeCase(unittest.TestCase):
    def test_pre(self):
        for _ in range(100):
            vals = [i for i in range(100)]
            random.shuffle(vals)

            tree = bst.BST()
            for v in vals:
                tree.insert_recursive(v)

            p1 = tree.print_tree()
            s = tree.serialize()
            tree.deserialize(s)
            p2 = tree.print_tree()
            self.assertTrue(operator.eq(p1, p2))

    def test_level(self):
        for _ in range(100):
            vals = [i for i in range(100)]
            random.shuffle(vals)

            tree = bst.BST()
            for v in vals:
                tree.insert_recursive(v)

            p1 = tree.print_tree()
            s = tree.serialize_by_level()
            tree.deserialize_by_level(s)
            p2 = tree.print_tree()
            self.assertTrue(operator.eq(p1, p2))

结果

➜  4_serialize_and_deserialize git:(master) ✗ python -m unittest test_serialize_and_deserialize.py 
..
----------------------------------------------------------------------
Ran 2 tests in 0.114s

OK