代码随想录算法训练营17期day14-python（统一迭代法后续补）

一、二叉树的递归遍历-前序（后序和中序较为简单，改动递归语句的顺序即可）

'''
二叉树的前序遍历
'''
#定义二叉树类，底层逻辑为链表
class TreeNode:
    def __int__(self, val = 0, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right

# class Solution:
#     def preorderTraversal(self, root: TreeNode)-> list[int]:
#         if not root :
#             return []
#         left = self.preorderTraversal(root.left)
#         right = self.preorderTraversal(root.right)
#
#         return [root.val] + left + right

# 二叉树的递归遍历
class Solution1:
    def preorderTraversal2(self, root: TreeNode)-> list[int]:
        # 定义一个列表用来存放结果，因为要将所有节点内的数值存入，所以需要定义在内层函数之外
        res = []
        def dfs(root):
            # 可以调用上一级定义的res
            nonlocal res
            # 如果root为空，直接返回空列表
            if not root:
                return []
            # 第一步结果列表append结点加入val（中）
            res.append(root.val)
            # 第二步左节点递归
            dfs(root.left)
            # 第三步右节点递归
            dfs(root.right)
        dfs(root)
        return res

二、二叉树的迭代遍历-前序

'''
给你二叉树的根节点 root ，返回它节点值的前序遍历
'''
#首先定义二叉树类，本质为链表
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: TreeNode) -> list[int]:
        # 定义一个栈，根节点入栈
        stack = [root]
        #定义一个空列表，作为结果数组
        res = []
        if not root:
            return []
        # 当栈不为空时执行循环体
        while stack:
            #栈内的根节点直接出栈，并赋值给过程节点node
            node = stack.pop()
            #如果node不为空，执行条件语句
            if node:
                #结果数组加入node（出栈节点）的数值
                res.append(node.val)
                if node.right:
                    #因为栈是先进后出，所以先将右孩子入栈
                    stack.append(node.right)
                    #左孩子入栈
                if node.left:
                    stack.append(node.left)
                #随后循环以上整个语句，
        return res

 二叉树的迭代遍历-中序

# 中序遍历-迭代-LC94_二叉树的中序遍历
class Solution1:
    def inorderTraversal(self, root: TreeNode) -> list[int]:
        if not root:
            return []
        stack = []  # 不能提前将root结点加入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