代码随想录训练营第22天|LeetCode 235.二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点

忆昔z

已于 2022-11-16 13:00:31 修改

阅读量100

点赞数

分类专栏：代码随想录训练营文章标签： leetcode 算法数据结构

于 2022-11-16 11:55:59 首次发布

本文链接：https://blog.csdn.net/qq_70244454/article/details/127878054

版权

代码随想录训练营专栏收录该内容

60 篇文章 2 订阅

订阅专栏

参考

这个题可以和之前的二叉树的最近公共祖先那题一样的思路去做，但是这个题可以利用二叉搜索树的性质简化搜索过程。根据二叉搜索树的性质，左节点数值 < 中间节点数值 < 右节点数值，因此公共节点的数值一定在 [p->val,q->val] 区间内（假设p->val < q->val），注意这里是左闭右闭，因此只要遍历二叉树，找到数值在 [p->val,q->val] 区间之内的节点即可，可以使用任一种遍历顺序。

确定递归函数的参数和返回值：
参数：根节点root，两个节点p和q
返回值：TreeNode类型，即返回最近公共节点

TreeNode* traversal(TreeNode* root, TreeNode* a, TreeNode* b);

确定递归终止条件：当某一个节点的数值在[p,q]内时即可返回，因为已经找到了最近公共公共祖先

if(root->val >= a->val && root->val <= b->val) return root;

确定单层递归逻辑：因为二叉搜索树是有序的，所以每次只需要沿着一条边搜索就可以了（假设p->val < q->val）。如果当前节点的数值比p和q都要大，就往左子树遍历，否则就往右子树遍历，注意，当前节点在区间内的情况在前面已经返回了。

TreeNode* node;
if(root->val > a->val && root->val > b->val) 
    node = traversal(root->left,a,b);
else
    node = traversal(root->right,a,b);
return node;

完整的代码实现如下：

class Solution {
public:
    TreeNode* traversal(TreeNode* root, TreeNode* a, TreeNode* b)
    {
        if(root->val >= a->val && root->val <= b->val) return root;
        TreeNode* node;
        if(root->val > a->val && root->val > b->val) 
            node = traversal(root->left,a,b);
        else
            node = traversal(root->right,a,b);
        return node;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr) return nullptr;
        TreeNode* a = (p->val < q->val) ? p : q; 
        TreeNode* b = (p->val < q->val) ? q : p; 
        return traversal(root,a,b);
    }
};

题目二：LeetCode 701.二叉搜索树中的插入操作

这个题题目说可以返回任意一种可行的树结构，所以返回最简单的一种就可以了。最简单的一种是在空节点位置处插入，从根节点开始搜索，当找到某一个节点满足下列条件时插入节点：若该节点左节点为空，且val小于当前节点数值，则将新节点作为该节点的左节点；若该节点的右节点为空，且val大于当前节点数值，则将新节点作为该节点的右节点。

确定递归函数的参数和返回值
参数：根节点root，新插入节点的数值val
返回值：无，在递归函数中没有返回值，根节点的返回和只有根节点的情况另做处理。

void traversal(TreeNode* root,int val);

确定递归终止条件：当找到满足插入位置时，将新节点插入然后返回，结束递归

if(root->left == nullptr && val < root->val){
	TreeNode* node = new TreeNode(val);
    root->left = node;
    return;
}
else if(root->right == nullptr && val > root->val){
    TreeNode* node = new TreeNode(val);
    root->right = node;
    return;
}

确定单层递归逻辑：如果val < root->val，就往左子树遍历；如果val > root->val，就往右子树遍历

 if(val < root->val) traversal(root->left,val);
        if(val > root->val) traversal(root->right,val);

完整的代码实现如下：

class Solution {
public:
    void traversal(TreeNode* root,int val){
        if(root->left == nullptr && val < root->val){
            TreeNode* node = new TreeNode(val);
            root->left = node;
            return;
        }
        else if(root->right == nullptr && val > root->val){
            TreeNode* node = new TreeNode(val);
            root->right = node;
            return;
        }

        if(val < root->val) traversal(root->left,val);
        if(val > root->val) traversal(root->right,val);
    }

    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr){
            TreeNode *node = new TreeNode(val);
            return node;
        }
        traversal(root,val);
        return root;
    }
};

上面的递归函数是没有返回值的，当然也可以返回值，递归函数返回新节点，整体实现会精简一些。代码如下：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == nullptr){
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if(val < root->val) root->left = insertIntoBST(root->left,val);
        if(val > root->val) root->right = insertIntoBST(root->right,val);
        return root;
    }
};

题目三：LeetCode 450.删除二叉搜索树中的节点

确定递归函数的参数和返回值
参数：根节点root，数值key
返回值：返回删除的节点

TreeNode* deleteNode(TreeNode* root, int key);

确定递归终止条件：当传入的节点为空时，说明没有找到要删除的节点，可以返回了。

if(root == nullptr) return nullptr;

确定单层递归逻辑
如果没有找到删除的节点，就不需要做任何操作，最终直接返回原来的根节点就可以了；如果找到了要删除的节点，需要考虑以下的几种情况：

第一种情况：左右孩子都为空（叶子节点），直接删除节点，返回NULL为根节点
第二种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
第三种情况：第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
第四种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

这几种情况中，最难理解的是第四种，下面做简单说明。
在这里插入图片描述
如图所示，如果删除节点7，那么删除节点的左子树就是以节点5为根节点的子树，删除节点的右子树是以节点9为根节点的子树，删除节点的右子树的最左面节点就是节点8，因此将节点5为根节点的子树作为节点8的左子树后得到的树结构如右上图所示。因为原来的节点为5和节点9分别是节点7的左右节点，因此一定可以保证以节点5为根节点的子树的所有节点一定比以节点9为根节点的子树的所有节点小，所以放到将节点5为根节点的子树放到节点8的左子树上后，一定能保证新的二叉树一定是二叉搜索树。

if (root->val == key) {
    // 第一种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
    // 第二种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
    if (root->left == nullptr) return root->right;
    // 第三种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
    else if (root->right == nullptr) return root->left;
    // 第四种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置，并返回删除节点右孩子为新的根节点。
    else {
        TreeNode* cur = root->right; // 找右子树最左面的节点
        while(cur->left != nullptr) {
            cur = cur->left;
        }
        cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
        TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
        root = root->right;     // 返回旧root的右孩子作为新root
        delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
        return root;
    }
}

这里返回新的根节点后作为上一个节点的左节点或者右节点：

if (root->val > key) root->left = deleteNode(root->left, key);
if (root->val < key) root->right = deleteNode(root->right, key);
return root;

完整的代码实现如下：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
            if(root == nullptr) return nullptr;
            if (root->val == key) {
            // 第一种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
            // 第二种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            if (root->left == nullptr) return root->right;
            // 第三种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
            else if (root->right == nullptr) return root->left;
            // 第四种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置，并返回删除节点右孩子为新的根节点。
            else{
                    TreeNode* cur = root->right; // 找右子树最左面的节点
                    while(cur->left != nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
                root = root->right;     // 返回旧root的右孩子作为新root
                delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
                return root;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};