代码随想录算法训练营第十三天 | 二叉树的理论基础、递归遍历、迭代遍历和统一遍历

二叉树理论基础

二叉树递归遍历

先序遍历：

题目链接：144-二叉树的前序遍历

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

        def traversal(root: TreeNode): #递归
            if root == None:
                return
            result.append(root.val)
            traversal(root.left)
            traversal(root.right)

        traversal(root)
        return result

中序遍历：

题目链接：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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result = []

        def traversal(root: TreeNode):
            if root == None:
                return 
            traversal(root.left)
            result.append(root.val)
            traversal(root.right)

        traversal(root)
        return result

后序遍历：

题目链接：145-二叉树的后序遍历

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

        def traversal(root: TreeNode):
            if root == None:
                return 
            traversal(root.left)
            traversal(root.right)
            result.append(root.val)

        traversal(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 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 []
        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 = []
        cur = root

        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]

二叉树统一遍历

迭代法前序遍历：

class Solution:
    def preorderTraversal(self, root: Optional[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) #添加右节点
                if node.left:
                    st.append(node.left)  #添加左节点
                st.append(node)  #添加中节点，添加空节点作为标记
                st.append(None)
            else: #若遇到空节点，同时将下一节点放入结果集
                node = st.pop() 
                result.append(node.val)
        return result

迭代法中序遍历：

class Solution:
    def inorderTraversal(self, root: Optional[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 

迭代法后序遍历：

class Solution:
    def postorderTraversal(self, root: 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