_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
递归地构建:
- 创建一个根节点,其值为
nums
中的最大值。 - 递归地在最大值 左边 的 子数组前缀上 构建左子树。
- 递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 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