剑指offer-树专题

最新推荐文章于 2025-12-16 14:17:05 发布
原创 最新推荐文章于 2025-12-16 14:17:05 发布 · 311 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树 #算法 #队列 #python #数据结构

重建二叉树

思路

用递归的方式解决：

  • Root是preorder的首项，在inorder里面找到root对应的位置，即可以确定左右子树。
  • 左子树的root是pre_root的下一项；依然根据root的位置确定root在左子树inorder的顺序，之后一直递归下去。
  • 右子树的root是preorder中右子树的第一项:pre_root+1+i-in_left。根据这个递归下去。

代码

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> 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 # 返回根节点，作为上层递归的左（右）子节点

相似题

106. 从中序与后序遍历序列构造二叉树
代码

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

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

    def recur(self, post_root, in_left, in_right):
        if in_left>in_right : return None
        # 找根节点
        root_node = TreeNode(self.po[post_root])
        if in_left == in_right: 
            return root_node
        # 找根节点在inorder中的位置
        i = self.dic[self.po[post_root]]
        print(i)
        # 递归
        root_node.right = self.recur(post_root-1, i+1, in_right)
        # 左子树考虑清楚，是post_root-(右子树的长度)-1
        root_node.left = self.recur(post_root-in_right+i-1, in_left, i-1)
        
        return root_node

剑指 Offer 26. 树的子结构

思路

经典的“匹配类二叉树问题”。有套路可循：

  • 先匹配根节点
  • 匹配根节点之后对子树进行匹配

在这道题中，写两个函数分别完成这两个功能：dfs 对子树进行匹配；isSubStructure为主函数，对应根节点的匹配。

代码

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

class Solution:
    def dfs(self, a, b):
        if not b: return True
        if not a: return False
        else:
            return a.val == b.val and self.dfs(a.left, b.left) and self.dfs(a.right, b.right)
    def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
        if not A or not B: return False
        return self.dfs(A, B) or self.isSubStructure(A.left, B) or self.isSubStructure(A.right, B)

思考

一道题解决一类题，我们可以用这个思路解决一系列“匹配类二叉树”的题目。

101. 对称二叉树

思路

同上

代码

class Solution:
    def dfs(self, a, b):
        if not a and not b: return True
        elif not a or not b: return False
        return a.val == b.val and self.dfs(a.left, b.right) and self.dfs(a.right, b.left)
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root: return True
        return self.dfs(root.left, root.right)

1367. 二叉树中的列表

思路

只是将其中一个树换成了链表，实际上还是匹配根节点，再匹配子树的套路。

代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

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

class Solution:
    def dfs(self, a, b):
        if not a : return True
        if not b : return False
        return b.val == a.val and \
        (self.dfs(a.next, b.left) or self.dfs(a.next, b.right))
    def isSubPath(self, head: ListNode, root: TreeNode) -> bool:
        if not root or not head: return False
        return self.dfs(head, root) or self.isSubPath(head, root.left) or self.isSubPath(head, root.right)

572. 另一个树的子树

思路

同上

代码

# 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 dfs(self, s, t):
        if not s and not t: return True
        elif not s or not t: return False
        return s.val == t.val and self.dfs(s.left, t.left) and self.dfs(s.right, t.right)
    def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
        if not s or not t: return False
        return self.dfs(s, t) or self.isSubtree(s.left, t) or self.isSubtree(s.right, t)

剑指 Offer 27. 二叉树的镜像

思路

  • 用递归的方法解决：在不None的情况下，新左右等于旧右左。

代码

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

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return None
        root.left, root.right = self.mirrorTree(root.right), self.mirrorTree(root.left)
        return root

剑指 Offer 32 - I. 从上到下打印二叉树

思路

  • 用BFS的方式，即采用queue结构来保存，之后依次写入res，最后打印出来。相当直接。

代码

import queue
class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return []
        q = queue.deque()
        res = []
        q.append(root)
        while q:
            out = q.popleft()
            res.append(out.val)
            if out.left: q.append(out.left)
            if out.right: q.append(out.right)
            
        return res

思考

这里需要注意，queue库中，Queue是依靠List实现的，所以put和insert的平均读写时间是 O ( n ) O(n) O(n). 而deque双向队列是 O ( 1 ) O(1) O(1)。所以用Queue写会超时。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kG3sCswf-1601058243643)(evernotecid://BC7CFB48-5C18-439C-ADB2-AD1171DE2741/appyinxiangcom/18838120/ENResource/p670)]

剑指 Offer 32 - II. 从上到下打印二叉树 II

思路：

同上，不过有一点点改变：在每次循环中把val写入这一层的tmp list，最后append tmp

代码：

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, q = [], collections.deque()
        q.append(root)
        while q:
            tmp = []
            for _ in range(len(q)):
                out = q.popleft()
                if out.left: q.append(out.left)
                if out.right: q.append(out.right)
                tmp.append(out.val)
            res.append(tmp)
        return res

思考：

一定要把边界条件放在最开始考虑

剑指 Offer 32 - III. 从上到下打印二叉树 III

思路

同上，不过每奇数层做一个翻转操作。

代码

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, q = [], collections.deque()
        l = 0
        q.append(root)
        while q:
            tmp = []
            for _ in range(len(q)):
                out = q.popleft()
                if out.left: q.append(out.left)
                if out.right: q.append(out.right)
                tmp.append(out.val)
            if l%2 == 1:
                print(tmp)
                for p in range(len(tmp)):
                    tmp.insert(p, tmp.pop())
            l += 1
            res.append(tmp)
        return res

剑指 Offer 34. 二叉树中和为某一值的路径

思路：

本问题是典型的二叉树方案搜索问题，使用回溯法解决，其包含 先序遍历 + 路径记录 两部分。

  • 先序遍历： 按照 “根、左、右” 的顺序，遍历树的所有节点。

  • 路径记录： 在先序遍历中，记录从根节点到当前节点的路径。当路径为 ① 根节点到叶节点形成的路径 且 ② 各节点值的和等于目标值 sum 时，将此路径加入结果列表。

算法流程：
pathSum(root, sum) 函数：

初始化： 结果列表 res ，路径列表 path 。
返回值： 返回 res 即可。

recur(root, tar) 函数：

递推参数： 当前节点 root ，当前目标值 tar 。
终止条件： 若节点 root 为空，则直接返回。
递推工作：

  • 路径更新： 将当前节点值 root.val 加入路径 path ；

  • 目标值更新： tar = tar - root.val（即目标值 tar 从 sum 减至 00 ）；

  • 路径记录： 当 ① root 为叶节点 且 ② 路径和等于目标值 ，则将此路径 path 加入 res 。

  • 先序遍历： 递归左 / 右子节点。

  • 路径恢复： 向上回溯前，需要将当前节点从路径 path 中删除，即执行 path.pop() 。

代码：

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

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res,path = [],[]
        dif = sum
        def recur(root, dif):
            if not root: return None
            path.append(root.val)
            dif -= root.val
            if dif == 0 and not root.left and not root.right:
            # 这里如果不用list强制构造新list，就会导致res里面加入的是path，是一直变化的。
                res.append(list(path))
            recur(root.left, dif)
            recur(root.right, dif)
            path.pop()
        recur(root, dif)
        return res

思考：

在def里面定义def，能够帮助理清思路。而且不用调用self，局部变量可以直接在内部函数里面调用。backtracking里面要注意，在路径恢复的时候要pop掉当前节点才能返回上一步。

剑指 Offer 54. 二叉搜索树的第k大节点

思路

  • 一个特殊的性质：BST的inorder traversal是从小到大排列好的。
  • 那么这道题就可以从inorder的逆序列。

代码

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> 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

剑指 Offer 55 - I. 二叉树的深度

思路

  • 第一个想到就是BFS，然后之前做的按层level print。可以输出这个res的长度。但非常不直接。
  • 也可以用DFS:深度就等于当前节点左/右子树的深度最大值+1。

代码

BFS：

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

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        # bfs, queue
        res, q = [], collections.deque()
        q.append(root)
        while q:
            tmp = []
            for _ in range(len(q)):
                out = q.popleft()
                tmp.append(out.val)
                if out.left: q.append(out.left)
                if out.right: q.append(out.right)
            res.append(tmp)
        return len(res)

DFS：

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

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0
        return max(self.maxDepth(root.left), self.maxDepth(root.right))+1

剑指 Offer 55 - II. 平衡二叉树

思路：

  • 可以用上面最大深度的function，先算出来左右子树的最大深度，再递归地判断当前是不是一个平衡二叉树。时间复杂度很高O(N*logn)
  • 剪枝

代码

简单算法：

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

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
    
        def get_depth(root):
            if not root: return 0
            return max(get_depth(root.left), get_depth(root.right))+1
        if not root: return True
        
        left_depth, right_depth= get_depth(root.left), get_depth(root.right)
        if abs(left_depth - right_depth) <= 1:
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        else: return False

剪枝算法：

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

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def recur(root):
            if not root: return 0
            left = recur(root.left)
            if left == -1: return -1
            right = recur(root.right)
            if right == -1: return -1
            if abs(left-right) >1 : return -1
            else : return max(left, right)+1
        return recur(root) != -1

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

思路：

  • 递归的方法解决：在以下三种情况下返回的是root值：
    1. p, q分别在root的两侧
    2. p是root
    3. q是root
  • 那么当p,q都在右侧时，递归右子树；vice versa。

代码：

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        p_val, q_val = p.val, q.val
        if not root: return 
        if (root.val-p_val)*(root.val-q_val) <= 0:
            return root
        elif p_val > root.val and q_val > root.val: 
            return self.lowestCommonAncestor(root.right, p, q)
        elif p_val < root.val and q_val < root.val: 
            return self.lowestCommonAncestor(root.left, p, q)

剑指 Offer 68 - II. 二叉树的最近公共祖先

思路：

  • 用inorder遍历，得到的list可以判断左右子树的关系。那么就可以跟上一题一样，进行迭代。

代码

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

class Solution:
    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
        if not root: return None
        in_list = []
        dic = {}
        def inorder(root):
            if not root: return 
            inorder(root.left)
            in_list.append(root.val)
            inorder(root.right)
        inorder(root)
        for i in range(len(in_list)):
            dic[in_list[i]] = i
        p_c, q_c = dic[p.val], dic[q.val]
        while root:
            root_c = dic[root.val]
            if (p_c - root_c)*(q_c - root_c) <= 0 : return root
            if p_c<root_c and q_c < root_c : root = root.left
            if p_c > root_c and q_c > root_c : root = root.right
牛客网在线编程专题《剑指offer-面试题25》二叉树中和为某一值的路径
Microstrong
08-30 389
我的个人微信公众号：Microstrong 微信公众号ID：MicrostrongAI 公众号介绍：Microstrong(小强)同学主要研究机器学习、深度学习、计算机视觉、智能对话系统相关内容，分享在学习过程中的读书笔记！期待您的关注，欢迎一起学习交流进步！ 知乎专栏：https://zhuanlan.zhihu.com/Microstrong Github：https://githu...
1024程序员节推荐书--《剑指Offer》专题突破版
宇宙之一粟的技术漂泊之旅
10-24 3509
《剑指Offer》书评 众所周知，在互联网招聘中，总少不了笔试这一环节。而说到笔试，肯定有一本书会被每一个童鞋提及——那就是《剑指Offer》，在更新了两版后，终于在2021年的夏天这本书也更新了——《剑指Offer》专题突破版。 第一时间拿到这本书后已经开始慢慢阅读起来了。刚好去年也在校招前买了之前的版本，说一下我拿到这本第一感受就是何海涛大佬更用心了。如书名的副标题——专项突破，专题大概可分为两大块：数据结构 + 算法。 可千万别觉得数据结构和算法就此分开了，其实算法的解题套路也是需要一个个数据结构中
剑指offer 树
qq_44717177的博客
06-01 188
11
leetcode剑指Offer 树(简单)
qq_43788026的博客
10-11 232
leetcode练习剑指 Offer 27. 二叉树的镜像剑指 Offer 28. 对称的二叉树剑指 Offer 32 - III. 从上到下打印二叉树 III 记录一些很简单，但做题时又没有立马做出来的一些题目。 剑指 Offer 27. 二叉树的镜像 题目 这道题用辅助栈或者辅助队列都是一样的效果。 public TreeNode mirrorTree(TreeNode root) { if(root == null) return null; Stack<TreeNode>
剑指Offer——树：把二叉树打印成多行（二叉树层序遍历）
HHHUOcairen的博客
07-13 355
对于二叉树的最好的解决办法就是递归。遍历方法无外乎先序遍历，中序遍历，后序遍历方法以及层序遍历方法。这里给大家安利一个关于树的面试题的链接，博主walkinginthewind比较全面且详细的介绍了二叉树相关的面试题：http://blog.youkuaiyun.com/walkinginthewind/article/details/7393134对于层序遍历，最好的方法就是用队列记录遍历节点的值，按层打印...
【LeetCode】剑指Offer
Arthur的博客
06-19 1014
LeetCode剑指Offer
jianzhi-offer:力扣上剑指优惠
03-27
"jianzhi-offer"是力扣上的一个专题，被称为“剑指优惠”，这个专题主要聚焦于Java编程语言，旨在帮助学习者深入理解和掌握Java的核心概念与技巧。 Java作为一款面向对象的编程语言，其特点包括平台无关性、安全性...
leetcode题库-leetcode:leetcode、剑指offer刷题集
06-29
《剑指Offer》是由名企面试官编写的一本经典面试指南，它包含了大量来自知名互联网公司的面试题，这些题目通常涵盖了LeetCode的部分内容。书中的每道题目都有详尽的解析和多种解题方法，适合准备面试的程序员阅读。 ...
剑指offer——树的镜像
Dashi_Lu的博客
04-11 277
题目描述：操作给定的二叉树，将其变换为源二叉树的镜像。 输入描述： 二叉树的镜像定义：源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ 11 9 7 5 ...
offer树的子结构
技术奇的默默积累
06-12 227
def HasSubtree(self,pRoot1,pRoot2): if pRoot2==None or pRoot1 ==None: return False def hasEqual(pRoot1,pRoot2): if pRoot2 ==None: return True if pRoot1 ==None: return False if pRoot1.val == .
剑指offer-树专题总结
weixin_46643875的博客
11-06 687
总结树相关的算法题： 1、广度优先（借助队列完成） 2、深度优先（通过递归的思路来完成）
剑指offer-树-树的子结构
Stefan的博客
06-01 282
题目 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 分析 总共应该分成三种情况： 1. AB树根相同，要求AB左右子树严格覆盖 2. AB树根不同，判断B是否存在于A的左子树中 3. B不在A的左子树中，判断B是否在A的右子树中 特殊情况： A树为空或B树为空 ⇒ return false; 进行子树覆盖判定时 ⇒ root2...
Louvain 算法
FionaDong的博客
12-12 202
Louvain 是一种经典的图社区发现算法（Community Detection），由 Blondel 等人在 2008 年提出。核心目标：通过最大化 Modularity（模块度）来自动划分图中的社区（cluster）。它最大的特点是：✔ 速度非常快✔ 能处理百万级节点的大图✔ 结果相对稳定。
智驾空间智能、物理智能、世界模型相关的最新论文和开源算法链接
最新发布
Bonaventure的博客
12-16 618
这些资源涵盖了2025年自动驾驶领域的前沿研究，从空间推理到物理建模和世界模拟，提供了丰富的开源工具和理论框架。建议用户通过链接深入探索论文和代码，以应用于实际项目或进一步研究。如果您需要更详细的解读或特定应用建议，请随时补充信息！
JVM 之 垃圾回收算法及其内部实现原理【垃圾回收的核心问题有哪些？分别怎么解决的？可达性分析解决了什么问题？回收算法有哪些？内部怎么实现的？】
人生快意事，读的好书，觅得良友
12-16 455
JVM垃圾回收面临的核心问题有哪些？分别怎么解决的？ 可达性分析解决了什么问题？回收算法有哪些？内部怎么实现的？ 根节点枚举、安全点、安全区域、记忆集与卡表、写屏障、并发性可达性分析各自解决了什么问题？怎么协同工作的？ G1中他们是怎么协作的？
从零开始写算法——链表篇4:删除链表的倒数第 N 个结点 + 两两交换链表中的节点
m0_59624833的博客
12-15 563
hot100链表的两道题详解。
八大排序之：冒泡排序、快速排序和堆排序
t2786024916的博客
12-16 421
冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。这个算法的名称由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端（升序排列）。
Leetcode算法专题解析与剑指offer回顾
通过LeetCode平台进行实战演练，并结合剑指offer中的面试题目进行深入分析，帮助读者更好地准备编程面试和提升编程能力。 知识点详细说明： 1. LeetCode平台： LeetCode是一个广泛的在线编程平台，提供各种难度的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值