【leetcode】二叉树分类、遍历方式、解题思路总结

已于 2024-08-03 11:55:31 修改
阅读量258 收藏
点赞数 2
分类专栏： leetcode刷题总结 文章标签： 数据结构 leetcode
于 2024-04-17 22:39:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zs16113/article/details/131377342
版权

二叉树分类

  • 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。即深度为k，有2^k-1个节点的二叉树。
  • 完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含 1~ 2^(h-1) 个节点。

  • 二叉搜索树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。中序遍历下，二叉搜索树节点的数值是有序序列。

  • 平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树存储方式

  • 链式存储：通过指针把分布在各个地址的节点串联一起。
  • 顺序存储：顺序存储的元素在内存是连续分布的，如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

递归函数设计步骤

  1. 确定递归函数的函数和返回值
  2. 确定终止条件
  3. 确定单层递归的逻辑

二叉树的遍历

深度优先遍历

深度优先遍历：先往深走，遇到叶子节点再往回走。前中后遍历，其实指的是中间节点的遍历顺序，遍历的差异点在于访问顺序和处理顺序的不同。深度优先遍历需要利用栈存放访问过的节点、未访问过的（待处理的）节点

深入理解：

  1. 前中后序遍历是遍历二叉树过程中处理每一个节点的三个特殊时间点。二叉树的所有问题，就是让我们在前中后序位置注入巧妙的代码逻辑，去达到题目的目的，我们只需要单独思考每一个节点应该做什么，其他的不用管，抛给二叉树遍历框架，递归会在所有节点上做相同的操作
  2. 前序位置的代码执行是自顶向下的，而后序位置的代码执行是自底向上的。前序位置的代码只能从函数参数中获取父节点传递来的数据，而后序位置的代码不仅可以获取参数数据，还可以获取到子树通过函数返回值传递回来的数据

前序遍历（递归法，迭代法）

递归法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        res = []
        self.traversal(root, res)
        return res

    def traversal(self, cur, r):
        if cur is None:
            return
        r.append(cur.val)
        self.traversal(cur.left, r)
        self.traversal(cur.right, r)

迭代法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        res = []
        if root is None:
            return res
        # 同时记录访问过的节点和未访问过节点，访问过节点后用None跟随表示
        stack = [root]
        while stack:
            node = stack.pop()
            if node is not None:
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
                stack.append(node)
                stack.append(None)
            else:
                res.append(stack.pop().val)
        return res

中序遍历（递归法，迭代法）

递归法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        res = []
        self.traversal(root, res)
        return res

    def traversal(self, cur, r):
        if cur is None:
            return
        self.traversal(cur.left, r)
        r.append(cur.val)
        self.traversal(cur.right, r)

迭代法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        res = []
        if root is None:
            return res
        # 同时记录访问过的节点和未访问过节点，访问过节点后用None跟随表示
        stack = [root]
        while stack:
            node = stack.pop()
            if node is not None:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                res.append(stack.pop().val)
        return res

后序遍历（递归法，迭代法）

递归法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        res = []
        self.traversal(root, res)
        return res

    def traversal(self, cur, r):
        if cur is None:
            return
        self.traversal(cur.left, r)
        self.traversal(cur.right, r)
        r.append(cur.val)

迭代法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        res = []
        if root is None:
            return res
        # 同时记录访问过的节点和未访问过节点，访问过节点后用None跟随表示
        stack = [root]
        while stack:
            node = stack.pop()
            if node is not None:
                stack.append(node)
                stack.append(None)
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
            else:
                res.append(stack.pop().val)
        return res

广度优先遍历

广度优先遍历：一层一层的去遍历。广度优先遍历需要利用队列存放待处理的节点。

层次遍历（递归法、迭代法）

递归法（这种思路从结果上说确实可以得到层序遍历结果，但其本质还是二叉树的前序遍历，而不是层序遍历，因为这个解法是依赖前序遍历自顶向下、自左向右的顺序特点得到了正确的结果）

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        levels = []

        def traverse(node, level):
            if not node:
                return
            if len(levels) == level:
                levels.append([])
            levels[level].append(node.val)
            traverse(node.left, level + 1)
            traverse(node.right, level + 1)

        traverse(root, 0)
        return levels

迭代法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        from collections import deque
        res = []
        if root is None:
            return res
        queue = deque([root])
        while queue:
            tmp_res = []
            tmp_num = len(queue)
            for i in range(tmp_num):
                node = queue.popleft()
                tmp_res.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(tmp_res)
        return res

二叉树问题的解题思路

二叉树解题的思维模式分两类，有的题可能两种思路都可以解决，有的题只能用其中一种解决：

  1. 是否可以通过遍历一遍二叉树得到答案？如果可以，用一个traversal函数，此时递归函数一般不带返回值，依靠更新外部变量来计算结果，这叫遍历的思维模式（如果遇到找到一个合法答案后终止递归的问题，依旧推荐traversal函数就起到遍历的作用，不要带返回值，至于是否找到了答案，由外部变量控制）
  2. 是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，首先写出这个递归函数的定义，此时递归函数一般会有返回值，返回值是子问题的计算结果，然后在后序位置做文章，这叫分解问题的思维模式
  3. 无论使用哪一种思维模式，你都要明白二叉树的每一个节点需要做什么，需要在什么位置（前中后序）做

动态规划/DFS/回溯算法都可以看做二叉树问题的扩展，只是它们的关注点不同：

  • 动态规划算法属于分解问题的思路，它的关注点在整棵「子树」
  • 回溯算法属于遍历的思路，它的关注点在节点间的「树枝」
  • DFS 算法属于遍历的思路，它的关注点在单个「节点」
zs1996_
关注
专栏目录
leetcode二叉树的四种遍历(迭代)及构造(C语言)
ygl184的博客
04-29 1686
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、二叉树中序遍历非递归方法1.1设计思路1.2代码二、前序遍历方法2.1设计思路2.2代码三、后序遍历3.1设计思路3.2代码四、层次遍历4.1设计思路4.2代码五、二叉树的构造(递归方法)5.1设计思路5.2代码 前言 遍历二叉树（非递归）需要每个结点输出一次，而每个元素只进栈或出栈一次，因此写代码的时候可以将输出与进栈或出栈一起考虑。 实现算法时只考虑树的结点如何按顺序进栈出栈。 一、二叉树中序遍历非递归方法 1.1.
LeetCode094——二叉树的中序遍历
热门推荐
清风阁
08-26 1万+
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/description/ 题目描述： 知识点：二叉树、中序遍历、递归 思路一：递归实现 学过数据结构的人都知道，二叉树天然的具有递归性质，因为二叉...
LeetCode刷题记-二叉树篇-遍历
weixin_53162079的博客
03-14 234
其实拿到这道题，我很快就有了一个思路，既然是轴对称的，那我把这棵树翻转过来，如果还和原来的树一样，那不就是轴对称的了吗，我试图先去翻转这棵树，然后返回的头节点与原来的头节点比较，相同就是轴对称，反之不是。这看似正确，但是我是天真地以为一个头节点就能代表一整棵树了，以为比较头节点就相当于比较一整棵树，显然是不行的。那既然头节点无法代表一整棵树，我们必然要把这棵树从中间切开，依次比较对应的值是否相同嘛，只要搞清楚是谁和谁比较就行了。题目要求的是一个集合，里面再嵌套集合，里面的集合包含了每一层的所有节点值。
[编程题] LeetCode上的Tree类型的题目
notHeadache的博客
09-04 1503
继之前做完 回文 动态规划 回溯 BackTracking 的题目之后，我又做了LeetCode上关于树的题目：https://leetcode.com/tag/tree/在做的过程中有些题没有思路，于是便看了 Discuss 或者《Cracking the coding Interview》和算法导论等书籍，下面从 Easy ~ Hard 给出答案：这里二叉树的结构是：/** * Definit
LeetCode 二叉树的层次遍历
hestyle的博客
02-19 8517
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 二叉树层次遍历：按照二叉树的层次，从根节点所在的层，逐层进行遍历。逐层遍历时按照从...
LeetCode 算法：二叉树的中序遍历 c++
想都是问题，做才有答案～～
06-23 1032
LeetCode 算法：二叉树的中序遍历 c++
【LeetCode】144.二叉树的前序遍历
kezade的blog
04-18 498
LeetCode 第144题 二叉树前序遍历的两种方式
LeetCode 二叉树的中序遍历 (最详细的解法！！！)
Student_xiao_ming的博客
11-28 622
给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ **解题思路：**二叉树的中序遍历：左根右。采用递归的思路很简单。直接看代码吧。 代码： /** * Definition for a binary tree node. * struct TreeNode { * ...
二叉树的层次遍历（LeetCode）
weixin_43573824的博客
06-06 264
题目描述： 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树:[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 解题思路： 利用队列的先进先出原则，先将每一层的节点...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所说的中序遍历，就是按照这个顺序：左子树—> 根结点 —> 右子树的顺序来遍历的。那么递归就很好写了，我还是...
php-leetcode题解之二叉树的层次遍历II.zip
06-08
在IT领域，尤其是在编程竞赛和面试中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的算法问题供程序员解决...同时，通过研究他人的解题思路，可以学习到不同的编程技巧，这对于个人的成长和职业发展都大有裨益。
LeetCode 1379. 找出克隆二叉树中的相同节点（二叉树遍历）
12-21
找出克隆二叉树中的相同节点" 是一个关于二叉树遍历的问题。在这个问题中，我们被给予两棵二叉树，一棵是原始树 `original`，另一棵是其副本，即克隆树 `cloned`，还有一个目标节点 `target`，它存在于原始树中。...
数据结构之——树形结构
m0_71974552的博客
10-07 1508
数据结构之树形结构：强大而灵活的数据组织方式
知识改变命运 数据结构【优先级队列(堆)】
2402_84062064的博客
10-08 1684
堆的使用
java-02 数据结构-队列
wyh106115的博客
10-09 921
在Java中，队列是一种常见的数据结构，用于在保持顺序的同时存储和检索数据。Java提供了java.util.Queue接口，它的常见实现包括ArrayDeque、LinkedList和PriorityQueue等。
Redis Bitmap 数据结构在权限管理、数据分析以及广告投放中的应用
最新发布
欢迎来到【技术拾光者】，在这里，我们专注分享编程教程、技术趋势、实战案例和优质资源。不定期举办技术问答、专家访谈和职业指导。加入我们，共同探索技术世界，提升技能，拓展职业道路！
10-11 364
Redis 的 Bitmap 是一种高效的位操作数据结构，适用于存储和处理大量布尔值（0 或 1）。本文探讨了 Redis Bitmap 在多个实际应用场景中的使用方法，包括权限管理以及数据分析和广告投放。通过具体的 Java 示例代码，展示了如何利用 Bitmap 提高数据存储和处理的效率。这些示例不仅帮助理解 Bitmap 的基本操作，还展示了其在实际业务中的广泛应用，提供了实用的解决方案。
数据结构--堆的深度解析
2302_81410974的博客
10-08 2173
堆（Heap）是一种非常重要的非线性数据结构，广泛应用于各种算法和问题解决中，如优先队列、堆排序、Top-k 问题等。本文将深入解析堆的定义、类型、操作、应用及其优缺点。
数据结构--List的介绍
2301_80176093的博客
10-07 959
在集合框架中，
C语言实现LeetCode第107题二叉树层序遍历解析
- 该题目的变种可能涉及不同的二叉树遍历方式，对面试者在递归、迭代、层序和非递归等多方面知识的掌握程度进行测试。 5. 代码实现和调试技巧： - 使用C语言编写算法时，要注意代码的规范性和可读性，这对团队...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值