_18LeetCode代码随想录算法训练营第十八天-C++二叉树 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236.二叉树的最近公共祖先
_18LeetCode代码随想录算法训练营第十八天-C++二叉树 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236.二叉树的最近公共祖先
题目列表
- 530.二叉搜索树的最小绝对差
- 501.二叉搜索树中的众数
- 236.二叉树的最近公共祖先
530.二叉搜索树的最小绝对差
代码随想录地址：https://programmercarl.com/0530.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E7%BB%9D%E5%AF%B9%E5%B7%AE.html
题目
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。
示例 1：
输入：root = [4,2,6,1,3]
输出：1
示例 2：
输入：root = [1,0,48,null,null,12,49]
输出：1
提示：
- 树中节点的数目范围是 [2, 1 0 4 10^4 104]
- 0 <= Node.val <= 1 0 5 10^5 105
**注意：**本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同
代码
递归代码
/*
* @lc app=leetcode.cn id=530 lang=cpp
*
* [530] 二叉搜索树的最小绝对差
*/
// @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:
int res = INT_MAX;
TreeNode* pre = nullptr;
void traverse(TreeNode* node)
{
if(node == nullptr)
return;
//左
traverse(node->left);
//中
if(pre != nullptr)
res = min(res, node->val - pre->val);
pre = node;//记录前一个元素
//右
traverse(node->right);
}
public:
int getMinimumDifference(TreeNode* root) {
traverse(root);
return res;
}
};
// @lc code=end
非递归代码-迭代代码
/*
* @lc app=leetcode.cn id=530 lang=cpp
*
* [530] 二叉搜索树的最小绝对差
*/
// @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:
int getMinimumDifference(TreeNode* root) {
int res = INT_MAX;
TreeNode* pre = nullptr;
stack<TreeNode*> st;
if(root != nullptr)
st.push(root);
while(!st.empty())
{
TreeNode* node = st.top();
st.pop();
if(node == nullptr)
{
node = st.top();
st.pop();
if(pre != nullptr)
res = min(res, node->val - pre->val);
pre = node;
}
else
{
if(node->right) st.push(node->right);
st.push(node);
st.push(nullptr);
if(node->left) st.push(node->left);
}
}
return res;
}
};
// @lc code=end
501.二叉搜索树中的众数
代码随想录地址：https://programmercarl.com/0501.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E4%BC%97%E6%95%B0.html
题目
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
- 结点左子树中所含节点的值 小于等于 当前节点的值
- 结点右子树中所含节点的值 大于等于 当前节点的值
- 左子树和右子树都是二叉搜索树
示例 1：
输入：root = [1,null,2,2]
输出：[2]
示例 2：
输入：root = [0]
输出：[0]
提示：
- 树中节点的数目在范围 [1, 1 0 4 10^4 104] 内
- - 1 0 5 10^5 105 <= Node.val <= 1 0 5 10^5 105
**进阶：**你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）
代码
是写的递归的代码，非递归的就是一个中序遍历，然后对当前节点做一些处理，因此没写。
/*
* @lc app=leetcode.cn id=501 lang=cpp
*
* [501] 二叉搜索树中的众数
*/
// @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:
int maxcount = INT_MIN;
int count = 0;
vector<int> res;
TreeNode* pre = nullptr;
void traverse(TreeNode* node)
{
if(node == nullptr)
return;
//左
traverse(node->left);
//中
//当当前元素与前一个元素相等，则将count++
if(pre != nullptr && node->val == pre->val)
count++;
//当当前元素与前一个元素不相等，则将count置为1
if(pre == nullptr || node->val != pre->val)
count = 1;
pre = node;//记录前一个元素
//当count == maxcount时，要将当前节点入vector
if(maxcount == count)
res.push_back(node->val);
//当count > maxcount时，要将之前的节点清空并将当前节点存起来
if(maxcount < count)
{
res.clear();
res.push_back(node->val);
maxcount = count;
}
traverse(node->right);
}
public:
vector<int> findMode(TreeNode* root) {
maxcount = INT_MIN;
count = 0;
pre = nullptr;
res.clear();
traverse(root);
return res;
}
};
// @lc code=end
236.二叉树的最近公共祖先
代码随想录地址：https://programmercarl.com/0236.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88.html
题目
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 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, 1 0 5 10^5 105] 内。
- - 1 0 9 10^9 109 <= Node.val <= 1 0 9 10^9 109
- 所有
Node.val互不相同。 p != qp和q均存在于给定的二叉树中。
整体思路
情况1
情况2
情况1的处理办法把情况2包括了，因为p和q一定存在。
代码
没有迭代法的解法，因为迭代法不适合回溯的过程。
/*
* @lc app=leetcode.cn id=236 lang=cpp
*
* [236] 二叉树的最近公共祖先
*/
// @lc code=start
/**
* 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) {
//如果root为空，那么直接返回空
if(root == nullptr)
return root;
//如果root等于p或q，那么返回root
if(root == p || root == q)
return root;
//左
TreeNode* left = lowestCommonAncestor(root->left, p, q);
//右
TreeNode* right = lowestCommonAncestor(root->right, p, q);
//中
if(left != nullptr && right != nullptr)
return root;
else if(left != nullptr && right == nullptr)
return left;
else if(left == nullptr && right != nullptr)
return right;
else//如果左子树和右子树都为空
return nullptr;
}
};
// @lc code=end