C++算法题 - 二叉树（2）

最新推荐文章于 2024-07-16 18:00:34 发布
最新推荐文章于 2024-07-16 18:00:34 发布
阅读量999 收藏 25
点赞数 11
分类专栏： 力扣算法 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x_fengmo/article/details/138315814
版权

@TOC

114. 二叉树展开为链表

LeetCode_link

给你二叉树的根结点 root ，请你将它展开为一个单链表：

  • 展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
  • 展开后的单链表应该与二叉树 先序遍历 顺序相同。

示例 1：
在这里插入图片描述
输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [0]
输出：[0]

提示：
树中结点数在范围 [0, 2000] 内
-100 <= Node.val <= 100

思路：用栈进行先序遍历，让遍历过的节点成为空节点，即让父节点的指针变成null

/**
 * 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 flatten(TreeNode* root) {
        if(root==nullptr)   return;
        stack<TreeNode*> s;
        s.push(root);
        TreeNode* rec = new TreeNode(root->val, nullptr, nullptr);
        TreeNode* n = root, *end = rec, *temp;
        while(!s.empty()){
            if(n->left != nullptr){
                n = n->left;
                s.push(n);                         
            }else if(n->right != nullptr){
                n = n->right;
                s.push(n);
                
            }else{
                while(!s.empty() && n->left == nullptr && n->right == nullptr){
                    temp = s.top();
                    s.pop();
                    if(!s.empty()) {
                        n = s.top();
                        if(n->left == temp){
                            n->left = nullptr;
                        }else if(n->right == temp){
                            n->right = nullptr;
                        }
                    }
                }
                if(!s.empty()){ 
                    n = n->right;
                    s.push(n);
                }
            }
            if(!s.empty()){
                TreeNode* new_node = new TreeNode(n->val, nullptr, nullptr);
                end->right = new_node;
                end = end->right;
            }
        }
        root->right = rec->right;
    }
};

112. 路径总和

LeetCode_link

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：
在这里插入图片描述
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：
在这里插入图片描述
输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：
输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：
树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

思路：递归

/**
 * 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 hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        if(root->left == nullptr && root->right == nullptr){
            if(targetSum == root->val)  return true;
            else    return false;
        }
        bool left, right;
        if(root->left != nullptr){
            left = hasPathSum(root->left, targetSum - root->val);
        }
        if(root->right != nullptr){
            right = hasPathSum(root->right, targetSum - root->val);
        }
        return left || right;
    }
};

129. 求根节点到叶节点数字之和

LeetCode_link

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
每条从根节点到叶节点的路径都代表一个数字：

  • 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

示例 1：
在这里插入图片描述
输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：
在这里插入图片描述
输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

提示：
树中节点的数目在范围 [1, 1000] 内
0 <= Node.val <= 9
树的深度不超过 10

思路：递归

/**
 * 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 sumNumbers(TreeNode* root) {
        return number(root, 0);
    }
    int number(TreeNode* root, int n){
        if(root-> left == nullptr && root->right == nullptr)	return n + root->val;
        int left, right;
        if(root->left == nullptr)	left = 0;
        else	left = number(root->left, (n+root->val)*10);
        if(root->right == nullptr)	right = 0;
        else	right = number(root->right, (n+root->val)*10);
        return left + right;
    }
};

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

LeetCode_link

二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

路径和 是路径中各节点值的总和。

给你一个二叉树的根节点 root ，返回其 最大路径和 。

示例 1：
在这里插入图片描述
输入：root = [1,2,3]
输出：6
解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6

示例 2：
在这里插入图片描述
输入：root = [-10,9,20,null,null,15,7]
输出：42
解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42

提示：
树中节点数目范围是 [1, 3 * 10^4]
-1000 <= Node.val <= 1000

思路：递归，返回值是小于0，就不会将分支算入路径了

/**
 * 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 {
private:
    int maxnum = -1002;
public:
    int maxPathSum(TreeNode* root) {
        pathsum(root);
        return maxnum;

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

        int sum = left + right + val;
        maxnum = max(sum, maxnum);

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

173. 二叉搜索树迭代器

LeetCode_link

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：

  • BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
  • boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
  • int next()将指针向右移动，然后返回指针处的数字。

注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。

你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

示例：
在这里插入图片描述

输入
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
输出
[null, 3, 7, true, 9, true, 15, true, 20, false]

解释
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next();    // 返回 3
bSTIterator.next();    // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next();    // 返回 20
bSTIterator.hasNext(); // 返回 False

提示：
树中节点的数目在范围 [1, 10^5] 内
0 <= Node.val <= 10^6
最多调用 10^5 次 hasNext 和 next 操作

思路：递归建队列，用队列输出

/**
 * 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 {
private:
    queue<int> q;
public:
    BSTIterator(TreeNode* root) {
        push_stack(root);
    }
    void push_stack(TreeNode* root){
        if(root == nullptr){
            return;
        }
        push_stack(root->left);
        q.push(root->val);
        push_stack(root->right);
    }
    
    int next() {
        int now = q.front();
        q.pop();
        return now;
    }
    
    bool hasNext() {
        return !q.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();
 */

222. 完全二叉树的节点个数

LeetCode_link

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h 个节点。

示例 1：
在这里插入图片描述
输入：root = [1,2,3,4,5,6]
输出：6

示例 2：
输入：root = []
输出：0

示例 3：
输入：root = [1]
输出：1

提示：
树中节点的数目范围是[0, 5 * 10^4]
0 <= Node.val <= 5 * 10^4
题目数据保证输入的树是 完全二叉树

思路：递归

/**
 * 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 countNodes(TreeNode* root) {
        if(root == nullptr) return 0;
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

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

LeetCode_link

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：
在这里插入图片描述
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：
在这里插入图片描述
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：
输入：root = [1,2], p = 1, q = 2
输出：1

提示：
树中节点数目在范围 [2, 10^5] 内。
-10^9 <= Node.val <= 10^9
所有 Node.val 互不相同 。
p != q
p 和 q 均存在于给定的二叉树中。

思路：
x_fengmo
关注
  • 11
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3308
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
[C++算法入门]-二叉树打印练习题
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者熟悉二叉树的打印操作和相关算法。文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和...
C++算法题 - 二叉树层次遍历
一个愚蠢的研究牲
05-08 798
力扣算法：199，637，102，103
C++算法题——平衡二叉树判断
m0_64509386的博客
06-24 657
平衡二叉树的判断
C++算法二叉树
jkjldjjqde的博客
01-25 1484
可以从图中看到，满二叉树在完全二叉树里面，因为它包含了完全二叉树的所有特征 ，所以在完全二叉树里面。可以从字面意思来理解一下，高度是从0开始，从叶子节点开始，往上一层高度就加一。存储当然是用结构体啦，结构体保存着：自己的值，左孩子，右孩子。意思就是我先遍历父节点，再遍历左孩子，最后遍历右孩子。深度与高度相反，也是从0开始，但是从根节点开始，往下一层深度就加一。去掉最后一层节点后，剩下来的树是满二叉树，还有一个要求，最后一层必须是左右分布。层数最好理解，从1开始，从根节点开始，往上一层层数加一。
C++实现树 - 02 二叉树
Newin2020的博客
05-04 5348
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
每日一道算法题--leetcode 94--二叉树的中序遍历--python&C++ 递归+迭代
transformed的博客
11-12 123
传送门
【王道数据结构编程题】- 二叉树算法题
m0_56051805的博客
06-22 1367
王道代码题具体实现，可以运行。1.已知一颗二叉树按顺序存储结构进行存储，设计一个算法，求编号分别为i和j的两个节点的最近的公共祖先节点的值。2.编写后序遍历的二叉树的非递归算法。3.试给出二叉树的自下而上，从右到左的层次遍历算法。4.假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度。5.设一颗二叉树中各个节点的值互不相同，其先序遍历序列和中序遍历序列分别存于两个一维数组A[1...n]和B[1...n]中，试编写算法建立该二叉树的二叉链表。6.二叉树按二叉链表形式存储，写一个判别给定二叉树.
分治算法实践2-二叉树的后序遍历 C++
m0_51230983的博客
12-17 1362
题目描述 给你一个二叉树，按照后序遍历的顺序输出这棵树。 输入数据 第一行一个整数 n (1≤n≤1e4) ，表示这棵树的节点数。 接下来有 n-1 行，每行有两个整数 u,v 表示节点 u 到节点 v 有一条边，输入保证树以 1 为根，且 u 为 v 的父节点。对于一个节点的多个子节点，将更早输入的那一个子节点的视为他的左子节点。 输出数据 输出该树的后序遍历，节点编号之间用一个空格分隔。 样例输入 6 1 2 2 3 3 4 1 5 5 6 样例输出 4 3 2 6 5 1 样例说明 后序遍
关于常见的各种二叉树算法题C++代码实现（希望可以持续更新…）
C/C++菜鸟养成记
12-07 1027
各种常见的二叉树算法题
C/C++，树算法-二叉树（BTree）的基本数据结构
05-14
C/C++，树算法——二叉树（BTree）的基本数据结构
C/C++，树算法-二叉树的插入(Insert)算法之源程序
05-14
C/C++，树算法——二叉树的插入(Insert)算法之源程序
数据结构C++版-二叉树实验-使用类模板的方式实现
11-27
一、实验目的：1、实现二叉树的存储结构（二叉链表或三叉链表等存储结构任选）2、熟悉二叉树基本术语的含义3、掌握使用栈和队列及递归思想完成二叉树相关操作的编程实现二、实验内容: 主要完成以下功能:1....
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1100
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 218
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 155
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
最新发布
m0_59680769的博客
07-16 979
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1039
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
c++编写算法统计二叉树结点个数
06-11
统计二叉树结点个数的算法可以通过递归实现，递归的思路是：二叉树结点个数 = 左子树结点个数 + 右子树结点个数 + 1（根节点）。 具体实现代码如下： ```cpp int countNodes(TreeNode* root) { if (root == NULL)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

x_fengmo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值