二叉树三种遍历的递归和非递归实现

1. 前序遍历

1.1 递归实现

def pre_order(root):
    if root is None:
        return
    print(root.val)
    pre_order(root.left)
    pre_order(root.right)

1.2 非递归实现

def pre_order(root):
    stack = []
    p = root
    while p or stack:
        while p:
            print(p.val)
            stack.append(p)
            p = p.left
        if stack:
            p = stack.pop(-1)
            p = p.right

2. 中序遍历

2.1 递归实现

def in_order(root):
    if root is None:
        return
    in_order(root.left)
    print(root.val)
    in_order(root.right)

2.2 非递归实现

def in_order(root):
    stack = []
    p = root
    while p or stack:
        while p:
            stack.append(p)
            p = p.left
        if stack:
            p = stack.pop(-1)
            print(root.val)
            p = p.right

3. 后序遍历

3.1 递归实现

def post_order(root):
    if root is None:
        return
    post_order(root.left)
    post_order(root.right)
    print(root.val)

3.2 非递归实现

def post_order(root):
    if root is None:
        return
    stack1, stack2 = [root], []
    while stack1:
        node = stack1.pop(-1)
        stack2.append(node)
        if node.left:
            stack1.append(node.left)
        if node.right:
            stack1.append(node.right)
    while stack2:
        node = stack2.pop(-1)
        print(node.val)