剑指 Offer 最优题解系列python--二叉树

最新推荐文章于 2022-07-22 19:11:13 发布
最新推荐文章于 2022-07-22 19:11:13 发布
阅读量425 收藏
点赞数
文章标签： 数据结构 算法 二叉树 面试 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tunnel_/article/details/107803542
版权

剑指 Offer 最优题解系列python--二叉树

1.重建二叉树

明天补思路睡了。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        self.dic, self.po = {}, preorder
        for i in range(len(inorder)):
            self.dic[inorder[i]] = i
        return self.recur(0, 0, len(inorder) - 1)

    def recur(self, pre_root, in_left, in_right):
        if in_left > in_right: return # 终止条件：中序遍历为空
        root = TreeNode(self.po[pre_root]) # 建立当前子树的根节点
        i = self.dic[self.po[pre_root]]    # 搜索根节点在中序遍历中的索引，从而可对根节点、左子树、右子树完成划分。
        root.left = self.recur(pre_root + 1, in_left, i - 1) # 开启左子树的下层递归
        root.right = self.recur(i - in_left + pre_root + 1, i + 1, in_right) # 开启右子树的下层递归
        return root # 返回根节点，作为上层递归的左（右）子节点

在这里插入图片描述

复杂度分析

  • 时间复杂度 O(N) ： N为树的节点数量。初始化 HashMap 需遍历 inorder ，占用 O(N) ；递归共建立 N个节点，每层递归中的节点建立、搜索操作占用 O(1) ，因此递归占用 O(N)。（最差情况为所有子树只有左节点，树退化为链表，此时递归深度 O(N) ；平均情况下递归深度 O(log_2 N)。

  • 空间复杂度 O(N) ： HashMap 使用 O(N) 额外空间；递归操作中系统需使用 O(N)额外空间。

2.树的子结构

解题思路：
若树 B 是树 A 的子结构，则子结构的根节点可能为树 A 的任意一个节点。因此，判断树 B 是否是树 A 的子结构，需完成以下两步工作：

  1. 先序遍历树 A 中的每个节点 n_A
    （对应函数 isSubStructure(A, B)）
  2. 判断树 A中 以 n_A 为根节点的子树 是否包含树 B 。（对应函数 recur(A, B)）

在这里插入图片描述

recur(A, B) 函数：

  1. 终止条件：
  • 当节点 B为空：说明树 B 已匹配完成（越过叶子节点），因此返回 truetrue ；
  • 当节点 A 为空：说明已经越过树 A 叶子节点，即匹配失败，返回 false ；
  • 当节点 A 和 B 的值不同：说明匹配失败，返回false ；
  1. 返回值：
    判断 A 和 B 的左子节点是否相等，即 recur(A.left, B.left) ；
    判断A 和 B 的右子节点是否相等，即 recur(A.right, B.right) ；

isSubStructure(A, B) 函数：

  1. 特例处理： 当 树 A 为空 或 树 B 为空 时，直接返回 false ；
  2. 返回值：
    1. 若树 B 是树 A 的子结构，则必满足以下三种情况之一，因此用或 || 连接；
    2. 以 节点 A 为根节点的子树 包含树 B ，对应 recur(A, B)；
    3. 树 BB 是 树 AA 左子树 的子结构，对应 isSubStructure(A.left, B)；
    树 BB 是 树 AA 右子树 的子结构，对应 isSubStructure(A.right, B)；
class Solution(object):
    def isSubStructure(self, A, B):
        """
        :type A: TreeNode
        :type B: TreeNode
        :rtype: bool
        """
        def recur(A, B):
            if not B: return True
            if not A or A.val != B.val: return False
            return recur(A.left, B.left) and recur(A.right, B.right)

        return bool(A and B) and (recur(A, B) or self.isSubStructure(A.left, B) or self.isSubStructure(A.right, B))

在这里插入图片描述
复杂度分析：
时间复杂度 O(MN)： 其中 M,N 分别为树 A 和 树 B 的节点数量；先序遍历树 A 占用 O(M) ，每次调用 recur(A, B) 判断占用 O(N) 。
空间复杂度O(M) ： 当树 A 和树 B 都退化为链表时，递归调用深度最大。当 M ≤N 时，遍历树 A 与递归判断的总递归深度为 M ；当 M>N 时，最差情况为遍历至树 A 叶子节点，此时总递归深度为 M。

3.二叉树的镜像

方法一：递归法
根据二叉树镜像的定义，考虑递归遍历（dfs）二叉树，交换每个节点的左 / 右子节点，即可生成二叉树的镜像。
递归解析：

  • 终止条件： 当节点 root 为空时（即越过叶节点），则返回 null ；
  • 递推工作：
    – 初始化节点 tmp ，用于暂存 root 的左子节点；
    – 开启递归 右子节点mirrorTree(root.right)mirrorTree(root.right) ，并将返回值作为 root的 左子节点 。
    – 开启递归 左子节点 mirrorTree(tmp)，并将返回值作为 root 的 右子节点 。
  • 返回值： 返回当前节点 root；
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def mirrorTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root: return
        root.left, root.right = self.mirrorTree(root.right), self.mirrorTree(root.left)
        return root

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def mirrorTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root: return
        tmp = root.left
        root.left = self.mirrorTree(root.right)
        root.right = self.mirrorTree(tmp)
        return root

在这里插入图片描述
复杂度分析：

  • 时间复杂度 O(N) ： 其中 N 为二叉树的节点数量，建立二叉树镜像需要遍历树的所有节点，占用 O(N) 时间。
  • 空间复杂度 O(N) ： 最差情况下（当二叉树退化为链表），递归时系统需使用 O(N)大小的栈空间。

方法二：辅助栈（或队列）
利用栈（或队列）遍历树的所有节点 node ，并交换每个 node 的左 / 右子节点。

  • 算法流程：
    – 特例处理： 当 root为空时，直接返回 nullnull ；
    – 初始化： 栈（或队列），本文用栈，并加入根节点 rootroot 。
    –循环交换： 当栈 stack 为空时跳出；
  1. 出栈： 记为 nodenode ；
  2. 添加子节点： 将 nodenode 左和右子节点入栈；
  3. 交换： 交换 node 的左 / 右子节点。

– 返回值： 返回根节点 root 。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def mirrorTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root: return
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left: stack.append(node.left)
            if node.right: stack.append(node.right)
            node.left, node.right = node.right, node.left
        return root

在这里插入图片描述
复杂度分析：

  • 时间复杂度 O(N) ： 其中 NN 为二叉树的节点数量，建立二叉树镜像需要遍历树的所有节点，占用 O(N)时间。
  • 空间复杂度 O(N) ： 最差情况下（当为满二叉树时），栈 stack 最多同时存储 N/2个节点，占用 O(N)额外空间。

来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

4.从上到下打印二叉树1

解题思路：

  • 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。
  • BFS 通常借助 队列 的先入先出特性来实现。
    算法流程：
  • 特例处理： 当树的根节点为空，则直接返回空列表 [] ；
  • 初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；
  • BFS 循环： 当队列 queue 为空时跳出；
    – 出队： 队首元素出队，记为 node；
    – 打印： 将 node.val 添加至列表 tmp 尾部；
    – 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
  • 返回值： 返回打印结果列表 res 即可。
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            res.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return res

在这里插入图片描述
复杂度分析：
时间复杂度 O(N) ： N 为二叉树的节点数量，即 BFS 需循环 N 次。
空间复杂度 O(N)： 最差情况下，即当树为平衡二叉树时，最多有 N/2 个树节点同时在 queue 中，使用 O(N) 大小的额外空间。

5.从上到下打印二叉树2

解题思路：

  • 按层打印： 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。

  • 每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

算法流程：

  • 特例处理： 当根节点为空，则返回空列表 [] ；

  • 初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；

  • BFS 循环： 当队列 queue 为空时跳出；
    –1.新建一个临时列表 tmp ，用于存储当前层打印结果；
    –2.当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；

      1.出队： 队首元素出队，记为 node；
  2.打印： 将 node.val 添加至 tmp 尾部；
  3.添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；

    –3.将当前层结果 tmp 添加入 res 。

  • 返回值： 返回打印结果列表 res 即可。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp)
        return res

在这里插入图片描述
复杂度分析：

  • 时间复杂度 O(N)： N为二叉树的节点数量，即 BFS 需循环 N 次。
  • 空间复杂度 O(N) ： 最差情况下，即当树为平衡二叉树时，最多有 N/2 个树节点同时在 queue 中，使用 O(N) 大小的额外空间。

从上到下打印二叉树 3

本题额外要求 打印顺序交替变化
方法一：层序遍历 + 双端队列
利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：

  • 奇数层 则添加至 tmp 尾部 ，
  • 偶数层 则添加至 tmp 头部 。
    算法流程：
  1. 打印： 若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root: return []
        res, deque = [], collections.deque([root])
        while deque:
            tmp = collections.deque()
            for _ in range(len(deque)):
                node = deque.popleft()
                if len(res) % 2: tmp.appendleft(node.val) # 偶数层 -> 队列头部
                else: tmp.append(node.val) # 奇数层 -> 队列尾部
                if node.left: deque.append(node.left)
                if node.right: deque.append(node.right)
            res.append(list(tmp))
        return res

在这里插入图片描述

复杂度分析：

  • 时间复杂度 O(N) ： N为二叉树的节点数量，即 BFS 需循环 N 次，占用 O(N) ；双端队列的队首和队尾的添加和删除操作的时间复杂度均为 O(1) 。
  • 空间复杂度 O(N) ： 最差情况下，即当树为满二叉树时，最多有 N/2 个树节点 同时 在 deque 中，使用O(N) 大小的额外空间。

方法二：层序遍历 + 双端队列（奇偶层逻辑分离）
方法一代码简短、容易实现；但需要判断每个节点的所在层奇偶性，即冗余了 NN 次判断。
通过将奇偶层逻辑拆分，可以消除冗余的判断。
算法流程：
与方法一对比，仅 BFS 循环不同。

BFS 循环： 循环打印奇 / 偶数层，当 deque 为空时跳出；
打印奇数层： 从左向右 打印，先左后右 加入下层节点；
若 deque 为空，说明向下无偶数层，则跳出；
打印偶数层： 从右向左 打印，先右后左 加入下层节点；

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root: return []
        res, deque = [], collections.deque()
        deque.append(root)
        while deque:
            tmp = []
            # 打印奇数层
            for _ in range(len(deque)):
                # 从左向右打印
                node = deque.popleft()
                tmp.append(node.val)
                # 先左后右加入下层节点
                if node.left: deque.append(node.left)
                if node.right: deque.append(node.right)
            res.append(tmp)
            if not deque: break # 若为空则提前跳出
            # 打印偶数层
            tmp = []
            for _ in range(len(deque)):
                # 从右向左打印
                node = deque.pop()
                tmp.append(node.val)
                # 先右后左加入下层节点
                if node.right: deque.appendleft(node.right)
                if node.left: deque.appendleft(node.left)
            res.append(tmp)
        return res

在这里插入图片描述

复杂度分析：
时间复杂度 O(N)O(N) ： 同方法一。
空间复杂度 O(N)O(N) ： 同方法一。

方法3：

二叉搜索树的后序遍历序列

方法一：递归分治

class Solution(object):
    def verifyPostorder(self, postorder):
        """
        :type postorder: List[int]
        :rtype: bool
        """
        def recur(i, j):
            if i >= j: return True
            p = i
            while postorder[p] < postorder[j]: p += 1
            m = p
            while postorder[p] > postorder[j]: p += 1
            return p == j and recur(i, m - 1) and recur(m, j - 1)

        return recur(0, len(postorder) - 1)

在这里插入图片描述
方法二：辅助单调栈(看不懂跳过)

二叉树中和为某一值的路径

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: List[List[int]]
        """
        res, path = [], []
        def recur(root, tar):
            if not root: return
            path.append(root.val)
            tar -= root.val
            if tar == 0 and not root.left and not root.right:
                res.append(list(path))
            recur(root.left, tar)
            recur(root.right, tar)
            path.pop()

        recur(root, sum)
        return res

在这里插入图片描述

二叉搜索树与双向链表

有点难，过

二叉树的深度

方法一：后序遍历DFS

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root: return 0
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

在这里插入图片描述
方法二：层次遍历

对称的二叉树

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def recur(L, R):
            if not L and not R: return True
            if not L or not R or L.val != R.val: return False
            return recur(L.left, R.right) and recur(L.right, R.left)

        return recur(root.left, root.right) if root else True

在这里插入图片描述

按之字形顺序打印二叉树

二叉树的下一个结点

序列化二叉树

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if not root: return "[]"
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            node = queue.popleft()
            if node:
                res.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else: res.append("null")
        return '[' + ','.join(res) + ']'


        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if data == "[]": return
        vals, i = data[1:-1].split(','), 1
        root = TreeNode(int(vals[0]))
        queue = collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            if vals[i] != "null":
                node.left = TreeNode(int(vals[i]))
                queue.append(node.left)
            i += 1
            if vals[i] != "null":
                node.right = TreeNode(int(vals[i]))
                queue.append(node.right)
            i += 1
        return root



# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

在这里插入图片描述

二叉搜索树的第k大节点

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthLargest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        def dfs(root):
            if not root: return
            dfs(root.right)
            if self.k == 0: return
            self.k -= 1
            if self.k == 0: self.res = root.val
            dfs(root.left)

        self.k = k
        dfs(root)
        return self.res

在这里插入图片描述

隧隧道道
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python实现最优二叉搜索树（OBST）
weixin_44781333的博客
10-01 527
python实现最优二叉搜索树（OBST） 可打印出期望代价表e，权重表w，根节点表root
二叉树最强总结(python实现)
coder_Gray的博客
06-04 4784
这篇文章总结了关于二叉树的创建和各种遍历方式。 二叉树的创建方式 通过层次遍历顺序创建 先序遍历顺序(带上叶子结点标识符)创建 先序顺序+中序顺序 中序顺序+后序顺序 二叉树的递归方式 先序遍历(递归+非递归) 中序遍历(递归+非递归) 后序遍历(递归+非递归) 广度优先遍历(BFS) 首先来定义一下节点的结构 class Node(): def __init__(s...
算法导论程序39--最优二叉搜索树（Python）
勇气与行动
05-31 3725
最优二叉搜索树： 给定一个n个不同关键字的已排序的序列K=（因此k1 有些要搜索的值可能不在K中，因此，我们还有n+1个“伪关键字”d0,d1,d2,...,dn表示不在K中的值。d0表示所有小于k1的值，dn表示所有大于kn的值，对i=1,2,...,n-1伪关键字di表示所有在ki和k(i+1)之间的值。 对每个伪关键字di也都有一个概率qi表示对应的搜索频率。 假定一次搜索的
python实现哈夫曼树
CRUD工程师
08-03 5197
这次是哈夫曼树，又叫最优二叉树，特点就是最大的在上面，小的在下面。 建立步骤大概就是这样的，每次选两个2最小的建立一个然后加上去再做重复操作 现在我们来试着来写出哈夫曼树 首先需要定义一个节点类来保存节点信息，这个节点需要保存的信息包括：数值，左右孩子，是否已加入数中 class Node(): def __init__(self,item): self.it...
单词树（最优二叉树）
sunshine的博客
10-11 2925
在进行文法分析的时候，通常需要检测一个单词是否在我们的单词列表里。为了提高查找和定位的速度，通常都画出与单词列表所对应的单词查找树，其特点如下： 1．根结点不包含字母，除根结点外每一个结点都仅包含一个大写英文字母； 2．从根结点到某一结点，路径上经过的字母依次连起来所构成的字母序列，称为该结点对应的单词。单词列表中的每个单词，都是该单词查找树某个结点所对应的单词； 3．在满足上述条件下，该单词
【剑指offer】python-data-structures-and-algorithms
最新发布
05-06
本教程提供python版本的剑指offer题解，希望对你有所帮助。 2、数据结构和算法是每个程序员需要掌握的基础知识之一，也是面试中跨不过的槛。目前关于 Python 算法和数据结构的系统中文资料比较欠缺， 本教程尝试...
剑指offer题目题解java版+c++版+Python版.zip
07-15
总之，《剑指Offer》题解涵盖了编程基础、算法、设计模式等多个方面，通过不同语言的实现，帮助开发者巩固编程基础，提升解决实际问题的能力。无论是准备面试还是提升自身技术，都是不可或缺的学习资源。
牛客网《剑指Offer》66题 题解-附件资源
03-05
牛客网《剑指Offer》66题 题解-附件资源
剑指offer题解(C++).docx
07-17
此资源是剑指OFFER的题解(C++)，由本人在刷剑指OFFER题的期间整理，其中有整理牛客网讨论区的代码+剑指OFFER书中的代码+自己编写的代码，方法很全，且附有解析和思路，很方便大家在刷题时参考。 资源中题目顺序参照...
python-leetcode面试题解之对称二叉树.zip
03-06
本压缩包文件"python-leetcode面试题解之对称二叉树.zip"显然是针对Python程序员，特别是那些准备面试的人，重点讲解了如何解决LeetCode上的“对称二叉树”问题。 对称二叉树是二叉树的一种特殊形态，它的左右子树...
Python:实现最优二叉搜索树算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-22 641
Python:实现最优二叉搜索树算法(附完整源码)
树------最优二叉树
hd12370的博客
09-28 9266
哈夫曼树是带权路径最小的一种特殊二叉树，所以也称最优二叉树。 在这里不讨论基本概念如如何计算路径等，而只着重于树的创建，具体过程让我们举例而言。 其基本的原理为：将所有节点一开始都视为森林，每次从森林中选取两个根节点权值最小的树合并为一棵新树，新树的根节点大小为两个子节点大小的和，并将这棵新树重新加入到森林中。 如此一来每一轮操作都可以简化为两个基本操作：合并两棵树、插入新树，直到森林中只剩下一...
哈夫曼树及python实现
热门推荐
lzq20115395的博客
12-26 2万+
最近在看《tensorflow实战》中关于RNN一节，里面关于word2vec中涉及到了哈夫曼树，因此在查看了很多博客（文末）介绍后，按自己的理解对概念进行了整理（拼凑了下TXT..），最后自己用python实现Haffuman树的构建及编码。哈夫曼（huffman）树基本概念 路径和路径长度：树中一个结点到另一个结点之间的分支构成这两个结点之间的路径；路径上的分枝数目称作路径长度，它等于路径上的结
python数据结构和算法,八大排序算法,二叉树的实现
qq_42121640的博客
08-28 1725
一些总结. 时间复杂度O 我们关注最坏时间复杂度 1.基本操作,O(1) 2.顺序结构,加法 3.循环结构,乘法 4.分支结构,取最大 5. 忽略次要项 O(1) Python中的顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术，具有前面讨论的顺序表的所有性质。 tuple是不可变类型，即不变的顺序表，因此不支持改变其内部状态的任何操作，而其他方面...
【leetcode】Python实现-111.二叉树的最小深度
神不烦
05-23 2608
111.二叉树的最小深度 描述 我 if root is None: return 0 p = [root] current_level_num = 1 next_level_num = 0 i = 1 while p: current = ...
LeetCode-Python-998. 最大二叉树 II
Keep Coding
02-26 682
最大树定义：一个树，其中每个节点的值都大于其子树中的任何其他值。 给出最大树的根节点root。 就像之前的问题那样，给定的树是从表A（root = Construct(A)）递归地使用下述Construct(A)例程构造的： 如果A为空，返回null 否则，令A[i]作为 A 的最大元素。创建一个值为A[i]的根节点root root的左子树将被构建为Cons...
简述最优二叉树（赫夫曼树）
time_money的博客
11-16 1万+
什么是哈夫曼树： 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 哈夫曼树被用来进行哈夫曼编码，下面来介绍哈夫曼编码： 假设需要传送的电文为“ABACCDA”，它只有四种字符，只需要用两个字符的串就可以分辨，假设A,B,C,D的编码分别是00，01,10,11，则该电文的编码便是：“00010010101100”，总长为14位，对方接收时，只需要二位一
数据结构与算法（python)：二叉树
牛顿爱吃香蕉的博客
03-29 386
文章目录1、树相关概念1.1、树1.2、树的种类1.3、树的存储1.4、应用 1、树相关概念 1.1、树 节点的度：一个节点含有的子树个数 树的度：树中最大的节点的度称为树的度 叶节点或终端节点：度为零的节点 父节点：一个节点含有子节点，这个节点称为子节点的父节点 子节点：一个节点含有的子树的根节点称为该节点的子节点 兄弟节点：含有相同父节点的节点互称兄弟节点 节点的层次：从根节点起，根节点为第...
数据结构——森林和最优二叉树
qq_43627106的博客
12-02 438
森林的逻辑结构 森林是m（m≥0）棵互不相交的树的集合。 森林的前序遍历：前序遍历森林中的每一棵数。 森林的后序遍历：后序遍历森林中的每一棵树。 森林通常有这两种方式。 树、森林与二叉树的转换 1.树转换为二叉树 ①加线——树中所有相邻兄弟结点之间加一条线。 ②去线——对树中的每个结点，只保留它与第一个孩子结点之间的连线，删去它与其他孩子结点之间的连线。 ③层次调整——按照二叉树结点之间的关系...
剑指offer-java-pdf1
08-04
"剑指offer-java-pdf1" "剑指Offer"是一本经典的Java编程面试指南，专注于解决常见的面试问题，帮助求职者提升编程技能和理解算法。这本书的电子版PDF1可能包含了书中部分章节的内容，提供了Java语言实现的代码示例...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值