二叉树中常见的使用方法逻辑整理

已于 2024-04-14 10:40:24 修改
阅读量718 收藏 11
点赞数 10
分类专栏： Python Go Java 文章标签： 数据结构 二叉树
于 2024-04-13 21:33:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43845924/article/details/137725860
版权
Python 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
Go
8 篇文章 0 订阅
订阅专栏
Java
8 篇文章 0 订阅
订阅专栏

文章目录

二叉树常见的使用方法逻辑整理

1. 二叉树特点

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

二叉树特点

  • 性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
  • 性质2: 深度为k的二叉树至多有2^k - 1个结点（k>0）
  • 性质3: 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
  • 性质4:具有n个结点的完全二叉树的深度必为 log2(n+1)
  • 性质5:对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）

1.1 完全二叉树

完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。

在这里插入图片描述

1.2 满二叉树

除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。

在这里插入图片描述

2. 二叉树创建

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

class Tree():
    def __init__(self):
        self.root = None
        self.queue = [] #用来存放正在操作的三个树节点，分别是root,left和right
        self.create_queue = [] #用来存放先序序列来创建二叉树

2.1 通过先序序列带有叶子结点标识符创建二叉树

#通过先序序列创建二叉树，没有左右子节点被标记为'#'
def createTree(self):
    current = self.create_queue.pop(0)
    if current != '#':
        new_node = Node(current)
        if self.root is None:
            self.root = new_node
        new_node.left = self.createTree()
        new_node.right = self.createTree()
        return new_node
    return None

2.2 通过层次遍历顺序创建二叉树

#通过层次遍历顺序创建二叉树
def add(self, val):
    new_node = Node(val)
    self.queue.append(new_node)
    if self.root is None:
        self.root = new_node
        return 
    tree_node = self.queue[0]
    if tree_node.left is None:
        tree_node.left = new_node
    else:
        tree_node.right = new_node
        self.queue.pop(0)

2.3 通过 先序+中序 创建二叉树

#通过前序序列和中序序列创建二叉树
def create_tree(self, pre_order, mid_order):
    if len(pre_order) == 0:
        return None
    new_node = Node(pre_order[0])
    if self.root is None:
        self.root = new_node
    i = mid_order.index(pre_order[0])
    print(i)
    new_node.left = self.create_tree(pre_order[1:1+i], mid_order[:i])
    new_node.right = self.create_tree(pre_order[1+i:], mid_order[i+1:])
    return new_node

2.4 通过 先序+中序 创建二叉树

#通过前序序列和中序序列创建二叉树
def create_tree(self, pre_order, mid_order):
    if len(pre_order) == 0:
        return None
    new_node = Node(pre_order[0])
    if self.root is None:
        self.root = new_node
    i = mid_order.index(pre_order[0])
    print(i)
    new_node.left = self.create_tree(pre_order[1:1+i], mid_order[:i])
    new_node.right = self.create_tree(pre_order[1+i:], mid_order[i+1:])
    return new_node

2.5 通过 中序+后序 创建二叉树

#通过中序和后序创建二叉树
def construct_tree(self, mid_order, post_order):
    length = len(post_order)
    if length == 0:
        return None
    new_node = Node(post_order[-1])
    if self.root is None:
        self.root = new_node
    i = mid_order.index(post_order[-1])
    new_node.left = self.construct_tree(mid_order[:i], post_order[:i])
    new_node.right = self.construct_tree(mid_order[i+1:], post_order[length-2-i:length-1])
    return new_node

3. 二叉树遍历通用方法

二叉树的遍历方式通常有2种

  • 深度搜索(dfs)：先序遍历、中序遍历、后序遍历
  • 广度搜索(bfs): 广度优先遍历

针对深度搜索的3种方式，对应的访问路径不同，需要根据实际情况进行调整

3.1 先序遍历(深度递归)

#通过递归进行先序遍历
def dfs(self, root):
    if root is None: return
    print(root.val)
    self.recursion_vlr(root.left)
    self.recursion_vlr(root.right)

遍历顺序：根节点→左孩子→右孩子，注意所有子树都是按照该顺序访问

在这里插入图片描述

3.2 中序遍历(深度递归)

#通过递归进行中序遍历
def dfs(self, root):
    if root is None: return
    self.recursion_lvr(root.left)
    print(root.val)
    self.recursion_lvr(root.right)

遍历顺序：左孩子→根节点→右孩子，注意所有子树都是按照该顺序访问

在这里插入图片描述

3.3 后序遍历(深度递归)

#通过递归进行后序遍历
def dfs(self, root):
    if root is None: return
    self.recursion_lrv(root.left)
    self.recursion_lrv(root.right)
    print(root.val)

遍历顺序：左孩子→根节点→右孩子，注意所有子树都是按照该顺序访问

在这里插入图片描述

3.4 广度优先遍历(BFS)

#利用队列进行广度优先遍历BFS
def bfs(self):
    queue = []
    current = self.root
    queue.append(current)
    while queue:
        current = queue.pop(0)
        print(current.val)
        if current.left: queue.append(current.left)
        if current.right: queue.append(current.right)

4. 常见面试题

一些总结

4.1 二叉树的中序遍历

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

在这里插入图片描述

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

输入：root = []
输出：[]
示例 3：

输入：root = [1]
输出：[1]

# 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):
        """
        :type root: TreeNode
        :rtype: List[int]
        """

        rs = []
        def dfs(root, res):
            if root is None:
                return 
            
            dfs(root.left,res)
            res.append(root.val)
            dfs(root.right,res)
        
        dfs(root, res)
        return res

4.2 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：

输入：root = [1,null,2]
输出：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 maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None: return 0
        left_height = self.maxDepth(root.left)
        right_height = self.maxDepth(root.right)
        return max(left_height, right_height) + 1

4.3 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

在这里插入图片描述

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

在这里插入图片描述

输入：root = [2,1,3]
输出：[2,3,1]

示例 3：

输入：root = []
输出：[]

# 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 invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

4.4 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

在这里插入图片描述

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

在这里插入图片描述

输入：root = [1,2,2,null,3,null,3]
输出：false

# 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 isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:return True
        def dfs(left, right):
            if not (left or right): return True
            if not (left and right): return False
            if left.val != right.val: return False
            return dfs(left.right, right.left) and dfs(left.left, right.right)
        return dfs(root.left, root.right)

4.5 二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。

在这里插入图片描述

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的 长度 由它们之间边数表示。

示例 1：

在这里插入图片描述

输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。

示例 2：

输入：root = [1,2]
输出：1

# 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 diameterOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.res = 1
        def dfs(root):
            if root is None: return 0 
            l = dfs(root.left)
            r = dfs(root.right)
            self.res = max(self.res, l + r + 1)
            return max(l,r) + 1
        
        dfs(root)
        return self.res -1

4.6 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

# 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):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        if not root: return res
        
        queue = [root]
        while queue:
            size = len(queue)
            tmp = []
            for _ in range(0, size):
                r = queue.pop(0)
                tmp.append(r.val)
                if r.left: queue.append(r.left)
                if r.right: queue.append(r.right)
            res.append(tmp)
        return res

4.7 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵平衡二叉搜索树。

示例 1：

在这里插入图片描述

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

在这里插入图片描述

示例 2：

在这里插入图片描述

输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

# 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 sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        def dfs(nums, low, high):
            if(low > high): return 
            
            # 以中间树作为根
            mid = low + (high - low) /2 
            root = TreeNode(nums[mid])
            root.left = dfs(nums, low, mid - 1)
            root.right = dfs(nums, mid + 1, high)
            return root
        
        return dfs(nums, 0, len(nums) - 1)

5. 参考文档

暂无，相关面试题请参考letcode以及相关说明

李姓门徒
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用归并删除法删除二叉树中节点的方法
09-03
主要介绍了java使用归并删除法删除二叉树中节点的方法,实例分析了java二叉树算法的相关操作技巧,需要的朋友可以参考下
Python实现重建二叉树的三种方法详解
12-24
学习算法中，探寻重建二叉树的方法： 用input 前序遍历顺序输入字符重建 前序遍历顺序字符串递归解析重建 前序遍历顺序字符串堆栈解析重建 如果懒得去看后面的内容，可以直接点击此处本站下载完整实例代码。 思路...
C++实现二叉树非递归遍历方法实例总结
01-20
一般来说，二叉树的遍历是C++程序员在面试中经常考察的，其实前中后三种顺序的遍历都大同小异，自己模拟两个栈用笔画画是不难写出代码的。现举一个非递归遍历的方法如下，供大家参考。 具体代码如下： class ...
JS二叉树的简单实现方法示例
12-09
本文实例讲述了JS二叉树的简单实现方法。分享给大家供大家参考，具体如下： 今天学习了一下 二叉树的实现，在此记录一下 简单的二叉树实现，并且实现升序和降序排序输出 function Node(data , left,right){ this....
Python对称的二叉树多种思路实现方法
12-20
对称二叉树的含义非常容易理解，左右子树关于根节点对称，具体来讲，对于一颗对称二叉树的每一颗子树，以穿过根节点的直线为对称轴，左边子树的左节点=右边子树的右节点，左边子树的右节点=左边子树的左节点。...
数据结构 | 详解栈实现队列&队列实现栈
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 528
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 688
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
数据结构选择题
m0_67187271的博客
05-17 367
由于是对称矩阵，我们可以将其压缩存储到一维数组中，只需存储上三角部分的元素加上对角线的元素，即 ( 45 + 10 = 55 ) 个元素。现在，我们再次添加一个元素 'f'，其下标为 1（因为队列是循环的），此时尾指针 r 回到了 1 的位置。选项A描述的是有一个以上根结点的数据结构，这在标准的数据结构分类中并不存在，因为根结点通常指的是树或图结构的起始点，而一个结构中只能有一个起点。因此，正确答案是B，只有一个根结点的数据结构不一定是线性结构，这可能指的是树或图结构，它们是非线性结构。
数据结构 之 Map & Set
AUGENSTERN_dc的博客
05-18 943
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的 搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复杂度为,但搜索前必须要求序列是有序的 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： 根据姓名查询考试成绩 通讯录，即根据姓名查询联系方式 不重复集合，即需要先搜索关键字是否已经在集合中 可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本
数据结构——01-抽奖数人-链表-实验题目与解答
——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-14 904
在抽奖过程中，我通过循环和条件判断来模拟报数过程，并在每次报数到m时，输出中奖者的编号，并从数组中移除该编号。n个人围成一圈，由第一个人开始，依次报数，数到第m人，便抽出来作为中奖人，然后从他的下一个人数起，数到第m人，再抽出来作为中奖人，如此循环，直到抽出k个为止。在本次实验中，我深入探索了数据结构的魅力，通过实现一个抽奖游戏，我不仅巩固了对顺序存储结构和链式存储结构的理解，还提升了我的编程实践能力。当k>0时，从index开始循环数组，每数到第m个人，就将其编号输出，并从数组中移除该编号。
【数据结构】树（Tree）
SWsunlight的博客
05-16 653
树、二叉树
数据结构-队列(带图详解)
2302_78381559的博客
05-17 1074
链表是一种基本的数据结构，它用于存储一系列元素（节点），每个节点不仅包含数据元素，还包含一个指向下一个节点的指针。在链表中，数据并非连续地存储在内存中，而是通过每个节点的指针链接起来形成一个逻辑上的线性序列通过前面我们学习的顺序表我们现在延伸一个链表我们会发现顺序表的一些缺点。：顾客在超市收银台前排队等待付款，先到的顾客先完成结账离开，后来的顾客依次跟进。：在餐厅，特别是快餐店，顾客排队等待点餐和取餐，先排队的顾客先完成点餐流程。：在办公室，多个人提交打印任务时，打印机会按照任务提交的顺序依次执行打印。
第十三讲：指针（5）
最新发布
2301_79761834的博客
05-18 954
第十三讲：指针（5）
探索数据结构：堆的具体实现与应用
Bettysweetyaaa的博客
05-14 794
堆是一种重要的数据结构，常用于优先队列和堆排序等算法中。它是一个特殊的树形结构，满足堆属性，即父节点的值总是大于或小于其子节点的值。堆可以分为最大堆和最小堆两种类型，具有高效的插入、删除和查找最值的操作。在实际应用中，堆被广泛运用于调度算法、图论算法以及操作系统等领域。
【探索数据结构】线性表之顺序表
2301_80840905的博客
05-17 1271
线性表在逻辑结构上是连续的，在物理结构上不一定是连续的。线性表中的顺序表（本篇的主角）在物理结构上是连续的，而线性表中的链表在物流结构上却是不连续的。
数据结构进阶——搜索二叉树
weixin_73870552的博客
05-14 803
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；它的左右子树也分别为二叉搜索树。// 左节点// 右节点K _key;,_key(key){}public:// ... 相关接口实现protected:节点的定义中提供了一个构造函数，方便在后续实现相关接口的时候使用。
AMS相关数据结构
weixin_43700867的博客
05-14 879
图中的方框可以理解为一个中包含关系：譬如一个TaskRecord中包含多个ActivityRecord;图中的连接线可以理解为等价关系，譬如同一个ActivityRecord会被TaskRecord和ProcessRecord引用，两者是从不同维度来管理ActivityRecord。
二叉树中序遍历的最优逻辑
12-03
二叉树的中序遍历是指先遍历左子树，再遍历根节点，最后遍历右子树。其最优逻辑是使用递归实现，具体步骤如下： 1. 判断当前节点是否为空，如果为空则返回。 2. 递归遍历左子树。 3. 输出当前节点的值。 4. 递归遍历右子树。 下面是一个示例代码： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def inorderTraversal(root: TreeNode) -> List[int]: res = [] def inorder(node): if not node: return inorder(node.left) res.append(node.val) inorder(node.right) inorder(root) return res ``` 其中，TreeNode是二叉树的节点类，inorderTraversal是中序遍历函数，root是二叉树的根节点。函数中使用了一个辅助函数inorder来实现递归遍历。在inorder函数中，先递归遍历左子树，再将当前节点的值加入结果列表，最后递归遍历右子树。最后返回结果列表即可。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值