算法训练营

递归遍历

文档讲解： 代码随想录
题目难度：简单

思路:递归思想，按照遍历顺序来就行
时间复杂度：O(n)；空间复杂度：O(n)
下面展示 代码：

# 二叉树定义
class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right

# 前序遍历
class Solution:
    
    # 递归三部曲
    # 1、确定递归函数的参数和返回值
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 2、确定终止条件
        if not root:
            return []
        else:
            # 3、确定单层递归的逻辑
            left = self.preorderTraversal(root.left)
            right = self.preorderTraversal(root.right)
        return [root.val] + left + right
# 中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        else:
            left = self.inorderTraversal(root.left)
            right = self.inorderTraversal(root.right)
        return left + [root.val] + right
# 后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

迭代遍历

文档讲解： 代码随想录
题目难度：中等
思路:基于栈实现。因此入栈时遍历顺序为逆序且中节点后需要加入空节点标记
时间复杂度：O(n)；空间复杂度：O(n)
代码如下

# 二叉树定义
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: TreeNode) -> List[int]:
        # 利用栈来实现
        res = [] # 存储节点的值
        st = []  # 存储节点
        # 先存储根节点
        if root:
            st.append(root)
        # 前序遍历的逆序:右左中
        while st:
            current = st.pop()
            if current!= None:
                if current.right:
                    st.append(current.right)
                if current.left:
                    st.append(current.left)
                st.append(current)
                # 中节点访问过，但未处理，因此加入空节点作为标记
                st.append(None)
            else:
                current = st.pop()
                res.append(current.val)
        return res

# 中序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 利用栈来实现
        res = [] # 存储节点的值
        st = []  # 存储节点
        # 先存储根节点
        if root:
            st.append(root)
        # 中序遍历的逆序:右中左
        while st:
            current = st.pop()
            if current!= None:
                if current.right:
                    st.append(current.right)
                
                st.append(current)
                # 中节点访问过，但未处理，因此加入空节点作为标记
                st.append(None)

                if current.left:
                    st.append(current.left)
                
            else:
                current = st.pop()
                res.append(current.val)
        return res
    
# 后序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 利用栈来实现
        res = [] # 存储节点的值
        st = []  # 存储节点
        # 先存储根节点
        if root:
            st.append(root)
        # 后序遍历的逆序:中右左
        while st:
            current = st.pop()
            if current!= None:
                st.append(current)
                # 中节点访问过，但未处理，因此加入空节点作为标记
                st.append(None)

                if current.right:
                    st.append(current.right)

                if current.left:
                    st.append(current.left)
            else:
                current = st.pop()
                res.append(current.val)
        return res