代码随想录day14|144. 二叉树的前序遍历145. 二叉树的后序遍历94. 二叉树的中序遍历

 递归法前中后序遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        #不能将result写在递归函数里，因为每次调用都会重新创建result
        #递归中止条件就是cur为空无事发生 前序中左右，先将中加入，再先左后右
        def preorder(root):
            if root == None:
                return 
            result.append(root.val)
            preorder(root.left)
            preorder(root.right)
        result=[]
        preorder(root)
        return result

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def inorder(cur):
            if cur == None:
                return
            inorder(cur.left)
            result.append(cur.val)
            inorder(cur.right)
        result = []
        inorder(root)
        return result

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def postorder(cur):
            if cur == None:
                return
            postorder(cur.left)
            postorder(cur.right)
            result.append(cur.val)
        result = []
        postorder(root)
        return result

遍历法前中后序遍历，在写while循环时要注意两点，一是while要能退出，尤其注意if语句是否会一直判断没有更改，二是当cur走到None时是没有值的，需要判断

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result = []
        stack = [root]
        while stack !=[]:
            temp = stack.pop()
            if temp == None:
                continue
            result.append(temp.val)
            stack.append(temp.right)
            stack.append(temp.left)
        return result

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        stack =[root]
        result=[]
        while stack !=[]:
            if root != None:
                stack.append(root.left)
                root = root.left
            else:
                a = stack.pop()
                if a == None:
                    continue
                result.append(a.val)
                stack.append(a.right)
                root = a.right
        return result

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result = []
        stack = [root]
        while stack!= []:
            temp = stack.pop() 
            if temp == None:
                continue
            result.append(temp.val)
            stack.append(temp.left)
            stack.append(temp.right)
        result.reverse()
        return result

统一遍历法 中序，前后序只用修改中间操作顺序，None节点跟着中节点

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root:
            st.append(root)
        while st:
            node = st.pop()
            if node != None:
                if node.right: #添加右节点（空节点不入栈）
                    st.append(node.right)
                
                st.append(node) #添加中节点
                st.append(None) #中节点访问过，但是还没有处理，加入空节点做为标记。
                
                if node.left: #添加左节点（空节点不入栈）
                    st.append(node.left)
            else: #只有遇到空节点的时候，才将下一个节点放进结果集
                node = st.pop() #重新取出栈中元素
                result.append(node.val) #加入到结果集
        return result