_17LeetCode代码随想录算法训练营第十七天-C++二叉树 | 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

已于 2023-02-01 22:41:09 修改
阅读量109 收藏 1
点赞数 1
分类专栏： Algorithms 文章标签： 算法 c++ leetcode
于 2022-12-26 15:51:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44410704/article/details/128445434
版权

_17LeetCode代码随想录算法训练营第十七天-C++二叉树 | 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

题目列表

  • 654.最大二叉树
  • 617.合并二叉树
  • 700.二叉搜索树中的搜索
  • 98.验证二叉搜索树

654.最大二叉树

代码随想录地址：https://programmercarl.com/0654.%E6%9C%80%E5%A4%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html

题目

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

  1. 创建一个根节点，其值为 nums 中的最大值。
  2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。
  3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。

返回 nums 构建的 最大二叉树 。

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

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

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

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

  • 1 <= nums.length <= 1000
  • 0 <= nums[i] <= 1000
  • nums 中的所有整数 互不相同

代码

/*
 * @lc app=leetcode.cn id=654 lang=cpp
 *
 * [654] 最大二叉树
 */

// @lc code=start
/**
 * 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:
    //中左右即前序的遍历顺序
    //begin和end是左闭右闭的
    TreeNode* traverse(vector<int>& nums, int begin, int end)
    {
        if(begin > end)
            return nullptr;
        int maxValue = INT_MIN;
        int index = 0;
        for(int i = begin; i <= end; i++)
        {
            if(nums[i] > maxValue)
            {
                maxValue = nums[i];
                index = i;
            }
        }
        //构造中节点
        TreeNode* res = new TreeNode(maxValue);
        //构造左子树
        res->left = traverse(nums, begin, index - 1);
        //构造右子树
        res->right = traverse(nums, index + 1, end);
        return res;
    }
public: 
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traverse(nums, 0, nums.size() - 1);
    }
};
// @lc code=end

617.合并二叉树

代码随想录地址：https://programmercarl.com/0617.%E5%90%88%E5%B9%B6%E4%BA%8C%E5%8F%89%E6%A0%91.html

题目

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

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

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例 2：

输入：root1 = [1], root2 = [1,2]
输出：[2,2]

提示：

  • 两棵树中的节点数目在范围 [0, 2000] 内
  • - 1 0 4 10^4 104 <= Node.val <= 1 0 4 10^4 104

代码

递归代码

改变原树结构

/*
 * @lc app=leetcode.cn id=617 lang=cpp
 *
 * [617] 合并二叉树
 */

// @lc code=start
/**
 * 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:
    //此为改变树1和树2的结构的代码
    //使用前序遍历
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == nullptr)    return root2;
        if(root2 == nullptr)    return root1;
        //中
        root1->val += root2->val;
        //左
        root1->left = mergeTrees(root1->left, root2->left);
        //右
        root1->right = mergeTrees(root1->right, root2->right);
        return root1;
    }
};
// @lc code=end

非递归代码-迭代

/*
 * @lc app=leetcode.cn id=617 lang=cpp
 *
 * [617] 合并二叉树
 */

// @lc code=start
/**
 * 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* mergeTrees(TreeNode* root1, TreeNode* root2) {
        //只要有一个树为空，则将该树直接返回
        if(root1 == nullptr)
            return root2;
        if(root2 == nullptr)
            return root1;
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);
        while(!que.empty())
        {
            //处理中
            TreeNode* node1 = que.front();
            que.pop();
            TreeNode* node2 = que.front();
            que.pop();
            node1->val += node2->val;
            //处理左，如果node1和node2的左孩子都不为空
            if(node1->left != nullptr && node2->left != nullptr)
            {
                que.push(node1->left);
                que.push(node2->left);
            }
            //处理右，如果node1和node2的右孩子都不为空
            if(node1->right != nullptr && node2->right != nullptr)
            {
                que.push(node1->right);
                que.push(node2->right);
            }
            //处理左，如果node1的左孩子为空，node2的左孩子不为空
            if(node1->left == nullptr && node2->left != nullptr)
                node1->left = node2->left;
            //处理右，如果node1的右孩子为空，node2的右孩子不为空
            if(node1->right == nullptr && node2->right != nullptr)
                node1->right = node2->right;
        }
        return root1;
    }
};
// @lc code=end

700.二叉搜索树中的搜索

代码随想录地址：https://programmercarl.com/0700.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E6%90%9C%E7%B4%A2.html

题目

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

在这里插入图片描述

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

示例 2:

在这里插入图片描述

输入：root = [4,2,7,1,3], val = 5
输出：[]

提示：

  • 数中节点数在 [1, 5000] 范围内
  • 1 <= Node.val <= 1 0 7 10^7 107
  • root 是二叉搜索树
  • 1 <= val <= 1 0 7 10^7 107

代码

递归代码

/*
 * @lc app=leetcode.cn id=700 lang=cpp
 *
 * [700] 二叉搜索树中的搜索
 */

// @lc code=start
/**
 * 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* searchBST(TreeNode* root, int val) {
        if(root == nullptr || root->val == val)
            return root;
        TreeNode* res = nullptr;
        //如果当前元素的val大于val，那么说明可能在左子树中
        if(root->val > val)
            res = searchBST(root->left, val);
        //如果当前元素的val小于val，那么说明可能在右子树中
        if(root->val < val)
            res = searchBST(root->right, val);
        return res;
    }
};
// @lc code=end

非递归代码-迭代

/*
 * @lc app=leetcode.cn id=700 lang=cpp
 *
 * [700] 二叉搜索树中的搜索
 */

// @lc code=start
/**
 * 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* searchBST(TreeNode* root, int val) {
        //就一直往下找呗
        while(root != nullptr)
        {
            if(root->val > val)
                root = root->left;
            else if(root->val < val)
                root = root->right;
            else//找到了就直接返回   
                return root;
        }
        return nullptr;
    }
};
// @lc code=end

98.验证二叉搜索树

代码随想录地址：https://programmercarl.com/0098.%E9%AA%8C%E8%AF%81%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91.html

题目

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

  • 节点的左子树只包含 小于 当前节点的数。
  • 节点的右子树只包含 大于 当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

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

输入：root = [2,1,3]
输出：true

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

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

  • 树中节点数目范围在[1, 1 0 4 10^4 104] 内
  • - 2 31 2^{31} 231 <= Node.val <= 2 31 2^{31} 231 - 1

注意事项

空树是二叉搜索树，空树是完全二叉树。

代码

借助数组实现

/*
 * @lc app=leetcode.cn id=98 lang=cpp
 *
 * [98] 验证二叉搜索树
 */

// @lc code=start
/**
 * 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:
    vector<int> res;
    void traverse(TreeNode* node)
    {
        if(node == nullptr)
            return;
        traverse(node->left);
        res.push_back(node->val);
        traverse(node->right);
    }
public:
    //遍历一遍树，按中序遍历，将遍历所得数据存储到数组里面
    //最后判断数组是否是有序的
    bool isValidBST(TreeNode* root) {
        traverse(root);
        for(int i = 1; i < res.size(); i++)
        {
            if(res[i] <= res[i - 1])
                return false;
        }
        return true;
    }
};
// @lc code=end

递归代码

/*
 * @lc app=leetcode.cn id=98 lang=cpp
 *
 * [98] 验证二叉搜索树
 */

// @lc code=start
/**
 * 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* pre = nullptr;//记录前一个节点的状态
    bool isValidBST(TreeNode* root) {
        //空树是二叉平衡树
        if(root == nullptr)
            return true;   
        //左     
        bool left = isValidBST(root->left);
        //中
        if(pre != nullptr && root->val <= pre->val)
            return false;
        else
            pre = root;
        //右
        bool right = isValidBST(root->right);
        return left && right;
    }
};
// @lc code=end

非递归代码

/*
 * @lc app=leetcode.cn id=98 lang=cpp
 *
 * [98] 验证二叉搜索树
 */

// @lc code=start
/**
 * 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) {
        TreeNode* pre = nullptr;//记录前一个节点的状态
        stack<TreeNode*> st;
        //空树是二叉平衡树
        if(root == nullptr)
            return true;   
        st.push(root);
        while(!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();
            if(node == nullptr)
            {
                node = st.top();
                st.pop();
                if(pre != nullptr && node->val <= pre->val)
                    return false;
                else
                    pre = node;
            }
            else
            {
                if(node->right != nullptr) st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if(node->left != nullptr) st.push(node->left);
            }
        }
        return true;
    }
};
// @lc code=end
Jasmine-Lily
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法系列——合并二叉树(Merge Two Binary Trees)
BridgeGeorge
03-21 1894
题目 题目链接：https://leetcode-cn.com/problems/merge-two-binary-trees 给你两棵二叉树： root1 和 root2 。 想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。 返回合并后的二叉树。 注意: 合并过程必须从两个树的根节点开始。 思路 应用
代码随想录算法训练营第20天｜654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树
qq_33269525的博客
10-17 168
对于二叉搜索树的题优先考虑中序遍历。
js 树形结构数据合并
来了波，兄嘚
08-17 2138
需求：合并后面的树形数据到下标0的对象里面 原数组 let RawData = [ { dataList: [ { indicatorId: 1, value0: 1, children: { indicatorId: 2, value0: 2, }, }, { indicator
力扣：合并二叉树java
qq_42325147的博客
10-28 486
力扣：合并二叉树java
LeetCoed617：合并二叉树
46426906的博客
11-03 243
给你两棵二叉树： root1 和 root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意: 合并过程必须从两个树的根节点开始。
js数组操作，两个数组对比合并
weixin_47278755的博客
09-13 219
【代码】js数组操作，两个数组对比合并。
代码随想录算法训练营Day20| 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索 、98.验证二叉搜索树
wuhuqifei123的博客
12-26 103
代码随想录算法训练Day20
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
php-leetcode题解之合并二叉树.zip
06-09
在IT领域，尤其是在编程和算法学习中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程挑战题目，帮助开发者提升技能并准备面试。本压缩包文件"php-leetcode题解之合并二叉树.zip"显然是关于PHP语言实现的...
leetcode–617. 合并二叉树
01-20
题目"合并二叉树"来源于LeetCode的第617题，它要求我们将两个二叉树合并成一个新的二叉树。合并的原则是如果两个节点在重叠位置，它们的值相加作为合并后节点的新值。如果某个位置只有一个节点存在，则这个节点直接...
php-leetcode题解之二叉树的最大深度.zip
06-08
在本压缩包“php-leetcode题解之二叉树的最大深度.zip”中，主要涵盖了使用PHP语言解决LeetCode上的一个经典算法问题——“二叉树的最大深度”。LeetCode是一个在线平台，提供了各种编程挑战，旨在提升程序员的技能...
算法入门-合并二叉树
weixin_63434993的博客
01-24 581
算法入门-合并二叉树(树的先序遍历+深度优先搜索)
leetcode 617. 合并二叉树 【树】【递归】
Jessica的博客
11-13 237
题目： 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。 示例 1: 输入: Tree 1 Tree 2 ...
【LeetCode】617. 合并二叉树（js实现/递归）
在热爱技术的路上一直前行。
05-12 304
1、题目 617. 合并二叉树 - 力扣（LeetCode） 2、实现 （1）思路 （2）代码 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val) * this.left = (left===undefined ? null : left) * this.right =
617. 合并二叉树、Leetcode的Go实现
01-24 583
博客主页：🏆看看是李XX还是李歘歘🏆 🌺每天分享一些包括但不限于计算机基础、算法等相关的知识点🌺 💗点关注不迷路，总有一些📖知识点📖是你想要的💗 ⛽️今天的内容是Leetcode剑指 Offer 39. 数组中出现次数超过一半的数字⛽️💻💻💻 617. 合并二叉树 给你两棵二叉树： root1 和 root2 。 想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个...
每日一题算法：2020年9月23日 [合并二叉树] mergeTrees
I12XXXXXLbull的博客
09-23 308
2020年9月23日 合并二叉树 mergeTrees /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public TreeNode mergeTrees(Tree
leetcode : mergeTrees（递归）
Reid__的博客
08-29 554
题：输入两颗二叉树，将它们合成为一颗二叉树，合成规则如下， The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tr
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 190
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
C++二叉树详解：LeetCode刷题全攻略
"C/C++二叉树宝典（来源于carl）"是一份全面深入的教程，专注于二叉树在C++编程语言中的应用，特别是与LeetCode等在线编程平台上的算法题目的关联。这份资源涵盖了二叉树的基本概念、数据结构、遍历方法（如前序、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jasmine-Lily

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

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

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

打赏作者

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

抵扣说明：

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

余额充值