LeetCode树

最新推荐文章于 2024-07-25 19:34:38 发布
最新推荐文章于 2024-07-25 19:34:38 发布
阅读量92 收藏 1
点赞数 1
分类专栏： 刷题笔记 文章标签： leetcode 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56077202/article/details/125717884
版权

LeetCode.树

LeetCode. 98

/**
 * 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 isValidBST(TreeNode* root) {
        return dfs(root, INT_MIN, INT_MAX);
    }
    // 当前节点的值应该在[minv, maxv]这个值之间，如果符合分别递归判断左右子节点并且分别更新这个区间，否则return false
    bool dfs(TreeNode *root, long long minv, long long maxv) {
        if(!root) return true;
        if(root->val < minv || root->val > maxv) return false;
        return dfs(root->left, minv, root->val - 1ll) && dfs(root->right, root->val + 1ll, maxv);
    }
};

LeetCode. 94 迭代法中序遍历二叉树

  1. 将整棵树的最左边一条链压入栈中；
  2. 每次取出栈顶元素，如果其有右子树，则将右子树压入栈中；
/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> stk;

        auto p = root;
        while(p || stk.size()) {
            while(p) {
                stk.push(p);
                p = p->left;
            }
            p = stk.top();
            stk.pop();
            ans.push_back(p->val);
            p = p->right;
        }
        return ans;
    }
};

LeetCode. 1001 对称二叉树

递归：

/**
 * 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) {
        if(!root) return true;
        return dfs(root->left, root->right);
    }
    bool dfs(TreeNode *p, TreeNode *q) {
        if(!p || !q) return !p && !q;

        return p->val == q->val && dfs(p->left, q->right) && dfs(p->right, q->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) {
        if(!root) return true;
        stack<TreeNode*> left, right;
        TreeNode *l = root->left, *r = root->right;

        while(l || r || left.size() || right.size()) {
            while(l && r) {
                left.push(l), l = l->left;
                right.push(r), r = r->right;
            }

            if(l || r) return false;
            l = left.top(), left.pop();
            r = right.top(), right.pop();
            if(l->val != r->val) return false;
            l = l->right, r = r->left;
        }
        return true;
    }
};

LeetCode. 105 根据前序队列和中序队列重建二叉树

/**
 * 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 {
    unordered_map<int, int> pos;
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        for(int i = 0; i < n; ++i) {
            pos[inorder[i]] = i;
        }

        return dfs(preorder, inorder, 0, n-1, 0, n-1);
    }
    TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int pl, int pr, int il, int ir) {
        if(pl > pr) return nullptr;

        int val = preorder[pl]; // 根节点的值
        int k = pos[val]; // 根节点在中序遍历中的位置
        int len = k - il; // 左子树的长度
        TreeNode *root = new TreeNode(val);
        root->left = dfs(preorder, inorder, pl+1, pl+len, il, k-1);
        root->right = dfs(preorder, inorder, pl+len+1, pr, k+1, ir);
        return root;
    }
};

LeetCode. 102 二叉树的层序遍历

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(!root) return ans;

        queue<TreeNode*> q;
        q.push(root);
        int len;
        while(!q.empty()) {
            len = q.size();
            vector<int> level;
            for(int i = 0; i< len; ++i) {
                TreeNode* node = q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                level.push_back(node->val);
            }
            ans.push_back(level);
        }
        return ans;
    }
};

LeetCode. 236 二叉树的最近公共祖先

递归中需要做的：

  1. 如果以root为根的子树中包含p和q，则返回p和q的最近公共祖先；
  2. 如果以root为根的子树中只包含q，则返回q；
  3. 如果以root为根的子树中只包含p，则返回p；
  4. 如果以root为根的子树中都不包含，则返回nullptr；
/**
 * 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) {
        if(!root || root == p || root == q) return root;

        auto left = lowestCommonAncestor(root->left, p ,q);
        auto right = lowestCommonAncestor(root->right, p, q);

        if(!left) return right;
        if(!right) return left;

        return root;
    }
};

LeetCode. 543 二叉树的直径

枚举所有节点

/**
 * 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 {
    int ans = 0;
public:
    int diameterOfBinaryTree(TreeNode* root) {
        dfs(root);
        return ans;
    }
    int dfs(TreeNode *root) {
        if(!root) return 0;

        int left = dfs(root->left);
        int right = dfs(root->right);
        ans = max(ans, left+right);

        return max(left,right)+1;
    }
};

LeetCode. 124 二叉树的最大路径和

/**
 * 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 {
    int ans = INT_MIN;
public:
    int maxPathSum(TreeNode* root) {
        dfs(root);
        return ans;
    }
    // 返回的是权重的最大值
    int dfs(TreeNode* root) {
        if(!root) return 0;

        int left = dfs(root->left);
        int right = dfs(root->right);
        ans = max(ans, root->val + left + right);

        return max(0, root->val + max(0, max(left, right)));// 返回的时候，如果权重还没有0大，还不如不返回
    }
};

LeetCode. 173 二叉搜索树迭代器

迭代法中序遍历二叉树的思想

/**
 * 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 BSTIterator {
    stack<TreeNode*> stk;
public:
    BSTIterator(TreeNode* root) {
        while(root) {
            stk.push(root);
            root = root->left;
        }
    }
    
    int next() {
        TreeNode* node = stk.top();
        stk.pop();
        int tmp = node->val;
        node = node->right;
        while(node) {
            stk.push(node);
            node = node->left;
        }
        return tmp;
    }
    
    bool hasNext() {
        return !stk.empty();
    }
};

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator* obj = new BSTIterator(root);
 * int param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

LeetCode. 297 二叉树的序列化与反序列化

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

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string res;
        dfs1(root, res);
        return res;
    }
    void dfs1(TreeNode* root, string &res) {
        if(!root) {
            res += "#,";
            return;
        }

        res += to_string(root->val) + ",";
        dfs1(root->left, res);
        dfs1(root->right, res);
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        int u = 0;
        return dfs2(data, u);
    }
    TreeNode *dfs2(string& data, int &u) {
        if(data[u] == '#') {
            u += 2;
            return nullptr;
        }

        int t = 0;
        bool is_minus = false;
        if(data[u] == '-') {
            is_minus = true;
            ++u;
        }
        while(data[u] != ',') {
            t = t * 10 + data[u] - '0';
            ++u;
        }
        ++u;
        if(is_minus) t = -t;
        
        TreeNode *root = new TreeNode(t);
        root->left = dfs2(data, u);
        root->right = dfs2(data, u);

        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));

LeetCode. 106 从中序遍历和后序遍历序列构造二叉树

/**
 * 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 {
    int len;
    unordered_map<int, int> pos;
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        len = inorder.size() - 1;
        for(int i = 0; i <= len; ++i) {
            pos[inorder[i]] = i;
        }
        return dfs(inorder, postorder, 0, len, 0, len);
    }
    TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int il, int ir, int pl, int pr) {
        if(pl > pr) return nullptr;

        int num = postorder[pr];
        int index = pos[num];
        int length = ir - index;

        TreeNode* node = new TreeNode(num);
        node->right = dfs(inorder, postorder, index+1, ir, pr - length, pr - 1);
        node->left = dfs(inorder, postorder, il, index-1, pl, pr - length - 1);
        return node;
    }
};
小名王能全
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode 树的直径（树中最远的两个点）
一只老风铃
09-06 1649
题目描述 给定一棵树，求出这棵树的直径，即两个节点距离的最大值。 示例1 输入 复制 6,[[0,1],[1,5],[1,2],[2,3],[2,4]],[3,4,2,1,5] 输出 复制 11 思路： 从任意一个点出发找到最远的点P 从P点出发找到最远的点Q P Q之间的距离即为树中最远两个点距离 证明： 实现： 采取基本的dfs 实现搜索最远的点，找到他们之后 采取dfs 返回两者的距离 int point_p; ...
leetcode2-treevis:Treevis是一个用来绘制LeetCode树的小工具。调试可视化测试用例很有用
06-29
leetcode 2 树视 Treevis 是一个用来绘制 LeetCode 树的小工具。 调试可视化测试用例很有用。 如何使用 如果您想全局安装它以便将其添加到您的$PATH您可以使用 $ npm install -g treevis # or $ yarn global add ...
004 leetcode树总结
Mirevas的博客
12-04 1132
一、树的相关概念 高度与深度 节点的深度是指从根节点（深度为1）开始自顶向下逐层累加至该节点时的深度值 节点的高度是指从最底层叶子节点（高度为1）开始自底向上逐层累加至该节点时的高度值 树的深度是指树中节点的最大深度，树的高度是指树中节点的最大高度。对树而言，深度和高度是相等的。 完全二叉树 完全二叉树可以通过建立一个大小为2的k次方的数组来存放所有节点的信息，其中k为完全二叉树的最大高度 且1号位存放的必须是根节点，这样就可以用数组下标来表示节点编号 该数组中元素存放的顺序恰好为该完全二叉树的层
leetcode树之二叉树的创建
溪语流沙的博客
03-21 1163
前言 前面介绍了二叉树的遍历，这次我们来考虑一下二叉树的创建，给定前中后序遍历的结果，这个时候要还原成二叉树应该怎么做呢？ 下面来通过几道题来实际感受一下吧！ 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 121
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 140
leetcode 树总结 所遇见的树的题目差不多可以归为一下几类：前中后序遍历，dfs，bfs，层次遍历，二叉搜索树。 碰到一个比较有意思的思想是，leetcod的一个题解中将数的前中后序遍历与dfs关联： 1161. 最大层内元素和. ...
LeetCode-树
以笔为刀的博客
01-12 152
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 450
学习目标： 掌握树的常见leetcode题目 学习内容： ①二叉树前中后序遍历：递归与非递归都要掌握 94.二叉树的中序遍历 144.二叉树的前序遍历 145.二叉树的后序遍历 ②二叉树的层序遍历： 102. 二叉树的层序遍历 107. 二叉树的层序遍历 II LinkedList的api(addFirst) 翻转二叉树 二叉树周末总结 对称二叉树 二叉树的最大深度 二叉树的最小深度 完全二叉树的节点个数 平衡二叉树 二叉树的所有路径 二叉树周末总结 二叉树中递归带着回溯 左叶子之和 找树左下角的
Leetcode 树的子结构
成长之路
02-24 257
leetcode 输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构， 即 A中有出现和B相同的结构和节点值。 思路： 先判断B 为空， 则返回 False 在A中遍历，看B的根节点是否出现 如果出现，比较这个节点的子树是否与B 相同 # Definition for a binary tree node. # class TreeNode: # ...
leetcode 打印_leetcode树之从上到下打印二叉树
weixin_29331115的博客
01-17 209
序本文主要记录一下leetcode树之上到下打印二叉树题目从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。例如:给定二叉树: [3,9,20,null,null,15,7],3/ \9 20/ \15 7返回其层次遍历结果：[[3],[9,20],[15,7]]提示：节点总数 <= 1000注意：本题与主站 102 题相同：https://leetcode...
LeetCode——字典树
qq_43332536的博客
02-07 186
Leetcode字典树题目
leetcode思维导图-树
08-13
leetcode思维导图-树
Tcloser#leetcode-prectice#哈夫曼树1
07-25
① 对于给定的n个权值{W，w2，.. wn}, 构造出具有n棵叉树的森林F={ T, T,, .... T}，其中每棵.1叉树T均只有一个带有权值w的根结点
LeetCode Solutions
06-13
2. **数据结构**：包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树、红黑树等）、图等。在LeetCode中，很多问题都涉及到了数据结构的使用，如查找、排序、连接等操作。 3. **算法**：包括排序算法（快速排序...
LeetCode刷题手册
01-16
数据结构： 对常见数据结构（数组、链表、树、图等）进行深入解释，以及如何在算法问题中使用它们。 刷题策略： 提供刷题的有效策略，包括按主题刷题、按难度刷题、每日刷题计划等。 实战经验： 分享刷题的实战...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 841
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
LeetCode707 设计链表
daishabby2486的博客
07-25 574
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 313
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
力扣202.快乐数
最新发布
gyj215500的博客
07-25 227
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
leetcode 线段树
10-03
线段树是一种二叉搜索树，用于处理区间查询的数据结构。它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。线段树是一棵平衡二叉树，最后的子节点数目为N，即为整个线段区间的长度。线段树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值