leetcode—树

最新推荐文章于 2024-05-21 20:32:24 发布
最新推荐文章于 2024-05-21 20:32:24 发布
阅读量3.6k 收藏
点赞数
分类专栏： 学习记录 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myles_/article/details/121100449
版权

简单

翻转二叉树

leetcode直达

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if(!root) return 0;
        TreeNode* tmp;
        tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

成绩：100 85.17
思路：
一开始想着是不是把数值swap一下就好了。然后看到左子树整棵变成右子树了，那八成是换结构了。那就DFS基本框架加换左右子树结构即可。

二叉搜索树的最近公共祖先

leetcode直达

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        int low = min(p->val,q->val);
        int up = max(p->val,q->val);
        if(low<=root->val && up>=root->val) return root;
        else if(up<root->val) return lowestCommonAncestor(root->left,p,q);
        else return lowestCommonAncestor(root->right,p,q);
    }
};

成绩：72.62 44.54
思路：
要利用好二叉搜索树“左子节点小于根节点，右子节点大于根节点”这一特性。
当指定节点数值相较于当前节点数值一大一小时，说明两者分别在当前节点的左右子树，那么当前节点即为最近公共祖先；
如果两个指定节点数值均比当前节点数值小，说明均在左子树，就向左子树递归；
反之则向右子树递归。

二叉树的所有路径

/**
 * 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:
    void print(TreeNode* root,vector<int>& path,vector<string>& res){
        path.push_back(root->val);
        //如果是叶子节点，将路径格式化输出
        if(root->left==nullptr && root->right==nullptr){
            int i = 0;
            string s = "";
            for(i;i<path.size()-1;i++){
                s = s+to_string(path[i]);
                s += "->";
            }
            s = s+to_string(path[i]);
            res.push_back(s);
        }
        //若不是，递归
        if(root->left){
            print(root->left,path,res);
            path.pop_back();
        }
        if(root->right){
            print(root->right,path,res);
            path.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        vector<int> path;
        print(root,path,res);
        return res;
    }
};

成绩：74.22 68.24
思路：
这题最关键的是回溯，真正意义上的回溯，包括怎么回溯，什么时候回溯。
可以看看carl的题解，写的确实不错。
其实这里面的有一个点我感觉不能直接按照回溯去理解。就是
这个回溯就要很大的问题，我们知道，回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话相当于把递归和回溯拆开了， 一个在花括号里，一个在花括号外。

所以回溯要和递归永远在一起，世界上最遥远的距离是你在花括号里，而我在花括号外！

那么代码应该这么写：

if (cur->left) {
    traversal(cur->left, path, result);
    path.pop_back(); // 回溯 
    }
if (cur->right) {
    traversal(cur->right, path, result);
    path.pop_back(); // 回溯 
    }

这里直接把pop_back()的操作，即回溯是需要做的删除子节点这一操作写成是回溯，但其实回溯是由

if(递归终止条件){
	递归终止逻辑
}

来形成的。对于懂的人当然无伤大雅，但写清楚终究是好事。

左叶子之和

/**
 * 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:

    void cumulation(TreeNode* root,int& sum){
        if(root->left == nullptr && root->right == nullptr){
            return;
        }
        if(root->left){
            if(root->left->left == nullptr && root->left->right == nullptr) sum+=root->left->val;
            cumulation(root->left,sum);
        }
        if(root->right){
            cumulation(root->right,sum);
        }
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        cumulation(root,sum);
        return sum;
    }
};

成绩：25.43 93.68
思路：
DFS的框架是简单的，最重要的是找出左叶子节点。当然叶子节点自己是不知道自己是左叶子还是右叶子，要靠父节点来判断。当root有左子树时，就要判断左子树是不是叶子节点。如果是就计入sum。如果不是就继续往左子树遍历。
但是这个代码肯定是可以优化的，隐隐感觉可以更快回溯，明天再想想。可不可以记录当前节点root，若下一节点root->child是叶子节点，则看看root->child是不是root的左孩子，若是则加。感觉这样比较靠谱。

二叉搜索树中的众数

/**
 * 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 judge(int val,unordered_map<int,int>& hash){
        if(hash.find(val) == hash.end()) return false;
        return true;
    }
    void DFS(TreeNode* root, unordered_map<int,int>& hash){
        if(!root) return;
        if(judge(root->val,hash)) {
            //就是非新节点值，键值加一
            hash[root->val] += 1;
        }
        //若为新节点，则加入hash
        else hash.emplace(root->val,1);
        DFS(root->left,hash);
        DFS(root->right,hash);
    }
    vector<int> findMode(TreeNode* root) {
        unordered_map<int,int> hash;
        DFS(root,hash);
        auto it = hash.begin();
        vector<int> maxkey;
        int max = 0;
        for(it;it!=hash.end();it++){
            if(it->second>max) {
                maxkey.clear();
                max = it->second;
                maxkey.push_back(it->first);
            }
            else if(it->second == max){
                maxkey.push_back(it->first);
            }
        }
        return maxkey;
    }
};

分数：15.48 5.08
思路：
一目了然了就是，利用hash进行存储，利用DFS遍历二叉搜索树，最后根据每一个节点的次数输出最多出现的节点值。
这个方法确实是很慢，从代码里也可以看出。但是好歹是做出来了。

二叉树的直径

/**
 * 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:
    int DFS(TreeNode* root,int& res){
        if(!root) return 0;
        int l = DFS(root->left,res);
        int r = DFS(root->right,res);
        res = max(res,l+r);   //记录以所有节点为根节点的直径。这一步很重要
        return max(l,r)+1;

    }
    int diameterOfBinaryTree(TreeNode* root) {
        int res = 0;
        DFS(root,res);
        return res;
    }
};

成绩：76.26 96.70
思路：
一开始我想的就是左子树深度加上右子树深度，也就是说我认为这条最长的路径一定是经过根节点的。但是提交之后发现在第100个检测样例卡住了，一画才发现是有可能不过根节点的。
那既然有可能是不过根节点的，怎么样才能找到最长路径中的那一个“根节点”呢？最后发现，还是逃不掉遍历所有节点。只要找到这条路径上的这一个“根节点”，那么二叉树直径就是以该节点为根节点的左右子树深度和。
那么如何取实现这一步，就是看我们对树的DFS的掌握程度了。我们什么时候才能得到某个节点的左子树深度与右子树深度呢？是当回溯到该节点时才能得到两者，注意是回溯。也就是说已经结束了DFS(left)和DFS(right)，但该节点还没有往回回溯的时候。所以我们首先创建一个全局变量res(我不喜欢全局变量所以给了一个引用回去，都一样)，在每一次左右子树遍历完回溯到“根节点”时，取当前节点的左右子树深度和l+r（也就是以该节点为根节点的直径）与res较大者。最后主函数输出res，即为当前树的直径。

找树左下角的值

思路

DFS+深度判断

其实不用管什么左下角，只要满足两个条件，当前节点就是我们需要的节点：

1、最底层

2、最左边

那么如何实现这两个条件的判断，我们就需要一个depth变量来记录当前深度，若当前节点非叶子节点，则继续向左右子节点遍历；若当前节点为子节点，则判断当前深度变量depth是否大于最大深度变量maxdepth，若前者较大，说明当前节点处于最底层且为最左边的节点（因为是第一次遍历到，否则就应该是depth == maxdepth）

代码

/**
 * 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:
    void DFS(TreeNode* root,int& depth, int& maxdepth, int& res){
        depth += 1;
        if(root->left == nullptr && root->right == nullptr){
            if(depth > maxdepth){
                res = root->val;
                maxdepth = depth;
            }
        }
        if(root->left){
            DFS(root->left,depth,maxdepth,res);
            depth -= 1;
        }
        if(root->right){
            DFS(root->right,depth,maxdepth,res);
            depth -= 1;
        }
    }
    int findBottomLeftValue(TreeNode* root) {
         int depth = 0;
         int maxdepth = 0;
         int res = 0;
         DFS(root,depth,maxdepth,res);
         return res;
    }
};

复杂度分析

时间复杂度：O(n) n为节点个数

空间复杂度：O(h) h为最大深度

求根到叶子节点数字之和

这题和二叉树的所有路径其实是一模一样的，两题可以一起做。

思路

其实就是遍历所有路劲，无非就是设置一个数记录往下遍历和回溯后路径上数的变化。

代码

/**
 * 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:
    void DFS(TreeNode* root,int& sum, int &cur){
        cur = cur*10+root->val;
        if(root->left == nullptr && root->right == nullptr) sum += cur;
        if(root->left){
            DFS(root->left,sum,cur);
            cur = cur/10;
        }
        if(root->right){
            DFS(root->right,sum,cur);
            cur = cur/10;
        }
    }
    int sumNumbers(TreeNode* root) {
        int sum = 0;
        int cur = 0;
        DFS(root,sum,cur);
        return sum;
    }
};

复杂度分析

时间复杂度：O(n) n为节点个数

空间复杂度：O(h) h为树的深度，其实就是递归栈

myles_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode2-treevis:Treevis是一个用来绘制LeetCode树的小工具。调试可视化测试用例很有用
06-29
leetcode 2 树视 Treevis 是一个用来绘制 LeetCode 树的小工具。 调试可视化测试用例很有用。 如何使用 如果您想全局安装它以便将其添加到您的$PATH您可以使用 $ npm install -g treevis # or $ yarn global add ...
leetcode思维导图-树
08-13
leetcode思维导图-树
leetcode树之二叉树的创建
溪语流沙的博客
03-21 1122
前言 前面介绍了二叉树的遍历，这次我们来考虑一下二叉树的创建，给定前中后序遍历的结果，这个时候要还原成二叉树应该怎么做呢？ 下面来通过几道题来实际感受一下吧！ 105、从前序和中序序列构建二叉树 给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。 示例1： 输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] 输出: [3,9,20,n
Leetcode树专题
Myblog
08-19 102
Leetcode098（验证二叉搜索树）-------中序遍历 地址： https://leetcode-cn.com/problems/validate-binary-search-tree/ 描述： 代码： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(
leetcode 树总结
qq_40206060的博客
01-08 114
leetcode 树总结 所遇见的树的题目差不多可以归为一下几类：前中后序遍历，dfs，bfs，层次遍历，二叉搜索树。 碰到一个比较有意思的思想是，leetcod的一个题解中将数的前中后序遍历与dfs关联： 1161. 最大层内元素和. ...
004 leetcode树总结
Mirevas的博客
12-04 1105
一、树的相关概念 高度与深度 节点的深度是指从根节点（深度为1）开始自顶向下逐层累加至该节点时的深度值 节点的高度是指从最底层叶子节点（高度为1）开始自底向上逐层累加至该节点时的高度值 树的深度是指树中节点的最大深度，树的高度是指树中节点的最大高度。对树而言，深度和高度是相等的。 完全二叉树 完全二叉树可以通过建立一个大小为2的k次方的数组来存放所有节点的信息，其中k为完全二叉树的最大高度 且1号位存放的必须是根节点，这样就可以用数组下标来表示节点编号 该数组中元素存放的顺序恰好为该完全二叉树的层
LeetCode-树
以笔为刀的博客
01-12 128
1.二叉树层序遍历 LeetCode102 力扣https://leetcode-cn.com/problems/binary-tree-level-order-traversal/利用队列的特点: remove()方法:移除掉头部位置的元素并且返回最后位置的元素。 add()方法:队列尾部添加元素。 queue.isEmpty():队列是否为空。 队列先进先出。 public static void levelOrder(BiTreeNode t) { if (t == null)
Leetcode——树专题（持续更新）
qq_42265220的博客
01-11 432
学习目标： 掌握树的常见leetcode题目 学习内容： ①二叉树前中后序遍历：递归与非递归都要掌握 94.二叉树的中序遍历 144.二叉树的前序遍历 145.二叉树的后序遍历 ②二叉树的层序遍历： 102. 二叉树的层序遍历 107. 二叉树的层序遍历 II LinkedList的api(addFirst) 翻转二叉树 二叉树周末总结 对称二叉树 二叉树的最大深度 二叉树的最小深度 完全二叉树的节点个数 平衡二叉树 二叉树的所有路径 二叉树周末总结 二叉树中递归带着回溯 左叶子之和 找树左下角的
leetcode 打印_leetcode树之从上到下打印二叉树
weixin_29331115的博客
01-17 193
序本文主要记录一下leetcode树之上到下打印二叉树题目从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。例如:给定二叉树: [3,9,20,null,null,15,7],3/ \9 20/ \15 7返回其层次遍历结果：[[3],[9,20],[15,7]]提示：节点总数 <= 1000注意：本题与主站 102 题相同：https://leetcode...
LeetCode构建树的测试用例
飞奔的菜猪的博客
03-29 3078
最近几天有些佛了 由于一直赶导师分配的项目 所以LeetCode没怎么刷了 开始接触到树的题目了 一直卡在了如何构建一颗树的测试用例 所以想写篇文章专门分享一下 对了，分享一波最近做的书签 首先分享如何构建一颗二叉树的代码吧，因为这种情况比较特殊，所以更好写。 class TreeNode(object): def __init__(self, x): ...
LeetCode——字典树
qq_43332536的博客
02-07 144
Leetcode字典树题目
LeetCode：树的子结构
进击的Coder*的博客
05-01 206
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构， 即 A中有出现和B相同的结构和节点值。 来自：leetcode网站剑指offer第26题 树的子结构 下面给出两种解法，首先是自己的非递归解法，然后是leetcode一大佬的递归解法。 非递归解法： public boolean isSubStructure(TreeNode A, TreeNode B) { if(A==null || B==null) return fal..
Tcloser#leetcode-prectice#哈夫曼树1
07-25
① 对于给定的n个权值{W，w2，.. wn}, 构造出具有n棵叉树的森林F={ T, T,, .... T}，其中每棵.1叉树T均只有一个带有权值w的根结点
LeetCode刷题手册
01-16
数据结构： 对常见数据结构（数组、链表、树、图等）进行深入解释，以及如何在算法问题中使用它们。 刷题策略： 提供刷题的有效策略，包括按主题刷题、按难度刷题、每日刷题计划等。 实战经验： 分享刷题的实战...
LeetCode源码
05-09
该资源为《LeetCode题解》配套源码，程序员面试必备。主要是数据结构方面的知识，包括：数组、链表、栈、队列、树、图、查找、排序、动态规划以及贪心算法。包含题目130道左右，每道题目都给了不同的解法，方便大家...
LeetCode 235. 二叉搜索树的最近公共祖先
2301_80211119的博客
05-16 686
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
深入解读力扣154题：寻找旋转排序数组中的最小值 II（多种方法及详细ASCII图解）
最新发布
10年数据\经营分析经验，现任大厂数据分析负责人
05-21 159
这两种方法都能有效解决寻找旋转排序数组中最小值的问题。二分查找方法更高效，适用于大部分情况，而直接遍历方法简单直观，适用于理解和实现。根据具体情况选择合适的方法。假设按照升序排序的数组在预先未知的某个点上进行了旋转。请找出其中最小的元素。数组中可能存在重复元素。
Golang | Leetcode Golang题解之第91题解码方法
weixin_66442839的博客
05-16 278
Golang | Leetcode Golang题解之第91题解码方法
力扣204.计数质数（线性筛）
ouliten的博客
05-17 166
假设不中断，对于i*primes[j+1]这个合数，它被primes[j+1]这个质数标记.但实际上，它的最小质数因该是primes[j],因为当i' =(i/primes[j])*primes[j+1]时，i' *primes[j]==i*primes[j+1],可知它因该被primes[j]这个质数标记。线性筛我之前的题解已经涉及到，但是讲的实在太差了我自己回看都看不懂，于是通过这道题重新回顾线性筛。（p,q等都是质因数，n,m是指数），其中一定会有一个最小的质数，我们的目的是要标记一个合数。
leetcode 线段树
10-03
线段树是一种二叉搜索树，用于处理区间查询的数据结构。它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。线段树是一棵平衡二叉树，最后的子节点数目为N，即为整个线段区间的长度。线段树的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值