二叉树的序列化和反序列化（先序遍历、后序遍历、BFS、DFS）

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

• 序列化： 给定二叉树，生成 先序、后序、BFS、DFS 序列
• 反序列化：给定先序、后序、BFS、DFS 序列， 生成二叉树

1. 序列化

1.1 先序序列化：

• 递归方法：

def Preorder_serialize(root):
    return ['#'] if not root else [root.val] + Preorder_serialize(root.left) \
           + Preorder_serialize(root.right)

• 非递归方法：

def Preorder_serialize(root):
    if not root:
        return []

    stack = []
    p = root
    re = []
    while p or stack:
        while p:
            re.append(p.val) #打印
            stack.append(p)  #入栈
            p = p.left

        p = stack.pop(-1)  # 出栈
        p = p.right

    return re

1.2 中序序列化：

• 递归方法

def Midorder_serialize(root):
    return ['#'] if not root else  Midorder_serialize(root.left) + [root.val] \
           + Midorder_serialize(root.right)

• 非递归方法：

def Midorder_serialize(root):
    if not root:
        return []
    stack = []
    p = root
    re = []
    while stack or p:
        # 将指针移动到最左下角的节点
        while p:
            stack.append(p) # 入栈
            p = p.left

        p = stack.pop(-1) # 出栈
        re.append(p.val)  # 打印
        p = p.right
    return re

1.3 后序序列化：

• 递归方法：

def Postorder_serialize(root):
    return ['#'] if not root else  Postorder_serialize(root.left) \
           + Postorder_serialize(root.right) + [root.val] 

• 非递归方法： 等待更新

1.4 层次遍历BFS序列化：使用队列

def BFS_serialize(root):
    if not root:
        return []
    queue = []
    re = []
    queue.append(root)
    while queue:
        head = queue.pop(0)
        re.append(head.val)
        if head.left:
            queue.append(head.left)
        if head.right:
            queue.append(head.right)
    return re

1.5 深度优先遍历DFS序列化：使用栈

def DFS_serialize(root):
    if not root:
        return []
    stack = []
    re = []
    stack.append(root)
    while stack:
        head = stack.pop()
        re.append(head.val)
        if head.left:
            stack.append(head.left)
        if head.right:
            stack.append(head.right)
    return re

2. 反序列化

2.1 先序反序列化：

• 使用递归，递归依据：序列的头元素一定是当前根节点

def Preorder_deserialize(arr):
    if not arr:
        return None
    val = arr.pop(0)
    if val != '#': # 非空
        newnode = TreeNode(val)
        newnode.left = Preorder_deserialize(arr)
        newnode.right = Preorder_deserialize(arr)
        return newnode
    else:
        return None

2.2 后续反序列化：

• 使用递归，递归依据：序列的尾元素一定是当前根节点

def Postorder_deserialize(arr):
    if not arr:
        return None
    val = arr.pop()
    if val != '#': # 非空
        newnode = TreeNode(val)
        newnode.right = Postorder_deserialize(arr)
        newnode.left = Postorder_deserialize(arr)
        return newnode
    else:
        return None

2.3 中序反序列化：

• 等待更新

2.4 层次遍历BFS反序列化：使用队列

def BFS_deserialize(arr):
    if not arr:
        return None
    queue = []
    
    # 把根节点加入队列
    val = arr.pop(0)
    if val != '#':
        root = TreeNode(val)
        queue.append(root)
    else:
        return None

    while queue:
        # 出队
        head = queue.pop(0)
        # 从序列中左弹一个值,如果不空，就建立左子节点
        val = arr.pop(0)
        if val != '#':
            newnode = TreeNode(val)
            head.left = newnode
            queue.append(newnode)
        # 从序列中左弹一个值 ,如果不空，就建立右子节点  
        val = arr.pop(0)
        if val != '#':
            newnode = TreeNode(val)
            head.right = newnode
            queue.append(newnode)

    return root

2.5 深度优先遍历DFS反序列化：

• 等待更新