代码随想录刷题第14天|二叉树

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

前序遍历

递归法

class Solution:#递归法
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        left=self.preorderTraversal(root.left)
        right=self.preorderTraversal(root.right)

        return [root.val]+left+right

迭代法

# 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]:
        if not root:
            return []
        
        stack=[root]#定义一个栈，用来模拟过程,并预先放入根节点
        result=[]#用来存储
        while stack:#当栈非空时
            node=stack.pop()#中节点先处理
            result.append(node.val)
            if node.right:#不为空
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        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]:
        if not root:
            return []
        left=self.inorderTraversal(root.left)
        right=self.inorderTraversal(root.right)

        return left+[root.val]+right

迭代法

# 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]:
        if not root:
            return []
        stack=[]#不能提前计入
        result=[]
        cur=root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur=cur.left#一直遍历左子树到最小
            else:
                #到达最左节点后处理栈顶节点
                cur=stack.pop()
                result.append(cur.val)
                cur=cur.right
        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]:
        if not root:
            return []
        stack=[root]
        result=[]
        while stack:
            node=stack.pop()
            result.append(node.val)
            if node.left:#左孩子入栈
                stack.append(node.left)
            if node.right:#右孩子入栈
                stack.append(node.right)
        return result[::-1]#将最终的数组反转   

统一迭代法

# 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]:
        result=[]
        st=[]

        if root:
            st.append(root)

        while st:
            node=st.pop()#预先取出

            if node!=None:#空节点不入栈
                st.append(node)#中
                st.append(None)#中节点访问过了，但是还没处理，加入空节点作标记

                if node.right:#右
                    st.append(node.right)
                if node.left:#左
                    st.append(node.left)
            
            else:#遇到空节点
                node=st.pop()
                result.append(node.val)

        return result