二叉树的前中后序、层序遍历以及重建

一、Tree的结构

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

二、前序遍历

根->左->右，前中后都是指的是根，左右的关系永远是先左后右

1、递归方法

这个是通用写法，对于中序和后序，仅需稍微调整一下（详情看后面）

def preord_Recur(root):
    res = []
    def helper(node):
        if not node:
            return 
        res.append(node.val)
        helper(node.left)
        helper(node.right)
    helper(root)
    return res

2、非递归

2.1、方法一（不推荐，因为不易扩展到中后序）

优点：思想和递归的完全一致，只是翻译了一下，比较容易想到

def preord_Inter_one(root):
    res = []
    if not root: return res
    stack = [root]
    while stack:
        node = stack.pop()
        res.append(node.val)
        if node.right: stack.append(node.right)
        if node.left: stack.append(node.left)
    return res

2.2 、方法二（推荐，记住一个就可以轻易扩展到中后序）

这个思想也比较直观，按照根左右的顺序来即可

def preord_Inter(root):
    res, stack = [], []
    while root or stack:
        while root:
            res.append(root.val)
            stack.append(root)
            root = root.left
        root = stack.pop()
        root = root.right
    return res

三、中序遍历

1、递归

调整 res.append(node.val) 的顺序即可，后序也是如此

def inord_Recur(root):
    res = []
    def helper(node):
        if not node:
            return 
        helper(node.left)
        res.append(node.val)
        helper(node.right)
    helper(root)
    return res

2、非递归

调整 res.append(root.val) 的顺序即可

def inord_Inter(root):
    res, stack = [], []
    while root or stack:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        res.append(root.val)
        root = root.right
    return res

四、后续遍历

1、递归

调整 res.append(node.val) 的顺序即可

def postord_Recur(root):
    res = []
    def helper(node):
        if not node:
            return 
        helper(node.left)
        helper(node.right)
        res.append(node.val)
    helper(root)
    return res

2、非递归

核心思想：将 左->右->根 换成 根->右->左 来求解（即转化成前序遍历来求）

def postord_Inter(root):
    res, stack = [], []
    while root or stack:
        while root:
            res.append(root.val)
            stack.append(root)
            root = root.right
        root = stack.pop()
        root = root.left
    return res[::-1]

五、层序遍历

1、递归

加入depth，用前序遍历的方法加入结果中

def levelord_Recur(root):
    res = []
    def helper(node, depth):
        if not node: return
        if len(res) == depth:
            res.append([])
        res[depth].append(node.val)
        helper(node.left, depth+1)
        helper(node.right, depth+1)
    helper(root, 0)
    return res

2、非递归

用栈的思想来做

def levelord_Inter(root):
    res = []
    if not root: return res
    stack = [root]
    while stack:
        tmp = []
        next_level = []
        for node in stack:
            tmp.append(node.val)
            if node.left: next_level.append(node.left)
            if node.right: next_level.append(node.right)
        res.append(tmp)
        stack = next_level
    return res

六、二叉树重建

1、前序和中序重建二叉树

def bulid_Tree(pre_ord, in_ord):
    if not pre_ord:
        return None
    root = TreeNode(pre_ord[0])
    mid = in_ord.index(pre_ord[0])
    root.left = bulid_Tree(pre_ord[1:mid+1], in_ord[:mid])
    root.right = bulid_Tree(pre_ord[mid+1:], in_ord[mid+1:])
    return root