力扣--树题总结

已于 2025-04-01 16:56:30 修改
阅读量277 收藏
点赞数 2
分类专栏： leetcode 文章标签： leetcode
于 2024-11-11 19:21:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44965579/article/details/143691973
版权

1.传统二叉树 

112. 路径总和

class Solution {
public:
    bool flag = false;
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return 0;
        int pathsum=0;
        backtrack(root, targetSum, pathsum);
        return flag;
    }
    void backtrack(TreeNode* root, int targetSum, int pathsum){
        pathsum += root->val;
        if(root->left == nullptr && root->right == nullptr){
            if(pathsum == targetSum){
                flag = true;
            }
            return;
        }
        if(root->left){
            backtrack(root->left, targetSum, pathsum);
        }
        if(root->right){
            backtrack(root->right, targetSum, pathsum);
        }
    }
};

783. 二叉搜索树节点最小距离

/**
 * 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 minDiffInBST(TreeNode* root) {
        int ans = INT_MAX, pre = -1;
        dfs(root, pre, ans);
        return ans;
    }

    void dfs(TreeNode* root, int& pre, int& ans){
        //递归返回条件
        if(root == nullptr){
            return;
        }
        //前-一直递归到左下角
        dfs(root->left, pre, ans);
        //中-处理数据，第一次pre保存左下角值
        if(pre == -1){
            pre = root->val;
        }else{
            //递归退回到左下角父节点，ans取最小
            ans = min(ans, root->val - pre);
            //pre更新到当前节点的val
            pre = root->val;
        }
        //后续
        dfs(root->right, pre, ans);
    }
};

872. 叶子相似的树

/**
 * 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 leafSimilar(TreeNode* root1, TreeNode* root2) {
        vector<int> num1;
        vector<int> num2;
        inorder(root1, num1);
        inorder(root2, num2);
        if(num1.size() != num2.size()) return false;
        for(int i=0; i< num1.size(); i++){
            if(num1[i] != num2[i]) return false;
        }
        return true;
    }

    void inorder(TreeNode* root, vector<int>& num){
        if(root==nullptr){
            return;
        }
        inorder(root->left, num);
        if(root->left==nullptr && root->right==nullptr){
            num.push_back(root->val);
        }
        inorder(root->right, num);
    }
};

897. 递增顺序搜索树

/**
 * 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* increasingBST(TreeNode* root) {
        vector<int> res;
        TreeNode* head = new TreeNode();
        TreeNode* p = head;
        dfs(root, res);
        for(int val: res){
            TreeNode* node = new TreeNode(val);
            p->right = node;
            p = p->right;
        }
        return head->right;
    }

    void dfs(TreeNode* root, vector<int>& res){
        if(root == nullptr){
            return;
        }
        dfs(root->left, res);
        res.push_back(root->val);
        dfs(root->right, res);
    }
};

100. 相同的树

/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if (p == nullptr && q == nullptr) {
            return true;
        } else if (p == nullptr || q == nullptr) {
            return false;
        } else if (p->val != q->val) {
            return false;
        } else {
            return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
        }
    }
};

  104. 二叉树的最大深度

 先序递归遍历树，取deep的最大值，deep是一个回溯的过程

/**
 * 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 maxdeep = 0;
    int maxDepth(TreeNode* root) {
        dfs(root, 0);
        return maxdeep;
    }

    void dfs(TreeNode* root, int deep){
        if(root == nullptr){
            return;
        }
        deep++;
        maxdeep = max(maxdeep, deep);
        dfs(root->left, deep);
        dfs(root->right, deep);
    }
};

更常见的写法

class Solution {
public:
    int maxdeep = 0;
    int maxDepth(TreeNode* root) {
        if(root == nullptr){
            return 0;
        }
        return max(maxDepth(root->left), maxDepth(root->right))+1;
    }

563. 二叉树的坡度

/**
 * 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 findTilt(TreeNode* root) {
        int ans = 0;
        dfs(root, ans);
        return ans;
    }

    int dfs(TreeNode* root, int& ans){
        if(root == nullptr){
            return 0;
        }
        int left = dfs(root->left, ans);
        int right = dfs(root->right, ans);
        ans += abs(left - right);
        return left+right+root->val;
    }
};

2.搜索树 

 101. 对称二叉树

 模仿上一题，不同处为：比较的是left->left, right->right和 left->right, right->left

/**
 * 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 isSymmetric(TreeNode* root) {
        return fun(root->left, root->right);
    }

    bool fun(TreeNode* left, TreeNode* right){
        if(left==nullptr && right==nullptr){
            return true;
        }else if(left==nullptr || right==nullptr){
            return false;
        }else if(left->val != right->val){
            return false;
        }else{
            return fun(left->left, right->right) && fun(left->right, right->left);
        }

    }
};

108. 将有序数组转换为二叉搜索树

每次以中间节点为根节点进行递归。 

/**
 * 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* sortedArrayToBST(vector<int>& nums) {
        return fun(nums, 0, nums.size()-1);
    }

    TreeNode* fun(vector<int>& nums, int left, int right){
        if(left > right){
            return nullptr;
        }
        int mid = (left + right)/2;
        TreeNode* node = new TreeNode(nums[mid]);
        node->left = fun(nums, left, mid-1);
        node->right = fun(nums, mid+1, right);
        return node;
    }
};

110. 平衡二叉树

 每个子树都是平衡二叉树，即当前树的左右高度<=1，并且递归每个子树都满足这个条件

引用上一题中的求深度的函数

/**
 * 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 isBalanced(TreeNode* root) {
        if(root == nullptr){
            return true;
        }
        return abs(maxDeepth(root->left) - maxDeepth(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right);
    }

    int maxDeepth(TreeNode* root){
        if(root == nullptr){
            return 0;
        }
        return max(maxDeepth(root->left), maxDeepth(root->right)) + 1;
    }
};

3.N叉树 

589. N 叉树的前序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> preorder(Node* root) {
        vector<int> ans;
        if(root == nullptr){
            return ans;
        }
        preorder(root, ans);
        return ans;
    }

    void preorder(Node* node, vector<int>& ans){
        if(node == nullptr){
            return;
        }
        ans.push_back(node->val);
        for(auto n : node->children){
            preorder(n, ans);
        }
    }
};

590. N 叉树的后序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<int> postorder(Node* root) {
        vector<int> ans;
        if(root == nullptr){
            return ans;
        }
        order(root, ans);
        return ans;
    }

    void order(Node* node, vector<int>& ans){
        if(node == nullptr){
            return;
        }
        for(auto n : node->children){
            order(n, ans);
        }
        ans.push_back(node->val);
    }
};

559. N 叉树的最大深度

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if(root == nullptr){
            return 0;
        }
        return dfs(root)+1;
    }

    int dfs(Node* root){
        if(root == nullptr){
            return 0;
        }
        int deep = 0;
        for(Node* n : root->children){
            deep = max(deep, dfs(n)+1);
        }
        return deep;
    }
};

  

力扣--目标和
wolfGuiDao的博客
07-01 1822
力扣–目标和 文章目录力扣--目标和一、题目描述二、分析方法一：回溯方法二、消除重叠子问题方法三、动态规划 一、题目描述 class Solution { public: int findTargetSumWays(vector<int>& nums, int S) { } }; 二、分析 方法一：回溯 任何算法的核心都是穷举，回溯算法就是一个暴力穷举算法，回溯算法框架： def backtrack(路径, 选择列表): if 满足结束条件:
代码随想录-力扣刷题-总结笔记02
upward
04-04 1265
代码随想录-力扣刷题-总结笔记02
力扣----经典题（python实现）
一夜奈何梁山
03-11 3117
经典题一：两数之和：二：三数之和：三：两数相加：四： 买股票的最佳时机： 一：两数之和： 二：三数之和： 1：首先我们要对数组进行排序， 排序的原因是因为不允许出现重复的。 2：第一层循环，我们可以循环遍历数组，枚举a，而且我们要判断当前枚举的和上次枚举的是否值是相同的，如果相同的，则直接跳过。 3：第二层中，我们可以计算出，剩余两个相加需要的和。我们可以让第三个指针，指向末尾，然后循环遍历第二个指针， 4：第三层中，每次第二个指针到达一个位置，我们计算这两个指针的相加和是多少，如果大于需要的和，说明加多
力扣-剑指offer所有题
qq_40214464的博客
03-08 5527
第27天 单向队列 剑指 Offer 59 - I. 滑动窗口的最大值https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/ 给定一个数组nums和滑动窗口的大小k，请找出所有滑动窗口里的最大值。 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3 输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置 最大值 ---------.....
力扣-图论问题总结
weixin_44965579的博客
04-07 409
力扣题目记录
力扣-练习总结
caoluguang2006的专栏
01-19 568
一、数组（485、283、27）： 1.1 485（最大连续1的个数）： 通过一个for循环，维护一个max和count，如果指针是1，count就++并且更新max；如果不是1就把count置为0，最后返回max。1.2 283（将所有0移动到数据末尾）： 通过一个for循环，维护两个指针slow、fast，保证0~slow之间都是非0的保续元素，如果fast不为0，就把fast位置的值赋值给slow位置，并且slow++，继续变脸fast下一个位置；for结束后把slow及往后的所有数据都赋值为0，结束
力扣-动态规划问题总结
weixin_44965579的博客
02-23 1360
动态规划-自用
算法-力扣-N叉树遍历
六甲的博客
05-27 686
N叉树节点的定义 public class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) { val = _val; } public Node(int _val, List<Node> _children) { val = _val; childre
力扣-700-二叉搜索树中的搜索-JavaScript实现
j13733143423的博客
07-15 182
这道题代码和思路之所以这么简洁和容易理解，主要是这道题目利用了二叉搜索树的特性触发，根本不用遍历全部二叉树的节点，直接根据他的特性来缩小范围，就很类似于二分查找。
6.力扣-树-路径总和
“秃头”少女
06-03 250
力扣-树-路径总和 路径总和（LeetCode 437） 题目概述：给定一个二叉树，它的每个结点都存放着一个整数值。找出路径和等于给定数值的路径总数。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。（二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。） 题目示例： 解题思路： 1.递归：这个是我自己思路，比较简单但时间复杂度也比较大。首先我们需要构造一个函数getSum()来求解从某结点开始往下的路径和是否等于给
力扣-组合两个表
业余Python爱好者
02-16 632
在MySQL中，可以使用JOIN语句来组合两个表。JOIN语句可以根据两个或更多表中的列之间的关系，从这些表中获取数据。
js代码-力扣第七题
07-16
总结起来，这个压缩包提供了力扣第七题的JavaScript解决方案，包括了实际的代码实现（`main.js`）和可能的解释文档（`README.txt`）。通过阅读和理解这些文件，你可以学习到如何在JavaScript中处理二叉树结构，以及...
力扣题目 - 1847.最近的房间
12-17
力扣题号1847是一道关于空间搜索和数据结构的算法题。题目的核心任务是在一个房间管理系统中，找出与指定房间距离最近的房间，并给出最小的距离值。这个问题通常可以通过二分搜索、平衡树（如红黑树或AVL树）、堆等...
leetcode-hot-100 (矩阵）
weixin_73557167的博客
06-01 834
矩阵
704. 二分查找 （力扣）
最新发布
woyvxuetongzai52的博客
06-03 157
摘要：本文实现了一个二分查找算法，用于在有序整型数组中查找目标值。算法通过维护左右指针逐步缩小搜索范围，时间复杂度为O(log n)。当目标值存在时返回其下标，否则返回-1。示例展示了查找成功（target=9返回4）和失败（target=2返回-1）的情况。代码采用左闭右开区间写法，避免整数溢出问题，适用于元素唯一且数组长度在1到10000之间的场景。
LeetCode - 965. 单值二叉树
2402_83315537的博客
06-01 231
本文介绍了使用深度优先搜索(DFS)判断二叉树是否为单值二叉树的方法。DFS是一种递归遍历算法，会尽可能深入搜索每条路径。实现时分为三部分：检查当前节点与左右子节点的值是否相同，并递归验证左右子树是否为单值树。文中给出了正确的代码实现，若遇到空节点返回true，发现不同值则返回false，最终需左右子树都满足条件才判定为单值二叉树。
力扣HOT100之动态规划：416. 分割等和子集
weixin_52151595的博客
06-01 722
这道题之前刷过代码随想录，现在只能想起一点点思路，最后还是去看视频了。这道题用二维dp数组或者一维dp数组都可以做，这篇博客把两种思路都讲一下。
Leetcode 261. 以图判树
m0_51437455的博客
06-03 316
给定一个整数 n 和一个 edges 列表，其中 edges[i] = [ai, bi] 表示图中节点 ai 和 bi 之间存在一条无向边。第二步，遍历所有的边，将相关相连的点进行连接，如果边的两端都在同一个集合中，则代表存在环，直接返回false。如果这些边能够形成一个合法有效的树结构，则返回 true ，否则返回 false。第三步，如果图中无环，则只要并查集中的集合数为1就能保证图能构建成熟。第三步，如果图中无环且只有一个连通分量则可以构建成树。第一步，构建并查集，并将所有的节点添加到并查集中。
day15 leetcode-hot100-28（链表7）
m0_62948824的博客
05-31 281
（2）链表1与链表2相加，具体方式为sum=n1+n2+jin（进位），该位置的值为sum%10，jin=sum/10.（4）最后如果进位不为0，则需要再增加一个节点，节点值为jin（进位值）（3）判断两个链表的下一个节点是否为空，不为空就向下继续走。最核心的一点就是将两个链表模拟为等长，不足的假设为0；（1）设置一个新链表newl来代表相加结果。
力扣112题C语言实现
04-20
好的，我现在需要帮用户查找力扣112题的C语言实现代码或解决方案。首先，我要确定题目112是什么内容。力扣112题是“路径总和”，题目要求判断二叉树中是否存在从根节点到叶子节点的路径，使得路径上所有节点的值之和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值