代码随想录算法训练营第十四天 | 理论基础、递归遍历、迭代遍历、统一迭代（144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历）

最新推荐文章于 2024-05-21 20:29:42 发布

北极以北Pottt

最新推荐文章于 2024-05-21 20:29:42 发布

阅读量435

点赞数 11

分类专栏：代码随想录算法训练营文章标签：算法数据结构 python leetcode

本文链接：https://blog.csdn.net/m0_73184000/article/details/138380384

版权

代码随想录算法训练营专栏收录该内容

25 篇文章 0 订阅

订阅专栏

迭代遍历（基础不好的录友，迭代法可以放过）

统一迭代（基础不好的录友，迭代法可以放过）

题目链接

144.二叉树的前序遍历

94.二叉树的中序遍历

145.二叉树的后序遍历

理论基础

需要了解二叉树的种类，存储方式，遍历方式以及二叉树的定义

文章讲解：代码随想录

递归遍历（必须掌握）

二叉树的三种递归遍历掌握其规律后，其实很简单

题目链接/文章讲解/视频讲解：代码随想录

递归遍历思路

递归遍历是最容易写的二叉树遍历方法了，其实就是三行代码顺序来回调换而已。

递归遍历代码

from typing import Optional, List


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


class Solution:
    # 前序递归遍历
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(root):
            if root is None:
                return
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)

        dfs(root)
        return res


    #中序递归遍历
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        res= []
        stack = []
        cur = root
        while stack or cur:
            if cur:
                stack.append(cur)
                cur = cur.left

            else:
                cur = stack.pop()
                res.append(cur.val)
                cur = cur.right
        return res


    #后序递归遍历
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)

        dfs(root)
        return res

迭代遍历（基础不好的录友，迭代法可以放过）

题目链接/文章讲解/视频讲解：代码随想录

前序迭代遍历思路

迭代本质是用栈。其中先序遍历和后序遍历代码差不多，中序遍历需要额外记思路。

具体来说，先定义一个栈stack[ ]，并先把根节点放入栈中。先序遍历就是先把栈顶节点取出记为node，把node的val保存到result[ ]中，然后再把node.right和node.left压入栈里（注意不压入空节点。先压右节点，再左节点，这样pop出来才是先左后右）

前序迭代遍历代码

from typing import *


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


# 迭代法
class Solution:
    def preorderTracersal(self, root: 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

中序迭代遍历思路

中序迭代遍历和前序后序迭代遍历有点不同，中序遍历是左中右，先访问二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

所以需要借用指针的遍历来帮助访问节点，按照左中右的顺序，所以先遍历到最左下方的节点node，处理完node后把node右节点放入栈中。

中序迭代遍历代码

from typing import Optional, List


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: TreeNode) -> List[int]:
        if not root:
            return []
        result = []
        stack = []
        cur = root
        while stack or cur:
            if cur:
                stack.append(cur)
                cur = cur.left

            else:
                cur = stack.pop()
                result.append(cur.val)
                cur = cur.right
        return result

后序迭代遍历思路

后序迭代遍历和前序迭代遍历很像，稍微修改一下就好了。前序遍历是中左右，后序遍历是左右中。技巧来了：前序遍历的代码实现中左右和中右左其实就是两个if的先后问题，而中右左倒过来读不就是左右中，所以技巧就是把前序遍历的顺序调成中右左，最后翻转数组变成左右中。

后序迭代遍历代码

from typing import Optional, List


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


class Solution:
    def postorderTraversal(self,root:TreeNode)->List[int]:
        if not root:
            return []
        result=[]
        stack=[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]

统一迭代（基础不好的录友，迭代法可以放过）

这是统一迭代法的写法，如果学有余力，可以掌握一下

题目链接/文章讲解：代码随想录

北极以北Pottt

关注

11
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十四天 | 理论基础、递归遍历、迭代遍历、统一迭代（144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历）

目录题目链接理论基础递归遍历（必须掌握）递归遍历思路递归遍历代码迭代遍历（基础不好的录友，迭代法可以放过）前序迭代遍历思路前序迭代遍历代码中序迭代遍历思路中序迭代遍历代码后序迭代遍历思路后序迭代遍历代码统一迭代（基础不好的录友，迭代法可以放过）递归遍历是最容易写的二叉树遍历方法了，其实就是三行代码顺序来回调换而已。迭代遍历（基础不好的录友，迭代法可以放过）前序迭代遍历思路迭代本质是用栈。其中先序遍历和后序遍历代码差不多，中序遍历需要额外记思路。
复制链接

扫一扫