LeetCode刷题11--部分二叉树问题汇总

最新推荐文章于 2024-05-20 18:16:07 发布
最新推荐文章于 2024-05-20 18:16:07 发布
阅读量187 收藏
点赞数
分类专栏： LeetCode 文章标签： 二叉树 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40361809/article/details/113396692
版权

LeetCode刷题笔记11

部分二叉树问题汇总

144. 二叉树的前序遍历

链接

题目描述

给你二叉树的根节点 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 preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root==None:
            return None
        list_1=[root.val]
        if root.left!=None:
            list_1+=self.preorderTraversal(root.left)
        if root.right!=None:
            list_1+=self.preorderTraversal(root.right)
        return list_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 preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        p = root
        stack = []
        while p or stack:
            while p:
                res.append(p.val)
                stack.append(p)
                p = p.left
            p = stack.pop().right
        return res

94. 二叉树的中序遍历

链接

代码

递归方式

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root==None:
            return root
        if root.left==None and root.right==None:
            return [root.val]
        res=[]
        if root.left!=None:
            res=res+self.inorderTraversal(root.left)
        res.append(root.val)
        if root.right!=None:
            res=res+self.inorderTraversal(root.right)
        return 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root==None:
            return root
        if root.left==None and root.right==None:
            return [root.val]
        res = []
        stack = []
        p = root
        while p or stack:
            while p:
                stack.append(p)
                p = p.left
           
            p = stack.pop()
            res.append(p.val)
            p = p.right
        return res

145. 二叉树的后序遍历

链接

代码

# 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root==None:
            return None
        list_1=[]
        if root.left!=None:
            list_1+=self.postorderTraversal(root.left)
        if root.right!= None:
            list_1+=self.postorderTraversal(root.right)
        list_1.append(root.val)
        return list_1

102. 二叉树的层序遍历

链接

题目描述

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

代码

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        #q=[root]
        if root==None:
            return [[]]
        q=[root]
        res=[[root.val]]
        while(len(q)):
            tmp_q=[]
            tmp_res=[]
            for node in q:
                if node.left!=None:
                    tmp_q.append(node.left)
                    tmp_res.append(node.left.val)
                if node.right!=None:
                    tmp_q.append(node.right)
                    tmp_res.append(node.right.val)
            q=tmp_q
            if len(tmp_res)>0:
                res.append(tmp_res)
        return res

226. 翻转二叉树

链接

题目描述

翻转一棵二叉树。

思路：递归

代码

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

951. 翻转等价二叉树

链接

题目描述

我们可以为二叉树 T 定义一个翻转操作，如下所示：选择任意节点，然后交换它的左子树和右子树。

只要经过一定次数的翻转操作后，能使 X 等于 Y，我们就称二叉树 X 翻转等价于二叉树 Y。

编写一个判断两个二叉树是否是翻转等价的函数。这些树由根节点 root1 和 root2 给出。

思路：

层序遍历，如果root1.leftroot2.left and root1.rightroot2.right,直接接入下一层。如果 root1.leftroot2.right and root1.rightroot2.left，将左右交换然后进入下一层

代码

# 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 flipEquiv(self, root1, root2):
        """
        :type root1: TreeNode
        :type root2: TreeNode
        :rtype: bool
        """
        if root1==None and root2==None:
            return True
        if root1==None or root2==None:
            return False
        if root1.val!=root2.val:
            return False
        tmp_1=[root1]
        tmp_2=[root2]
        while(tmp_1 and tmp_2):
            p1=tmp_1.pop()
            p2=tmp_2.pop()
            l1=-1
            l2=-1
            r1=-1
            r2=-1
            if (p1==None or p2==None): continue
            if p1.left!=None:
                l1=p1.left.val
            if p1.right!=None:
                r1=p1.right.val
            if p2.left!=None:
                l2=p2.left.val
            if p2.right!=None:
                r2=p2.right.val
            if l1==l2 and r1==r2:
                
                tmp_1.append(p1.left)
                tmp_1.append(p1.right)
                tmp_2.append(p2.left)
                tmp_2.append(p2.right)
            elif l1==r2 and r1==l2:
                tmp_1.append(p1.left)
                tmp_1.append(p1.right)
                tmp_2.append(p2.right)
                tmp_2.append(p2.left)
            else:
                return False
        
        return True

101. 对称二叉树

链接

题目描述

给定一个二叉树，检查它是否是镜像对称的。

思路：递归

代码

python

# 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 root==None:
            return True
        if root.left==None and root.right==None:
            return True
        def helper(left,right):
            if left==None and right==None:
                return True
            if left==None or right==None:
                return False
            if left.val!=right.val:
                return False
            return helper(left.left,right.right) and helper(left.right,right.left)

        return helper(root.left,root.right)

c++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool helper(TreeNode* left,TreeNode* right){
        if (left==NULL && right==NULL) return true;
        if (left==NULL || right==NULL) return false;
        if (left->val!=right->val) return false;
        return helper(left->left,right->right) && helper(left->right,right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if (root==NULL) return true;
        return helper(root->left,root->right);

    }
};

java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean helper(TreeNode left,TreeNode right){
        if (left==null && right==null) return true;
        if (left==null || right==null) return false;
        if (left.val!=right.val) return false;
        return helper(left.left,right.right) && helper(left.right,right.left);
    }
    public boolean isSymmetric(TreeNode root) {
        if (root==null) return true;
        return helper(root.left,root.right);

    }
}

非递归法

# 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 root==None:
            return True
        if root.left==None and root.right==None:
            return True
        if root.left==None or root.right==None:
            return False
        left=[root.left]
        right=[root.right]
        while(len(left) and len(right)):
            l=left.pop(0)
            r=right.pop(0)
            
            if l.val!=r.val:
                return False
            if l.left and r.right:
                left.append(l.left)
                right.append(r.right)
            elif l.left or r.right:
                    return False
            if l.right and r.left:
                
                left.append(l.right)
                right.append(r.left)
            elif l.right or r.left:
                    return False
           
        if len(left)==0 and len(right)==0:
            return True
        else:
            return False

669. 修剪二叉搜索树

链接

题目描述

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树不应该改变保留在树中的元素的相对结构（即，如果没有被移除，原有的父代子代关系都应当保留）。 可以证明，存在唯一的答案。

所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

思路：

根据二叉搜索树的性质，如果root.val不在范围内，根据小于low还是大于high来判断保留左子树还是右子树。然后递归

代码

# 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 trimBST(self, root, low, high):
        """
        :type root: TreeNode
        :type low: int
        :type high: int
        :rtype: TreeNode
        """
        if root==None:
            return root
        if root.left==None and root.right==None:
            if root.val<=high and root.val>=low:
                return root
            else:
                return None
        if root.val<=high and root.val>=low:
            root.left=self.trimBST(root.left,low,high)
            root.right=self.trimBST(root.right,low,high)
        elif root.val<low:
            root=self.trimBST(root.right,low,high)
        elif root.val>high:
            root=self.trimBST(root.left,low,high)
        return root
qq_40361809
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
leetcode刷题账号 LeetCode LeetCode刷题记录(C#) 我的LeetCode账号地址：
JAVA小白leetcode刷题顺序--offer:-提供
07-06
JAVA小白leetcode刷题顺序 本人也是java小白一个，刷题剑指offer也是开始第三遍，准备记录一下每道题的一些通用解法，可能不是最优的，但一定是最容易理解和接受的~ 小白选取的《剑指offer》是LeetCode上面的剑指...
Leetcode中二叉树问题汇总（一）
wolvvi的博客
08-29 1307
最近陆陆续续在刷树结构这类的问题，非线性结构的问题一直是软肋，尤其是这类问题大量使用递归，对于我这种混了好几年的小白来说不容易理解，因此针对Leetcode中树这一类问题进行了下总结，温故而知新嘛（之前学的都还给老师了…），同时也希望各位大神批评指正。 篇幅有限，本文先写二叉树的一些基本操作。 二叉树的概念 二叉树的基本概念具体可以参考：度娘带你走进二叉树 抽取其中主要的做个简单的介绍...
LeetCode 二叉树问题总结
weixin_38170137的博客
08-17 382
导言： LeetCode 上面的二叉树问题一般可以看成是简单的深度优先搜索问题，一般的实现方式是使用递归，也会有非递归的实现方法，这边文章主要介绍一下解决二叉树问题的几个常规方法和思路，然后会给一个从递归转换到非递归的小技巧 两个通用方法和思路 拿到一道二叉树的问题，多半是需要你遍历这个树，只不过是在遍历的过程中，不同的题目要求你做的计算不一样。这里有两个遍历方法，自顶向下的递归遍历，以及自...
LeetCode二叉树问题全解--Python版(一)
小道的博客
07-27 558
LeetCode二叉树问题全解–Python版 二叉树是由若干个节点组成，节点连接起来就成了二叉树，而节点由一个值、指向左右的两个指针组成 创建树实际上就是创建节点，然后连接节点 节点的数据类型 每个节点都有值和左右孩子，如果没有则写None。Python代码如下 class TreeNode(): def __init__(self, value): self.val = value self.left = None self.right = No
LeetCode题目——二叉树篇
Pcl2001的博客
03-07 1505
LeetCode题目——二叉树篇前言一、二叉树的前、中、后序遍历1.前序遍历递归实现迭代法2.中序遍历递归迭代法3.后序遍历递归迭代二、二叉树的层次遍历三、二叉树的右视图四、二叉树的层平均值五、N叉树的层序遍历六、在每个树行中找最大值七、填充每个节点的下一个右侧节点指针（完全二叉树）八、填充每个节点的下一个右侧节点指针（普通二叉树）九、完全二叉树的节点个数![在这里插入图片描述](https://img-blog.csdnimg.cn/4ecfb9528fd44f388c1126f89885dd36.png
leetcode 二叉树题目总结
qq_41202486的博客
09-08 443
leetcode 二叉树题目总结一.基本问题遍历前序遍历后序遍历中序遍历莫里斯遍历：空间复杂度O(1)层次遍历由序列构造二叉树递归解决二叉树问题：将二叉树转换为其他结构 二叉树结构： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left
C++leetcode刷题c-c-master.zip
03-18
C++leetcode刷题c-c-master.zip
Leetcode刷题笔记-堆
08-19
Leetcode刷题笔记—堆相关题型，刷透一道题顶10盲刷10道题，还在苦苦纠结于打开力扣直奔题解的苦恼吗? 赶快来看一看吧
LeetCode刷题题解-Java版本
05-18
力扣解题java版本
leetcode——二叉树问题
右手点天下
03-19 121
重建二叉树 第k小元素 公共祖先
leetcode算法常见解题思路--二叉树篇
chenjixue的博客
12-17 444
1.填充二叉树节点的右侧指针 二叉树的问题难点在于，如何把题目的要求细化成每个节点需要做的事情，但是如果只依赖一个节点的话，肯定是没办法连接「跨父节点」的两个相邻节点的，那么，我们的做法就是增加函数参数，一个节点做不到，我们就给他安排两个节点，「将每一层二叉树节点连接起来」可以细化成「将每两个相邻节点都连接起来]。 //主函数 Nodeconnect(Noderoot){ if(root==null)returnnull; connectTwoNode(root....
leetcode解题二叉树篇
weixin_45774350的博客
03-27 1606
八、 二叉树 二叉树的种类 在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。 满二叉树 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 如图所示： 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 完全二叉树 什么是完全二叉树？ 完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~
洛谷P3369 普通平衡树题解(非旋Treap)题解
Exploration
11-28 1071
P3369普通平衡树题解(非旋Treap) 题意 您需要写一种数据结构，来维护一些数，其中需要提供以下操作： case 1: 插入xxx数 case 2: 删除xxx数(若有多个相同的数，因只删除一个) case 3: 查询xxx数的排名(排名定义为比当前数小的数的个数+1+1+1) case 4: 查询排名为xxx的数 case 5: 求xxx的前驱(前驱定义为小于xxx,且最大的数) case...
leetcode中的二叉树经典问题(一）
懵逼女青年
01-22 577
每一个类型的数据结构题目一般都有该数据结构特征所带来的解决秘诀。对于二叉树来说，最大的宝典莫过于递归。下面来看看leetcode二叉树中的经典问题。 二叉树的前中后序遍历（递归方式以及非递归方式） leetcode144前序遍历 https://leetcode.com/problems/binary-tree-preorder-traversal/ leetcode94 中序遍历 https...
leetcode中的二叉树经典问题（二）
懵逼女青年
01-28 349
每一个类型的数据结构题目一般都有该数据结构特征所带来的解决秘诀。对于二叉树来说，最大的宝典莫过于递归。 前面已经探讨了二叉树前中后三种遍历的递归和非递归方式。具体请看leetcode中的二叉树经典问题(一）。今天来说说二叉树的其他经典问题。 leetcode110判断一棵树是否为平衡二叉树https://leetcode.com/problems/balanced-binary-tree/ l...
【BZOJ - 3224】普通平衡树（Splay模板题）
xuanweiace的博客
07-26 297
题干： 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个) 3. 查询x数的排名(若有多个相同的数，因输出最小的排名) 4. 查询排名为x的数 5. 求x的前驱(前驱定义为小于x，且最大的数) 6. 求x的后继(后继定义为大于x，且最小的数) Input 第一行为n，表示操作的个数,下面n行每行有两个...
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
最新发布
未来就在脚下。
05-20 496
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 856
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
leetcode刷题目录
07-12
以下是一些常见的LeetCode刷题目录： 1. 数组： - 两数之和 - 盛最多水的容器 - 移动零 - 三数之和 - 合并两个有序数组 2. 字符串： - 反转字符串 - 反转字符串中的单词 - 验证回文串 - 最长回文子串 - ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值