python 二叉树的前中后序遍历 N叉树的遍历

递归方法都简单 用迭代法写

主要利用了栈先进后出的原理，以及一层一层访问数据，操作数据入栈

中序遍历： 先到达左叶子结点（一路向左），然后依次推出栈顶数据，如果该节点存在右子树，则储存完根节点数据后，转向该节点右子树，若不存在右子树且栈不为空，则出栈下一个数据，即左-根-右-左-根-右

前序遍历：从根节点开始，先存储根节点的值，然后依次压入根节点的右孩子、左孩子，并弹出栈顶数据，则弹出顺序为左孩子、右孩子，符合前序遍历 根-左-右的顺序

后序遍历：
两种方法：
一：按照前序遍历，但是依次压入根节点的左孩子，右孩子，则弹出顺序是根-右-左，将结果数组逆序即为根-左-右的顺序 res[::-1]
二：一直向左下行，如果不存在左子树则向右，最终目的是到达最左侧叶子结点，经过的节点都依次入栈，到达最左侧叶子结点后，将该数据存到res中，如果该节点存在右兄弟，则转向其右兄弟，如果不存在，则退栈，弹出此时栈顶元素，是该节点的父节点，实现了左-右-根的遍历顺序

94 二叉树的中序遍历

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack=[]
        res=[]
        node=root
        while stack or node:
            while node:
                stack.append(node)
                node=node.left
            node=stack.pop()
            res.append(node.val)
            node=node.right
        return res

144 二叉树的前序遍历

从根节点开始，每次迭代弹出当前栈顶元素，并将其孩子节点压入栈中，先压右孩子再压左孩子。
输出到最终结果的顺序按照 Top->Bottom 和 Left->Right，符合前序遍历的顺序。

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack=[root]
        res=[]
        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

145 二叉树的后序遍历

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack=[]
        res=[]
        node=root
        while stack or node:
            while node:
                #第一次入栈的是根节点
                stack.append(node)
                #判断当前节点的左子树是否存在，若存在则持续左下行，若不存在就转向右子树
                node=node.left if node.left else node.right
            #到达最左叶子结点
            node=stack.pop()
            res.append(node.val)
            #判断该节点是父节点的左子树还是右子树
            if stack and stack[-1].left==node:
                #是左子树则转去访问右子树，此时栈顶元素为Node的父节点
                node=stack[-1].right
            else:
                #是右子树则退栈，接下来访问栈顶元素
                node=None
        return res

仿N叉树的后序遍历

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        res=[]
        stack=[root]
        while stack:
            node=stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

590 N叉树后序遍历

class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def postorder(self, root: 'Node') -> List[int]:
        if not root:
            return []
        self.res=[]
        # stack=[root]
        # node=root
        # res=[]
        # while stack:
        #     root=stack.pop()#从前往后入栈，则从后往前推出数据
        #     if root:
        #         res.append(root.val)
        #     for c in root.children:
        #         stack.append(c)
        # return res[::-1]
        def dfs(root):
            if not root:
                return
            for i in root.children:
                dfs(i)
            self.res.append(root.val)
        dfs(root)
        return self.res