算法练习（二叉树）

已于 2022-09-25 16:49:59 修改
阅读量1k 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： leetcode 算法 职场和发展
于 2022-09-06 11:50:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42352516/article/details/126722081
版权

描述
给你二叉树的根节点 root ，返回它节点值的 前、中、后序遍历。
数据范围：二叉树的节点数量满足 0≤n≤100 ，二叉树节点的值满足1≤val≤100 ，树的各节点的值各不相同

BM23 二叉树的前序遍历

示例1
输入：{1,#,2,3}
返回值：[1,2,3]


# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def preorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.perorder(tree_list, root)
        return tree_list
    
    def perorder(self, tree_list: List[int], root: TreeNode):
        if root is None:
            return 
        tree_list.append(root.val)
        self.perorder(tree_list, root.left)
        self.perorder(tree_list, root.right)

BM24 二叉树的中序遍历

示例1
输入：{1,2,#,#,3}
返回值：[2,3,1]
  
示例2
输入：{}
返回值：[]

示例3
输入：{1,2}
返回值：[2,1]
 
示例4
输入：{1,#,2}
返回值：[1,2]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
import sys
sys.setrecursionlimit(10000)
class Solution:
    def inorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.inorder(root, tree_list)
        return tree_list
    
    def inorder(self, root: TreeNode, tree_list:List[int]):
        if root is None:
            return
        
        self.inorder(root.left, tree_list)
        tree_list.append(root.val)
        self.inorder(root.right, tree_list)

BM25 二叉树的后序遍历

示例1
输入：{1,#,2,3}
返回值：[3,2,1]
  
示例2
输入：{1}
返回值：[1]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def postorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.postorder(tree_list, root)
        return tree_list
    
    def postorder(self, tree_list:List[int], root: TreeNode):
        if root is None:
            return
        
        self.postorder(tree_list, root.left)
        self.postorder(tree_list, root.right)
        tree_list.append(root.val)

BM26 求二叉树的层序遍历

描述
给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
例如：
给定的二叉树是{3,9,20,#,#,15,7},
该二叉树层序遍历的结果是
[
[3],
[9,20],
[15,7]
]
数据范围：二叉树的节点数满足 1≤n≤10^5

示例1
输入：{1,2}
返回值：[[1],[2]]

示例2
输入：{1,2,3,4,#,#,5}
返回值：[[1],[2,3],[4,5]]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型二维数组
#
import sys
sys.setrecursionlimit(100000)
class Solution:
    def levelOrder(self , root: TreeNode) -> List[List[int]]:
        # write code here
        leve_list = []
        i = 0
        self.level(i, leve_list, root)
        return leve_list
    
    def level(self, i, level_list:List[int], root: TreeNode):
        """通过树的层数和列表的索引来进行递归处理"""
        if root is None:
            return
        if len(level_list)-1 >= i:
            level_list[i].append(root.val)
        else:
            level_list.append([root.val])
        i += 1
        self.level(i, level_list, root.left)
        self.level(i, level_list, root.right)

BM27 按之字形顺序打印二叉树

描述
给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）
数据范围：0≤n≤1500,树上每个节点的val满足∣val∣<=1500
要求：空间复杂度：O(n)，时间复杂度：O(n)
例如：
给定的二叉树是{1,2,3,#,#,4,5}
该二叉树之字形层序遍历的结果是
[
[1],
[3,2],
[4,5]
]

示例1
输入：{1,2,3,#,#,4,5}
返回值：[[1],[3,2],[4,5]]
说明：如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。 
    
示例2
输入：{8,6,10,5,7,9,11}
返回值：[[8],[10,6],[5,7,9,11]]

示例3
输入：{1,2,3,4,5}
返回值：[[1],[3,2],[4,5]]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pRoot TreeNode类 
# @return int整型二维数组
#
import sys
sys.setrecursionlimit(100000)

class Solution:
    def Print(self , pRoot: TreeNode) -> List[List[int]]:
        # write code here
        i = 0
        l = []
        self.p(i, l, pRoot)
        return l
    
    def p(self, i, l:List[int], pRoot:TreeNode):
        
        if pRoot is None:
            return
        
        if i > len(l)-1:
            l.append([pRoot.val])
        elif i <= len(l)-1 and (i+1)%2 == 0:
#         elif (i+1)%2 == 0:
            l[i].insert(0, pRoot.val)
        else:
            l[i].append(pRoot.val)
        i += 1
        self.p(i, l, pRoot.left)
        self.p(i, l, pRoot.right)

BM28 二叉树的最大深度

描述
求给定二叉树的最大深度，
深度是指树的根节点到任一叶子节点路径上节点的数量。
最大深度是所有叶子节点的深度的最大值。
（注：叶子节点是指没有子节点的节点。）
数据范围：0≤n≤100000，树上每个节点的val满足 ∣val∣≤100
要求： 时间复杂度 O(n)

示例1
输入：{1,2}
返回值：2

示例2
输入：{1,2,3,4,#,#,5}
返回值：3

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型
#
class Solution:
    def maxDepth(self , root: TreeNode) -> int:
        # write code here
        l = []
        i = 0
        self.max_d(i, l, root)
        return len(l)
    
    def max_d(self, i, l:List[int], root: TreeNode):
        
        if root is None:
            return 
        if i > len(l)-1:
            l.append([root.val])
        else:
            l[i].append(root.val)
        i += 1
        self.max_d(i, l, root.left)
        self.max_d(i, l, root.right)

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

描述
给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
例如：
给出如下的二叉树，sum=22，在这里插入图片描述
返回true，因为存在一条路径 25→4→11→2的节点值之和为 22
数据范围：
1.树上的节点数满足100000≤n≤10000
2.每 个节点的值都满足∣val∣≤1000
要求：空间复杂度 O(n)，时间复杂度 O(n)
进阶：空间复杂度 O(树的高度)，时间复杂度 O(n)

示例1
输入：{5,4,8,1,11,#,9,#,#,2,7},22
返回值：true

示例2
输入：{1,2},0
返回值：false

示例3
输入：{1,2},3
返回值：true

示例4
输入：{},0
返回值：false

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @param sum int整型 
# @return bool布尔型
#
class Solution:
    def hasPathSum(self , root: TreeNode, summer: int) -> bool:
        # write code here
        if root is None:
            return False
        
        if root.left is None and root.right is None and root.val == summer:
            return True
        return self.hasPathSum(root.left, summer-root.val) or self.hasPathSum(root.right,summer-root.val)

BM30 二叉搜索树与双向链表

描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。如下图所示
在这里插入图片描述

数据范围：输入二叉树的节点数 10000≤n≤1000，二叉树中每个节点的值 10000≤val≤1000
要求：空间复杂度O(1)（即在原树上操作），时间复杂度 O(n)
注意:
1.要求不能创建任何新的结点，只能调整树中结点指针的指向。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继
2.返回链表中的第一个节点的指针
3.函数返回的TreeNode，有左右指针，其实可以看成一个双向链表的数据结构
4.你不用输出双向链表，程序会根据你的返回值自动打印输出
输入描述：
二叉树的根节点
返回值描述：
双向链表的其中一个头节点。

示例1
输入：{10,6,14,4,8,12,16}
返回值：From left to right are:4,6,8,10,12,14,16;From right to left are:16,14,12,10,8,6,4;
说明：输入题面图中二叉树，输出的时候将双向链表的头节点返回即可。
    
示例2
输入：{5,4,#,3,#,2,#,1}
返回值：From left to right are:1,2,3,4,5;From right to left are:5,4,3,2,1;
说明：
                    5
                  /
                4
              /
            3
          /
        2
      /
    1
树的形状如上图       

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

#
# 
# @param pRootOfTree TreeNode类 
# @return TreeNode类
#
class Solution:
    head= None
    pre = None
    def Convert(self , pRootOfTree: TreeNode):
        # write code here
        if pRootOfTree is None:
            return
        self.Convert(pRootOfTree.left)
        if self.pre is None:
            self.head = pRootOfTree
            self.pre = pRootOfTree
        else:
            self.pre.right = pRootOfTree
            pRootOfTree.left = self.pre
            self.pre = pRootOfTree
        self.Convert(pRootOfTree.right)
        return self.head

BM31 对称的二叉树

描述
给定一棵二叉树，判断其是否是自身的镜像（即：是否对称）
例如： 下面这棵二叉树是对称的
在这里插入图片描述
下面这棵二叉树不对称。
在这里插入图片描述
数据范围：节点数满足 10000≤n≤1000，节点上的值满足1000∣val∣≤1000
要求：空间复杂度 O(n)，时间复杂度 O(n)
备注：
你可以用递归和迭代两种方法解决这个问题

示例1
输入：{1,2,2,3,4,4,3}
返回值：true

示例2
输入：
{8,6,9,5,7,7,5}
返回值：false

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param pRoot TreeNode类
# @return bool布尔型
#
class Solution:
    def isSymmetrical(self, pRoot: TreeNode) -> bool:
        # write code here
        # 方式一
        left_list = []
        right_list = []
        self.is_left(pRoot, left_list)
        self.is_right(pRoot, right_list)
        print(left_list)
        print(right_list)
        if left_list == right_list:
            return True
        return False

       # 方式二
        return self.recursion(pRoot, pRoot)

    def recursion(self, root1: TreeNode, root2: TreeNode):
        if not root1 and not root2:
            return True

        if not root1 or not root2 or root1.val != root2.val:
            return False

        return self.recursion(root1.left, root2.right) and self.recursion(root1.right, root2.left)
        

    def is_right(self, pRoot: TreeNode, right_list):
        if pRoot is None:
            right_list.append(0)
            return
        right_list.append(pRoot.val)
        self.is_right(pRoot.right, right_list)
        self.is_right(pRoot.left, right_list)

    def is_left(self, pRoot: TreeNode, left_list):
        if pRoot is None:
            left_list.append(0)
            return
        left_list.append(pRoot.val)
        self.is_left(pRoot.left, left_list)
        self.is_left(pRoot.right, left_list)

BM32 合并二叉树

描述
已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替。例如：
两颗二叉树是:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

数据范围：树上节点数量满足 0 \le n \le 5000≤n≤500，树上节点的值一定在32位整型范围内。
进阶：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n)

示例1
输入：{1,3,2,5},{2,1,3,#,4,#,7}
返回值：{3,4,5,5,4,#,7}
说明：如题面图 

示例2
输入：{1},{}
返回值：{1}

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param t1 TreeNode类
# @param t2 TreeNode类
# @return TreeNode类
#
class Solution:
    def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        # write code here
        if t1 is None:
            t1 = t2
            return t1
        if t2 is None:
            return t1
        t1.val = t1.val + t2.val

        t1.left = self.mergeTrees(t1.left, t2.left)
        t1.right = self.mergeTrees(t1.right, t2.right)

        return t1

BM33 二叉树的镜像

描述
操作给定的二叉树，将其变换为源二叉树的镜像。
数据范围：二叉树的节点数 10000≤n≤1000 ， 二叉树每个节点的值 10000≤val≤1000
要求： 空间复杂度 O(n) 。本题也有原地操作，即空间复杂度 O(1)的解法，时间复杂度 O(n)

比如： 源二叉树

在这里插入图片描述

镜像二叉树
在这里插入图片描述

示例1
输入：{8,6,10,5,7,9,11}
返回值：{8,10,6,11,9,7,5}
说明：如题面所示
    
示例2
输入：{}
返回值：{}

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pRoot TreeNode类 
# @return TreeNode类
#
class Solution:
    def Mirror(self , pRoot: TreeNode) -> TreeNode:
        # write code here
        if pRoot is None:
            return pRoot
        
        head = TreeNode(pRoot.val)

        head.left = self.Mirror(pRoot.right)
        head.right = self.Mirror(pRoot.left)
        
        return head

BM34 判断是不是二叉搜索树

描述
给定一个二叉树根节点，请你判断这棵树是不是二叉搜索树。
二叉搜索树满足每个节点的左子树上的所有节点均小于当前节点且右子树上的所有节点均大于当前节点。

例：在这里插入图片描述
图1
在这里插入图片描述
图2

数据范围：节点数量满足 1≤n≤10 ^4 ， 节点上的值满足 -2^31 ≤ val ≤ 2^31 - 1

示例1
输入：{1,2,3}
返回值：false
说明：如题面图1 

示例2
输入：{2,1,3}
返回值：true
说明：如题面图2 

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param root TreeNode类
# @return bool布尔型
#
import sys
class Solution:

    pre = -sys.maxsize - 1

    def isValidBST(self, root: TreeNode) -> bool:
        # write code here
        if root is None:
            return True

        root_val = root.val
        if not self.isValidBST(root.left):
            return False
        if root_val <= self.pre:
            return False
        self.pre = root_val
        if not self.isValidBST(root.right):
            return False
        return True
小小菜_v
关注
专栏目录
二叉树遍历算法
u011764940的博客
01-17 3441
栈 注： 1，三种遍历都是先把二叉树的最左结点循环入栈，以帮助找到返回处理的节点。 每个子树也是先把该右子树中的最左节点循环入栈，以帮助找到返回处理的节点。 先序遍历和中序遍历都是通过一个子树的最右下叶节点的right带出接下来的处理结点，表明该子树的左子树已经遍历处理完毕。因为不管先序遍历还是中序遍历，一颗子树的结束点是在该子树的最右下叶节点。 2，先序和中序代...
【算法练习】数据结构二叉树 百练poj2255:重建二叉树
一蓑烟雨任平生
08-29 313
http://bailian.openjudge.cn/practice/2255 2255:重建二叉树 总时间限制: 1000ms 内存限制: 65536kB 描述 给定一棵二叉树的前序遍历和中序遍历的结果，求其后序遍历。 输入 输入可能有多组，以EOF结束。 每组输入包含两个字符串，分别为树的前序遍历和中序遍历。每个字符串中只包含大写字母且互不重复。 输出 对于...
算法练习 二叉树的中序遍历
zzb_10000hkjh的博客
03-22 128
题目 给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 输出: [1,3,2] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 ...
二叉树算法练习
qiu_soft的博客
06-24 196
二叉树算法练习 判断二叉树是否为平衡树 解题思路：计算每个节点的高度，null为-1，那么，叶子节点为0；判断左右两个子树的高度差是否大于1，若是，将结果置为false，否则继续递归depth方法。 时间复杂度O(n), 空间复杂度O(1). public class Solution { private boolean isBalanced = true; //判断二叉树...
【算法】二叉树遍历
代码星辰的博客
01-17 868
本文介绍了二叉树遍历的常用几种方式：前序遍历、中序遍历、后序遍历以及层序遍历。
二叉树算法题
2303_81098358的博客
08-30 1912
后，我们了解了二叉树的相关概念和性质，并且实现了顺序结构二叉树——堆和链式结构二叉树，那么在本篇中我们就来试着解决一些二叉树相关的算法题，相信通过这些练习之后你会对二叉树有更深的理解。在之前二叉树的相关章节（
【算法练习】leetcode算法题合集之二叉树篇
秋装什么的博客
01-08 1116
【算法练习】leetcode算法题合集之二叉树篇
算法练习-二叉树（一）
jx的博客
03-19 690
算法练习-二叉树（一）
今日代码练习 二叉树的遍历算法
sasa_studying的博客
04-29 91
算法套路七——二叉树递归
Pistachiout的学习博客
04-06 1456
该题与上题一样，递归思想基本一样，也是使用全局变量进行解决，不过该题在代码书写上值得注意，在go语言中只有值传递，当slice做为参数传递给函数的时候，新建了切片s，只是原始切片slice和参数s切片的底层数组是一样的，与Java不同，在Java中需要使用Lsit进行修改，且在函数结束前需要删除List的最后一个元素。给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
算法练习集合,涵盖链表算法、数组算法、二叉树算法、动态规划、贪心算法、回溯算法.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
[C++算法入门]-二叉树打印练习题
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者熟悉二叉树的打印操作和相关算法。文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和...
数据结构与算法-二叉树的创建与操作
04-21
在IT领域，数据结构与算法是编程基础的重要组成部分，尤其对于C++开发者来说更是如此。本主题聚焦于“二叉树的创建与操作”，这是一种特殊的数据结构，它...通过实践和不断练习，你将能更好地运用二叉树解决实际问题。
Java 算法设计-递归二叉树的序列打印练习题
10-09
二叉树
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 456
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 517
64. 最小路径和。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 670
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode 692.前K个高频单词
m0_63816268的博客
09-13 366
首先用map存储该字典，然后放进vector进行排序，注意sort的排序规则与我们想要的规则不一致，所以我们需要写一个伪函数来判断second(value值)，由于该题要求了稳定性，所以我们在伪函数还需要继续判断相等情况的顺序。排完序后用vector将前k个单词存储起来返回。
Leetcode Hot 100刷题记录 -Day16（旋转图像）
weixin_45864705的博客
09-14 264
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。请你将图像顺时针旋转 90 度。
二叉树算法练习3
05-30
好的，我来为你讲解一下二叉树算法练习3。 题目描述： 给定一个二叉树，找出其最大深度。 示例： 输入：[3,9,20,null,null,15,7] 输出：3 解释：该二叉树的深度为3。 解题思路： 二叉树最大深度的求解可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值