LeetCode 题目 94:五种算法递归|迭代|莫里斯|线索二叉树|栈的迭代二叉树 实现中序遍历

简介: LeetCode 题目 94:五种算法递归|迭代|莫里斯|线索二叉树|栈的迭代二叉树 实现中序遍历

作者介绍:10年大厂数据\经营分析经验,现任大厂数据部门负责人。

会一些的技术:数据分析、算法、SQL、大数据相关、python

欢迎加入社区:码上找工作

作者专栏每日更新:

LeetCode解锁1000题: 打怪升级之旅

python数据分析可视化:企业实战案例

python源码解读

程序员必备的数学知识与应用

备注说明:方便大家阅读,统一使用python,带必要注释,公众号 数据分析螺丝钉 一起打怪升级

本文详细探讨了五种二叉树中序遍历算法,包括递归、迭代、莫里斯遍历、线索二叉树和栈的迭代,评估了它们的效率和实用性。


题目描述

给定一个二叉树的根节点 root,返回它的中序遍历。

输入格式
  • root:二叉树的根节点。
输出格式
  • 返回中序遍历结果的列表。

示例

示例 1
输入: root = [1,null,2,3]
输出: [1,3,2]

方法一:递归

解题步骤
  1. 递归遍历:先遍历左子树,然后访问根节点,最后遍历右子树。
完整的规范代码
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def inorderTraversal(root):
    """
    递归实现二叉树的中序遍历
    :param root: TreeNode, 二叉树的根节点
    :return: List[int], 中序遍历的结果
    """
    def helper(node, res):
        if node:
            helper(node.left, res)
            res.append(node.val)
            helper(node.right, res)
    
    result = []
    helper(root, result)
    return result
# 示例调用
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print(inorderTraversal(root))  # 输出: [1,3,2]
算法分析
  • 时间复杂度:(O(n)),每个节点访问一次。
  • 空间复杂度:(O(h)),递归栈的深度,其中 (h) 是树的高度。

方法二:迭代

解题步骤
  1. 使用栈:利用栈来模拟递归过程,先深入访问左子树,再访问节点,最后处理右子树。
完整的规范代码
def inorderTraversal(root):
    """
    迭代实现二叉树的中序遍历
    :param root: TreeNode, 二叉树的根节点
    :return: List[int], 中序遍历的结果
    """
    stack, res = [], []
    current = root
    while current or stack:
        while current:
            stack.append(current)
            current = current.left
        current = stack.pop()
        res.append(current.val)
        current = current.right
    return res
# 示例调用
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print(inorderTraversal(root))  # 输出: [1,3,2]
算法分析
  • 时间复杂度:(O(n)),每个节点访问一次。
  • 空间复杂度:(O(h)),栈的最大深度等于树的高度。

方法三:莫里斯遍历 (Morris Traversal)

解题步骤
  1. 线索二叉树:利用叶子节点中的空 right 指针指向中序遍历的后继节点,从而实现空间复杂度为 (O(1)) 的遍历。
完整的规范代码
def inorderTraversal(root):
    """
    莫里斯遍历实现二叉树的中序遍历
    :param root: TreeNode, 二叉树的根节点
    :return: List[int], 中序遍历的结果
    """
    res, current = [], root
    while current:
        if current.left:
            # 找到左子树的最右节点
            pre = current.left
            while pre.right and pre.right != current:
                pre = pre.right
            if not pre.right:
                pre.right = current
                current = current.left
            else:
                pre.right = None
                res.append(current.val)
                current = current.right
        else:
            res.append(current.val)
            current = current.right
    return res
# 示例调用
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print(inorderTraversal(root))  # 输出: [1,3,2]
算法分析
  • 时间复杂度:(O(n)),尽管看似复杂,但每个节点最多被处理两次(一次连接前驱,一次断开前驱)。
  • 空间复杂度:(O(1)),不使用额外空间。

方法四:线索二叉树

解题步骤

线索二叉树是一种通过链接空的左指针指向节点的前驱,空的右指针指向节点的后继来增加遍历效率的方法。对于中序遍历,可以通过构建线索二叉树来无需额外空间和递归地完成遍历。

  1. 构建线索:在构建或遍历时,把空的左指针指向中序遍历的前驱,右指针指向后继。
  2. 遍历节点:从根节点开始,一直向左下走到最左,然后使用线索向右移动。
完整的规范代码
def inorderTraversal(root):
    """
    使用线索二叉树的方法进行中序遍历
    :param root: TreeNode, 二叉树的根节点
    :return: List[int], 中序遍历的结果
    """
    result = []
    current = root
    while current:
        if current.left:
            pre = current.left
            while pre.right and pre.right != current:
                pre = pre.right
            if not pre.right:
                pre.right = current  # 建立线索
                current = current.left
                continue
            pre.right = None  # 断开线索
        result.append(current.val)
        current = current.right
    return result
# 示例调用
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print(inorderTraversal(root))  # 输出: [1,3,2]
算法分析
  • 时间复杂度:(O(n)),每个节点被访问至多两次。
  • 空间复杂度:(O(1)),不使用额外空间,除了输出列表。

方法五:使用栈的非递归迭代

解题步骤

这种方法使用显式栈存储将要访问的节点,模拟递归过程。

  1. 使用栈:利用显式栈存储节点来模拟递归的调用栈。
  2. 处理节点:按照中序的顺序处理每个节点,即左-根-右。
完整的规范代码
def inorderTraversal(root):
    """
    使用栈的迭代方法进行中序遍历
    :param root: TreeNode, 二叉树的根节点
    :return: List[int], 中序遍历的结果
    """
    stack = []
    result = []
    current = root
    while current or stack:
        while current:
            stack.append(current)
            current = current.left
        current = stack.pop()
        result.append(current.val)
        current = current.right
    return result
# 示例调用
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
print(inorderTraversal(root))  # 输出: [1,3,2]
算法分析
  • 时间复杂度:(O(n)),每个节点被访问一次。
  • 空间复杂度:(O(h)),栈的最大深度等于树的高度。

下面是五种中序遍历二叉树算法的优劣势对比表,这有助于直观地了解每种方法的特点和适用场景:

方法 时间复杂度 空间复杂度 优势 劣势
递归 (O(n)) (O(h)) 简单直观;直接符合中序遍历定义。 可能导致栈溢出;递归深度受树高限制。
迭代 (O(n)) (O(h)) 避免递归导致的栈溢出。 实现较为复杂;需要手动维护栈。
莫里斯遍历 (O(n)) (O(1)) 不使用额外空间;适合内存限制严格的环境。 修改树的结构(临时);实现复杂,难以掌握。
线索二叉树 (O(n)) (O(1)) 通过线索化减少空间使用,无栈无递归。 需要修改树的结构,实现较复杂。
栈的迭代 (O(n)) (O(h)) 易于理解和实现;不修改树的结构。 需要额外的存储空间模拟调用栈。

应用示例

  • 算法设计与数据结构教育:递归和迭代方法经常用于教学,展示基本的树遍历技术。
  • 计算机图形学:中序遍历可用于场景图管理,处理具有层次结构的图形对象。
  • 编译器构建:在抽象语法树(AST)的处理中,中序遍历可以用于生成输出代码或。

欢迎关注微信公众号 数据分析螺丝钉

相关文章
|
6天前
|
算法 Java
[Java·算法·简单] LeetCode 283. 移动零
[Java·算法·简单] LeetCode 283. 移动零
15 2
|
6天前
|
算法 Java
[Java·算法·中等] LeetCode21. 合并两个有序链表
[Java·算法·中等] LeetCode21. 合并两个有序链表
13 2
|
9天前
|
算法 C++
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题-2
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题
|
9天前
|
算法 C++
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题-1
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题
|
9天前
|
算法
二刷力扣--二叉树(3)
二刷力扣--二叉树(3)
|
9天前
二刷力扣--二叉树(2)
二刷力扣--二叉树(2)
|
9天前
二刷力扣--二叉树(1)基础、遍历
二刷力扣--二叉树(1)基础、遍历
|
1天前
|
机器学习/深度学习 算法
基于鲸鱼优化的knn分类特征选择算法matlab仿真
**基于WOA的KNN特征选择算法摘要** 该研究提出了一种融合鲸鱼优化算法(WOA)与K近邻(KNN)分类器的特征选择方法,旨在提升KNN的分类精度。在MATLAB2022a中实现,WOA负责优化特征子集,通过模拟鲸鱼捕食行为的螺旋式和包围策略搜索最佳特征。KNN则用于评估特征子集的性能。算法流程包括WOA参数初始化、特征二进制编码、适应度函数定义(以分类准确率为基准)、WOA迭代搜索及最优解输出。该方法有效地结合了启发式搜索与机器学习,优化特征选择,提高分类性能。
|
4天前
|
机器学习/深度学习 算法 数据可视化
m基于PSO-LSTM粒子群优化长短记忆网络的电力负荷数据预测算法matlab仿真
在MATLAB 2022a中,应用PSO优化的LSTM模型提升了电力负荷预测效果。优化前预测波动大,优化后预测更稳定。PSO借鉴群体智能,寻找LSTM超参数(如学习率、隐藏层大小)的最优组合,以最小化误差。LSTM通过门控机制处理序列数据。代码显示了模型训练、预测及误差可视化过程。经过优化,模型性能得到改善。
19 6
|
1天前
|
缓存 算法
基于机会网络编码(COPE)的卫星网络路由算法matlab仿真
**摘要:** 该程序实现了一个基于机会网络编码(COPE)的卫星网络路由算法,旨在提升无线网络的传输效率和吞吐量。在MATLAB2022a中测试,结果显示了不同数据流个数下的网络吞吐量。算法通过Dijkstra函数寻找路径,计算编码机会(Nab和Nx),并根据编码机会减少传输次数。当有编码机会时,中间节点执行编码和解码操作,优化传输路径。结果以图表形式展示,显示数据流与吞吐量的关系,并保存为`R0.mat`。COPE算法预测和利用编码机会,适应卫星网络的动态特性,提高数据传输的可靠性和效率。