_19LeetCode代码随想录算法训练营第十九天-C++二叉树 | 235.二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点
题目列表
- 235.二叉搜索树的最近公共祖先
- 701.二叉搜索树中的插入操作
- 450.删除二叉搜索树中的节点
235.二叉搜索树的最近公共祖先
代码随想录地址:https://programmercarl.com/0235.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%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 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
说明:
- 所有节点的值都是唯一的。
- p、q 为不同节点且均存在于给定的二叉搜索树中。
整体思路
从上往下遍历,只要遍历到符合条件的node,那么该node就是最近公共祖先。
原因是二叉搜索树的特性。
代码
递归代码
/*
* @lc app=leetcode.cn id=235 lang=cpp
*
* [235] 二叉搜索树的最近公共祖先
*/
// @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 {
private:
TreeNode* traverse(TreeNode* node, TreeNode* p, TreeNode* q)
{
if(node == nullptr)
return node;
//只会有四种情况
//node->val > p->val && node->val > q->val
//node->val < p->val && node->val < q->val
//node->val < p->val && node->val > q->val
//node->val > p->val && node->val < q->val
//后面两种情况都是符合要求的
if(node->val > p->val && node->val > q->val)
{
TreeNode* left = traverse(node->left, p, q);
if(left != nullptr)
return left;
}
else if(node->val < p->val && node->val < q->val)
{
TreeNode* right = traverse(node->right, p, q);
if(right != nullptr)
return right;
}
else
return node;
return node; //这一句完全就是因为力扣傻
}
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
return traverse(root, p, q);
}
};
// @lc code=end
迭代代码
/*
* @lc app=leetcode.cn id=235 lang=cpp
*
* [235] 二叉搜索树的最近公共祖先
*/
// @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) {
TreeNode* cur = root;
while(cur != nullptr)
{
if(cur->val > p->val && cur->val > q->val)
cur = cur->left;
else if(cur->val < p->val && cur->val < q->val)
cur = cur->right;
else
return cur;
}
return cur;
}
};
// @lc code=end
701.二叉搜索树中的插入操作
代码随想录地址:https://programmercarl.com/0701.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E6%8F%92%E5%85%A5%E6%93%8D%E4%BD%9C.html
题目
给定二叉搜索树(BST)的根节点 root
和要插入树中的值 value
,将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ,新值和原始二叉搜索树中的任意节点值都不同。
注意,可能存在多种有效的插入方式,只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。
示例 1:
输入:root = [4,2,7,1,3], val = 5
输出:[4,2,7,1,3,5]
解释:另一个满足题目要求可以通过的树是:
示例 2:
输入:root = [40,20,60,10,30,50,70], val = 25
输出:[40,20,60,10,30,50,70,null,null,25]
示例 3:
输入:root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出:[4,2,7,1,3,5]
提示:
- 树中的节点数将在[0, 1 0 4 10^4 104]范围内。
- - 1 0 8 10^8 108 <= Node.val <= 1 0 8 10^8 108
- 所有值
Node.val
是 独一无二 的。 - - 1 0 8 10^8 108 <= val <= 1 0 8 10^8 108
- 保证
val
在原始BST中不存在。
整体思路
一定可以找到叶子节点,将该节点插入树。
代码
递归代码
/*
* @lc app=leetcode.cn id=701 lang=cpp
*
* [701] 二叉搜索树中的插入操作
*/
// @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:
TreeNode* insert(TreeNode* node, int val)
{
//如果当前node是nullptr,那么直接创建新节点返回
if(node == nullptr)
return new TreeNode(val);
if(node->val > val)
node->left = insert(node->left, val);
if(node->val < val)
node->right = insert(node->right, val);
return node;
}
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
return insert(root, val);
}
};
// @lc code=end
迭代代码
/*
* @lc app=leetcode.cn id=701 lang=cpp
*
* [701] 二叉搜索树中的插入操作
*/
// @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* insertIntoBST(TreeNode* root, int val) {
//如果root为空,则直接创建一个新节点返回即可
if(root == nullptr)
return new TreeNode(val);
TreeNode* cur = root;
TreeNode* pre;//用于存储前一个节点,以备将val作为pre的孩子
//这里的目的就是找到前一个节点
while(cur)
{
pre = cur;
if(cur->val > val)
cur = cur->left;
else
cur = cur->right;
}
//如果前一个节点的值大于val,则val可以作为pre的左孩子
if(pre->val > val)
pre->left = new TreeNode(val);
else//否则,作为pre的右孩子
pre->right = new TreeNode(val);
return root;
}
};
// @lc code=end
450.删除二叉搜索树中的节点
代码随想录地址:https://programmercarl.com/0450.%E5%88%A0%E9%99%A4%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html
题目
给定一个二叉搜索树的根节点 root 和一个值 key,删除二叉搜索树中的 key 对应的节点,并保证二叉搜索树的性质不变。返回二叉搜索树(有可能被更新)的根节点的引用。
一般来说,删除节点可分为两个步骤:
- 首先找到需要删除的节点;
- 如果找到了,删除它。
示例 1:
输入:root = [5,3,6,2,4,null,7], key = 3
输出:[5,4,6,2,null,null,7]
解释:给定需要删除的节点值是 3,所以我们首先找到 3 这个节点,然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。
示例 2:
输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点
示例 3:
输入: root = [], key = 0
输出: []
提示:
- 节点数的范围 [0, 1 0 4 10^4 104].
- - 1 0 5 10^5 105 <= Node.val <= 1 0 5 10^5 105
- 节点值唯一
root
是合法的二叉搜索树- - 1 0 5 10^5 105 <= key <= 1 0 5 10^5 105
进阶: 要求算法时间复杂度为 O(h),h 为树的高度。
整体思路
稍微有点复杂:
存在五种情况:
- 第一种情况:没找到删除的节点,遍历到空节点直接返回了
- 找到删除的节点
- 第二种情况:左右孩子都为空(叶子节点),直接删除节点, 返回NULL为根节点
- 第三种情况:删除节点的左孩子为空,右孩子不为空,删除节点,右孩子补位,返回右孩子为根节点
- 第四种情况:删除节点的右孩子为空,左孩子不为空,删除节点,左孩子补位,返回左孩子为根节点
- 第五种情况:左右孩子节点都不为空,则将删除节点的左子树头结点(左孩子)放到删除节点的右子树的最左面节点的左孩子上,返回删除节点右孩子为新的根节点。
代码
递归代码
/*
* @lc app=leetcode.cn id=450 lang=cpp
*
* [450] 删除二叉搜索树中的节点
*/
// @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* deleteNode(TreeNode* node, int key) {
//没有找到key
if(node == nullptr)
return nullptr;
//找到了key
if(node->val == key)
{
//当前node的左子树为空,右子树为空
if(node->right == nullptr && node->left == nullptr)
{
delete node;//释放内存
return nullptr;
}
//当前node左子树为空,右子树不为空
else if(node->right != nullptr && node->left == nullptr)
{
TreeNode* cur = node->right;
delete node;
return cur;
}
//当前节点左子树不为空,右子树为空
else if(node->left != nullptr && node->right == nullptr)
{
TreeNode* cur = node->left;
delete node;
return cur;
}
//当前节点左右子树都不为空
else
{
//使用当前节点的右子树替换被删除节点
TreeNode* cur = node->right;
//将node的左子树放到右子树的最左节点
while(cur->left != nullptr)
cur = cur->left;//找到右子树的最左节点
cur->left = node->left;
//cur变了,指向的元素不再是node的右孩子了,所以直接返回是不对的,之前在这里出错了
cur = node->right;
delete node;
return cur;
}
}
if(node->val > key) node->left = deleteNode(node->left, key);
if(node->val < key) node->right = deleteNode(node->right, key);
return node;
}
};
// @lc code=end
迭代代码
稍微有点复杂
/*
* @lc app=leetcode.cn id=450 lang=cpp
*
* [450] 删除二叉搜索树中的节点
*/
// @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:
//找到要删除的节点后删除节点的逻辑
//返回值为替换被删除节点的地址
TreeNode* deleteOneNode(TreeNode* node)
{
//为叶子节点
if(node->left == nullptr && node->right == nullptr)
{
delete node;
return nullptr;
}//左孩子不为空,右孩子为空
else if(node->left != nullptr && node->right == nullptr)
{
TreeNode* cur = node->left;
delete node;
return cur;
}//左孩子为空,右孩子不为空
else if(node->left == nullptr && node->right != nullptr)
{
TreeNode* cur = node->right;
delete node;
return cur;
}
else//左孩子和右孩子都不为空
{
//使用右孩子顶替被删节点,将左孩子加到右孩子的最左孩子
TreeNode* cur = node->right;
while(cur->left != nullptr)
cur = cur->left;
cur->left = node->left;
cur = node->right;
delete node;
return cur;
}
}
public:
TreeNode* deleteNode(TreeNode* root, int key) {
//如果被删节点为空的话,直接返回空
if(root == nullptr)
return root;
//如果被删节点就是根节点,则直接删除根节点,返回顶替节点
if(root->val == key)
return deleteOneNode(root);
//这里是在找到被删节点和被删节点的父亲
TreeNode* node = root;
TreeNode* pre;
while(node != nullptr)
{
if(node->val == key)
break;
pre = node;
if(node->val > key)
node = node->left;
else
node = node->right;
}
//如果找到了被删节点,就执行以下操作
if(node != nullptr)
{
//如果被删节点是pre的左孩子
if(pre->left != nullptr && pre->left->val == key)
pre->left = deleteOneNode(node);
//如果被删节点是pre节点的右孩子
if(pre->right != nullptr && pre->right->val == key)
pre->right = deleteOneNode(node);
}
//返回根节点
return root;
}
};
// @lc code=end
普通二叉树的删除方式
就是使用右子树最左面的值去替换被删除节点的值。
class Solution {
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if (root == nullptr) return root;
if (root->val == key) {
if (root->right == nullptr) { // 这里第二次操作目标值:最终删除的作用
return root->left;
}
TreeNode *cur = root->right;
while (cur->left) {
cur = cur->left;
}
swap(root->val, cur->val); // 这里第一次操作目标值:交换目标值其右子树最左面节点。
}
root->left = deleteNode(root->left, key);
root->right = deleteNode(root->right, key);
return root;
}
};