二叉树递归与非递归写法

"""
二叉树
"""


class Node():
    def __init__(self, val=None, lchild=None, rchild=None):
        self.val = val
        self.lchild = lchild
        self.rchild = rchild


res = []


def pre_recursion(node):
    "根左右"
    if not node:
        return
    res.append(node.val)
    # print(node.root)
    pre_recursion(node.lchild)
    pre_recursion(node.rchild)
    return res


def mid_recursion(node):
    "左根右"
    if not node:
        return
    mid_recursion(node.lchild)
    res.append(node.val)
    mid_recursion(node.rchild)
    return res


def post_recursion(node):
    "左右根"
    if not node:
        return
    post_recursion(node.lchild)
    post_recursion(node.rchild)
    res.append(node.val)
    return res


"""
非递归算法写二叉树
！！每次循环从栈里面取一个节点
"""


def pre_unrecursion(node):
    """
    这里的入栈顺序是先入右子节点，再入左子节点
    弹出根节点，判断有无左右子节点，先入右子节点，再入左子节点
    :param node:
    :return:
    """
    stack = [node]
    res = []
    if not node:
        return res

    while stack:
        node = stack.pop()  # 将node出栈
        res.append(node)
        if node.rchild:
            stack.append(node.rchild)
        if node.lchild:
            stack.append(node.lchild)
    return res


def mid_unrecursion(node):
    """
    1.先不弹出根节点
    2.找到最左边的子节点，开始弹出
    3.弹出的子节点，判断有无右节点，有右节点再加入栈（这里不再考虑左子节点，因为循环里面会将所有的左子节点都加入stack内）
    :param node:
    :return:
    """
    stack = [node]
    res = []
    if not node:
        return res

    while not node or stack:
        currend_node = stack[-1]
        while currend_node.lchild and currend_node.lchild not in res:
            stack.append(currend_node.lchild)  # 将左子树加入栈中
            currend_node = currend_node.lchild
        currend_node = stack.pop()
        res.append(currend_node)
        if currend_node.rchild:
            stack.append(currend_node.rchild)
    return res


def post_unrecursion(node):
    """
    1.先不弹出根节点
    2.找到最左边的子节点
    3.判断左子节点有无右节点，有右节点需要加入stack,如果没有右子节点则可以弹出
    :param node:
    :return:
    """
    stack = []
    res = []
    if not node:
        return res
    stack.append(node)
    while not node or stack:
        currend_node = stack[-1]
        while currend_node.lchild and currend_node.lchild not in res:
            stack.append(currend_node.lchild)  # 将左子树节点全部取出
            currend_node = currend_node.lchild

        if currend_node.rchild and currend_node.rchild not in res:
            stack.append(currend_node.rchild)
        else:
            res.append(currend_node)
            stack.pop()
    return res


if __name__ == '__main__':
    node4 = Node(4)
    node5 = Node(5)
    node6 = Node(6)
    node3 = Node(3, None, node6)
    node2 = Node(2, node4, node5)
    node1 = Node(1, node2, node3)
    #
    # print(pre_recursion(node1))
    # print([item.val for item in pre_unrecursion(node1)])
    #
    # print(mid_recursion(node1))
    # print([item.val for item in mid_unrecursion(node1)])
    #
    # print(post_recursion(node1))
    # print([item.val for item in post_unrecursion(node1)])
    # node7 = Node(7)
    # node4 = Node(4, node7)
    # node5 = Node(5)
    # node6 = Node(6)
    # node3 = Node(3, node5, node6)
    # node2 = Node(2, None, node4)
    # node1 = Node(1, node2, node3)

    # print(pre_recursion(node1))
    # print([item.val for item in pre_unrecursion(node1)])

    # print(mid_recursion(node1))
    # print(mid_unrecursion(node1))
    # print([item.val for item in mid_unrecursion(node1)])

    print(post_recursion(node1))
    print([item.val for item in post_unrecursion(node1)])