算法学习——LeetCode力扣二叉树篇6
算法学习——LeetCode力扣二叉树篇6
617. 合并二叉树
617. 合并二叉树 - 力扣（LeetCode）
描述
给你两棵二叉树： 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] 内
- -104 <= Node.val <= 104
代码解析
/**
* 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* get_merge_tree(TreeNode* root1, TreeNode* root2)
{
if(root1 == nullptr && root2 == nullptr) return nullptr;
else if(root1 != nullptr && root2 == nullptr) return root1;
else if(root1 == nullptr && root2 != nullptr) return root2;
TreeNode* new_root = new TreeNode;
//合并树的值
new_root->val = root1->val + root2->val;
new_root->left = get_merge_tree(root1->left , root2->left);
new_root->right = get_merge_tree(root1->right , root2->right);
return new_root;
}
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
if(root1 == nullptr && root2 == nullptr) return nullptr;
else if(root1 != nullptr && root2 == nullptr) return root1;
else if(root1 == nullptr && root2 != nullptr) return root2;
return get_merge_tree(root1 ,root2);
}
};
700. 二叉搜索树中的搜索
700. 二叉搜索树中的搜索 - 力扣（LeetCode）
描述
给定二叉搜索树（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 <= 107
- root 是二叉搜索树
- 1 <= val <= 107
代码解析
/**
* 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* new_root ;
void get_subtree(TreeNode* cur, int target)
{
if(cur==nullptr) return;
if(cur->val == target)
{
new_root = cur;
return;
}
get_subtree(cur->left , target) ;
get_subtree(cur->right , target);
}
TreeNode* searchBST(TreeNode* root, int val) {
if(root==nullptr) return nullptr;
get_subtree(root,val);
return new_root;
}
};
98. 验证二叉搜索树
98. 验证二叉搜索树 - 力扣（LeetCode）
描述
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例
示例 1：
输入：root = [2,1,3]
输出：true
示例 2：
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。
提示
- 树中节点数目范围在[1, 104] 内
- -231 <= Node.val <= 231 - 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:
//记录上一个点
TreeNode* pre = nullptr;
bool judge_tree(TreeNode* cur)
{
if(cur==nullptr) return true;
bool left_val = judge_tree(cur->left);
//当前点应该比上一个大，如果小发生错误
if(pre != nullptr && cur->val <= pre->val) return false;
//更新当前点
pre = cur;
bool right_val = judge_tree(cur->right);
return left_val&right_val;
}
bool isValidBST(TreeNode* root) {
if(root==nullptr) return true;
return judge_tree(root);
}
};
单层递归
/**
* 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 judge_tree(TreeNode* cur)
{
if(cur==nullptr) return true;
bool left_val = judge_tree(cur->left);
//当前点应该比上一个大，如果小发生错误
if(pre != nullptr && cur->val <= pre->val) return false;
//更新当前点
pre = cur;
bool right_val = judge_tree(cur->right);
return left_val&right_val;
}
bool isValidBST(TreeNode* root) {
if(root==nullptr) return true;
return judge_tree(root);
}
};
530. 二叉搜索树的最小绝对差
530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
描述
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。
示例
示例 1：
输入：root = [4,2,6,1,3]
输出：1
示例 2：
输入：root = [1,0,48,null,null,12,49]
输出：1
提示
- 树中节点的数目范围是 [2, 104]
- 0 <= Node.val <= 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 {
public:
int pre_val = INT_MIN , diff_val = INT_MAX;
void min_diff(TreeNode* cur)
{
if(cur==nullptr) return ;
min_diff(cur->left);
if(pre_val != -1 && ( cur->val - pre_val ) < diff_val) diff_val = cur->val - pre_val;
pre_val = cur->val;
min_diff(cur->right);
}
int getMinimumDifference(TreeNode* root) {
if(root==nullptr) return 0;
min_diff(root);
return diff_val;
}
};
501. 二叉搜索树中的众数
501. 二叉搜索树中的众数 - 力扣（LeetCode）
描述
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树
示例
示例 1：
输入：root = [1,null,2,2]
输出：[2]
示例 2：
输入：root = [0]
输出：[0]
提示
- 树中节点的数目在范围 [1, 104] 内
- -105 <= Node.val <= 105
代码解析
任意二叉树map排序版
先遍历树，然后记录到map中。
之后将map存到vector中，因为map无法排序
对vector中pair的value排序
最后取最大的
/**
* 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:
//谓词，排序pair vector
class compare
{
public:
bool operator() (pair<int,int>p1 , pair<int,int>p2)
{
return p1.second > p2.second;
}
};
unordered_map<int,int>my_map;
//递归遍历
void tarvelsal(TreeNode* cur)
{
if(cur==nullptr) return;
tarvelsal(cur->left);
my_map[cur->val]++;
tarvelsal(cur->right);
}
vector<int> findMode(TreeNode* root) {
vector<pair<int,int>> nums;
vector<int> result;
tarvelsal(root);
//map复制到vector
for(auto it:my_map)
{
nums.push_back(pair(it.first , it.second));
}
sort(nums.begin() , nums.end() , compare());
//找最大的
for(int i=0 ; i<nums.size() ; i++)
{
if(nums[i].second == nums[0].second ) result.push_back(nums[i].first);
}
return result;
}
};
二叉搜索树
/**
* 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 count = 0;
//最大值重复次数
int max_count = 0;
vector<int> result;
TreeNode* pre = nullptr;
//中序递归，二叉搜索树是从小到达排序
void max_count_tree(TreeNode* cur)
{
if(cur == nullptr) return ;
max_count_tree(cur->left);
//如果当前次数是0，则是根节点，记录次数为1
if(count==0) count=1;
//如果当前值和旧值相同，次数加1
else if(count!=0 && pre->val == cur->val) count++;
//如果次数不为零，又发现当前值和旧值不同，则遇到新值。复位记录次数为1
else count =1;
//更新旧点
pre = cur;
//如果当前迭代次数和最大次数相同，此值加入结果
if(count == max_count)
{
result.push_back(cur->val);
}
//如果当前次数大于之前的最大次数，则更新结果
//之前的旧结果要清除，重新添加
if(count > max_count)
{
max_count = count;
result.clear();
result.push_back(cur->val);
}
max_count_tree(cur->right);
}
vector<int> findMode(TreeNode* root) {
max_count_tree(root);
return result;
}
};