代码随想录第二十二天 | 二叉搜索树：最近公共祖先（递归/迭代：leetcode 235），插入操作（递归/迭代：leetcode 701），删除节点（递归/迭代：leetcode 450）

Asher Gu

已于 2024-04-09 13:25:53 修改

阅读量80

点赞数 1

分类专栏： leetcode c++ 文章标签： leetcode 算法 c++ 数据结构

于 2023-10-04 21:10:46 首次发布

本文链接：https://blog.csdn.net/AsherGu/article/details/133558199

版权

leetcode c++ 专栏收录该内容

52 篇文章 1 订阅

订阅专栏

1、二叉搜索树最近公共祖先

1.1 leetcode 235：递归

按照上一节leetcode 236思路代码，第一遍，普通二叉树也适用

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr || 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 right;
        }
        else if(left != nullptr && right == nullptr) {
            return left;
        }
        return nullptr;
    }
};

利用二叉搜索树的有序性思路

根据leetcode 236，利用回溯从底向上搜索，遇到一个节点的左（右）子树里有p，右（左）子树里有q，那么当前节点就是最近公共祖先
那么本题是二叉搜索树，二叉搜索树是有序的，那得好好利用一下这个特点

在有序树里，如何判断一个节点的左（右）子树里有p，右（左）子树里有q呢

因为是有序树，所有如果中间节点是 q 和 p 的公共祖先，那么 中节点的数组一定是在 [p, q]（[q, p]）区间（注意一定是闭区间，因为相等的时候就是leetcode 236中的情况二的时候，即p/q在所找的区间的根节点上）的。即中节点 > p && 中节点 < q 或者中节点 > q && 中节点 < p
那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是q 和 p的公共祖先

那问题来了，一定是最近公共祖先吗
如图，我们从根节点搜索，第一次遇到 cur节点是数值在[p, q]区间中，即节点5，此时可以说明 p 和 q 一定分别存在于节点 5的左子树和右子树中
证明一定是最近公共祖先
此时节点5是不是最近公共祖先？如果从节点5继续向左遍历，那么将错过成为q的祖先，如果从节点5继续向右遍历则错过成为p的祖先
也可以这样想，假设5节点的子树还有1，9节点的公共祖先，那么1，9节点必须同时小于/大于5节点，显然不成立，所以从根节点出发先序（或者类先序，二叉搜索树有大小关系可以减少遍历的节点数）遍历，第一个在1，9[p, q]之间的节点就是最近公共祖先

所以当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[p, q]区间中，那么cur就是 p和q的最近公共祖先

根据思路写第一遍代码

if((root->val > p->val && root->val < q->val) || (root->val < p->val && root->val > q->val)) {
    return root;
 }

如果用这段代码替换最后的return root，就没考虑到p/q正好是root节点的情况

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr) return root;//别忘了root为空节点的情况
        // if((root->val > p->val && root->val < q->val) || (root->val < p->val && root->val > q->val)) {
        //     return root;
        // }
        // 如果用这段代码替换最后的return root，就没考虑到p/q正好是root节点的情况
        if(root->val < p->val && root->val < q->val) {
            return lowestCommonAncestor(root->right, p, q);
        }
        if(root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        }
        return root;
    }
};

代码随想录思路

递归三部曲如下：
1、确定递归函数返回值以及参数
参数就是当前节点，以及两个结点 p、q
返回值是要返回最近公共祖先，所以是TreeNode *

代码如下：

TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q)

2、确定终止条件
遇到空返回就可以了，代码如下：

if (cur == NULL) return cur;

其实都不需要这个终止条件，因为题目中说了p、q 为不同节点且均存在于给定的二叉搜索树中。也就是说一定会找到公共祖先的，所以并不存在遇到空的情况

3、确定单层递归的逻辑
在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭又闭）
那么如果 cur->val 大于 p->val，同时 cur->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）

代码如下：

if (cur->val > p->val && cur->val > q->val) {
    TreeNode* left = traversal(cur->left, p, q);
    if (left != NULL) {
        return left;
    }
}

如果 cur->val 小于 p->val，同时 cur->val 小于 q->val，那么就应该向右遍历（目标区间在右子树）

if (cur->val < p->val && cur->val < q->val) {
    TreeNode* right = traversal(cur->right, p, q);
    if (right != NULL) {
        return right;
    }
}

在这里调用递归函数的地方，把递归函数的返回值left，直接return
这就涉及到上一讲讲的节如果递归函数有返回值，如何区分要搜索一条边，还是搜索整个树

搜索一条边的写法：

if (递归函数(root->left)) return ;
if (递归函数(root->right)) return ;

搜索整个树写法：

left = 递归函数(root->left);
right = 递归函数(root->right);

left与right的逻辑处理;
本题就是标准的搜索一条边的写法，遇到递归函数的返回值，如果不为空，立刻返回

剩下的情况，就是cur节点在区间（p->val <= cur->val && cur->val <= q->val）或者（q->val <= cur->val && cur->val <= p->val）中，那么cur就是最近公共祖先了，直接返回cur

代码随想录整体代码，跟第一遍代码思路一致

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        } else if (root->val < p->val && root->val < q->val) { // 这里每个if不一定要加else，因为每个语句块都会返回，每次更新本来进去一个语句块（与迭代对比）
            return lowestCommonAncestor(root->right, p, q);
        } else return root;
    }
};

1.2 leetcode 235：迭代

对于二叉搜索树的迭代法，应该在leetcode 700迭代法就了解了
利用其有序性，迭代的方式还是比较简单的，解题思路与递归一致，把二叉搜索树迭代的条件修改一下就行

迭代代码如下：
不管最后会不会到while之外再返回，反正最后总要加一个返回语句

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(root != nullptr) {
            if(root->val > p->val && root->val > q->val) {
                root = root->left;
            }
            else if(root->val < p->val && root->val < q->val) {// 每个if都要加else，每次更新只能进去一个语句块
                root = root->right;
            }
            else {
                return root;
            }
        }
        return root;
    }
};

1.3 leetcode 235：总结

对于二叉搜索树的最近祖先问题，其实要比普通二叉树公共祖先问题leetcode 236简单的多

不用使用回溯，二叉搜索树自带方向性，可以方便的从上向下查找目标区间，遇到目标区间内的节点，直接返回

最后给出了对应的迭代法，二叉搜索树的迭代法甚至比递归更容易理解，也是因为其有序性（自带方向性），按照目标区间找就行了

2、二叉搜索树中的插入操作

第一遍代码

利用有序性找到对应叶子节点或者左空 / 右空节点，插入即可
注意cur可能为空指针的(插入空树)，而且cur->left 与 cur->right 同时为空也符合逻辑
最后一个 return：处理单独一个节点插入空树的情况，如[] 5，插入后为[5]

class Solution {
public:
//利用有序性找到对应叶子节点，插入即可
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        TreeNode* tmp = new TreeNode(val);
        TreeNode* cur = root;
        //注意cur可能为空指针的(插入空树)，而且cur->left与cur->right同时为空也符合逻辑
        while(cur != nullptr) {
            if(cur->val < val && cur->right != nullptr) {
                cur = cur->right;
            }
            else if(cur->val < val) {
            //即if(cur->val < val && cur->right == nullptr)，插入节点
                cur->right = tmp;
                return root;

            }
            if(cur->val > val && cur->left != nullptr) {
                cur = cur->left;
            }
            if(cur->val > val && cur->left == nullptr) {
                cur->left = tmp;
                return root;
            }
        }
        //处理单独一个节点插入空树的情况，如[] 5，插入后为[5]
        return tmp;
    }
};

可以不考虑题目中提示所说的改变树的结构的插入方式，只要按照二叉搜索树的规则去遍历，遇到空节点就插入节点就可以了

2.1 leetcode 701：递归

递归三部曲：
1、确定递归函数参数以及返回值
参数就是根节点指针，以及要插入元素，这里递归函数要不要有返回值呢
可以有，也可以没有，但递归函数如果没有返回值的话，实现是比较麻烦的，下面也会给出其具体实现代码

有返回值的话，可以利用返回值完成新加入的节点与其父节点的赋值操作（下面会进一步解释）
递归函数的返回类型为节点类型TreeNode *

代码如下：

TreeNode* insertIntoBST(TreeNode* root, int val)

2、确定终止条件
终止条件就是找到遍历的节点为null的时候，就是要插入节点的位置了，并把插入的节点返回
代码如下：

if (root == NULL) {
    TreeNode* node = new TreeNode(val);
    return node;
}

这里把添加的节点返回给上一层，就完成了父子节点的赋值操作了

3、确定单层递归的逻辑
此时要明确，需要遍历整棵树么？
别忘了这是搜索树，遍历整棵搜索树简直是对搜索树的侮辱
搜索树是有方向了，可以根据插入元素的数值，决定递归方向

代码如下：

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

到这里，大家应该能感受到，如何通过递归函数返回值完成了新加入节点的父子关系赋值操作了，下一层将加入节点返回，本层用 root->left 或者 root->right 将其接住并把经过改动的子树的根节点往上一层的根节点给（重要思路，也是添加的节点返回给上一层，就完成了父子节点的赋值操作的原因）

而且对于不遍历整棵树，不像上一题一样通过多个返回来达到只遍历一条边的目的，而是充分利用调用递归函数的条件（if），来确定递归方向（跟迭代一样思路）

整体代码如下：

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

刚刚说了递归函数不用返回值也可以，找到插入的节点位置，直接让其父节点指向插入节点，结束递归，也是可以的，但要多一个记录其父节点的节点

递归函数定义如下：

TreeNode* parent; // 记录遍历节点的父节点
void traversal(TreeNode* cur, int val)

没有返回值，需要记录上一个节点（parent），遇到空节点了，就让parent 左孩子或者右孩子指向新插入的节点。然后结束递归

class Solution {
private:
    TreeNode* parent;
    void traversal(TreeNode* cur, int val) {
        if (cur == NULL) {
            TreeNode* node = new TreeNode(val);
            if (val > parent->val) parent->right = node;
            else parent->left = node;
            return;
        }
        parent = cur;
        if (cur->val > val) traversal(cur->left, val);
        if (cur->val < val) traversal(cur->right, val);
        /*
        如果改成parent一定要用else，以防第一个if过后parent还带着之前的值，会进入下一个if
		if (parent->val > val) traverse(cur->left, val);
        else if (parent->val < val) traverse(cur->right, val);
		*/
        return;
    }

public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {//当加入空树的时候逻辑要相通，实际上后面进了traversal整了一句parent = cur就return了
            root = new TreeNode(val);
        }
        traversal(root, val);
        return root;
    }
};

更麻烦了
根据思路写代码：

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

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

2.2 leetcode 701：迭代

与第一遍代码思路相似，不同的是代码随想录思路是记录一下当前遍历的节点的父节点，这样才能做插入节点的操作，即遍历到空节点再插入，与leetcode 501一样使用记录pre和cur两个指针的技巧

而第一遍代码在遍历到左空/右空（不一定叶子节点，相关插入节点的父节点）就直接插入

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {
            TreeNode* node = new TreeNode(val);
            return node;
        }//直接把加入空树这种情况处理了
        TreeNode* cur = root;
        TreeNode* parent = root; // 这个很重要，需要记录上一个节点，否则无法赋值新节点
        while (cur != NULL) {
            parent = cur;
            if (cur->val > val) cur = cur->left;
            else cur = cur->right;
        }
        TreeNode* node = new TreeNode(val);
        if (val < parent->val) parent->left = node;// 此时是用parent节点的进行赋值
        else parent->right = node;
        return root;
    }
};

没有返回值的

class Solution {
private:
    TreeNode* parent;
    void insert(TreeNode* cur, int val) {
        while (cur != nullptr) {
            parent = cur;
            if (cur->val > val) cur = cur->left;
            else cur = cur->right; // 一定要用else，不然上面移动的cur会影响
        }
        if (parent->val < val) parent->right = new TreeNode(val);
        else parent->left = new TreeNode(val);
        return;
    }
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == nullptr) return new TreeNode(val);
        insert(root, val);
        return root;
    }
};

3、删除二叉搜索树中的节点

思路
搜索树的节点删除要比节点增加复杂的多，有很多情况需要考虑

3.1 leetcode 450：递归

递归三部曲：
1、确定递归函数参数以及返回值
说到递归函数的返回值，在leetcode 701（上一题）中通过递归返回值来加入新节点，这里也可以通过递归返回值删除节点

代码如下：

TreeNode* deleteNode(TreeNode* root, int key)

2、确定终止条件
遇到空返回，其实这也说明没找到删除的节点，遍历到空节点直接返回了

if (root == nullptr) return root;

3、确定单层递归的逻辑
这里就把二叉搜索树中删除节点遇到的情况都搞清楚

有以下五种情况（重要）：

第一种情况：没找到删除的节点，遍历到空节点直接返回了

找到删除的节点
第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点

第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点

第五种情况有点难以理解，看下面动画：
第五种情况的动图代码随想录
动画中的二叉搜索树中，删除元素7，那么删除节点（元素7）的左孩子就是5，删除节点（元素7）的右子树的最左面节点是元素8
将删除节点（元素7）的左孩子放到删除节点（元素7）的右子树的最左面节点（元素8）的左孩子上，就是把5为根节点的子树移到了8的左孩子的位置
要删除的节点（元素7）的右孩子（元素9）为新的根节点

代码如下：

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;
    }
}

这里相当于把新的节点返回给上一层，上一层就要用 root->left 或者 root->right接住，
所以需要有返回值，方便把树连接起来
代码如下：

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) {
            if (root->left == nullptr) return root->right;
            else if (root->right == nullptr) return root->left;
            else {
                TreeNode* tmp = root->right;
                while (tmp->left) {
                    tmp = tmp->left;
                }
                tmp->left = root->left;
                return root->right;
            }
        }
        if (root->val < key) root->right = deleteNode(root->right, key);
        else root->left = deleteNode(root->left, key);
        return root;
    }
};

代码随想录完整代码，多了对被删除节点内存的释放

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root->val == key) {
            // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
            if (root->left == nullptr && root->right == nullptr) {
                ///! 内存释放
                delete root;
                return nullptr;
            }
            // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            else if (root->left == nullptr) {
                auto retNode = root->right;
                ///! 内存释放
                delete root;
                return retNode;
            }
            // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
            else if (root->right == nullptr) {
                auto retNode = root->left;
                ///! 内存释放
                delete root;
                return retNode;
            }
            // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
            // 并返回删除节点右孩子为新的根节点。
            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;
    }
};

3.1.1 普通二叉树的删除方式

这里我在介绍一种通用的删除，普通二叉树的删除方式（没有使用搜索树的特性，遍历整棵树），用交换值的操作来删除目标节点

代码中目标节点（要删除的节点）被操作了两次（如果目标节点没有右子树，直接返回左子树就删除成功了）：
第一次是和目标节点的右子树最左面节点交换
第二次直接被NULL覆盖了

不能直接null，不然万一右子树的最左边节点有右子树也跟着没了
如果不写，因为if(root->right == nullptr)（没有右子树），有右子树会逐渐跟右子树的节点值互换
直至右子树没东西了回到if(root->right == nullptr)的删除逻辑

而且不能有选择性的遍历，即

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

要改成

root->left = deleteNode(root->left, key);
root->right = deleteNode(root->right, key);

因为在第一次交换之后就不是符合搜索树的有序性了，第二次交换再使用有选择性的遍历就找不着交换之后的目标元素了

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;
    }
};

3.2 leetcode 450：迭代

删除节点的迭代法还是复杂一些的，但其本质我在递归法里都介绍了，最关键就是删除节点的操作，其实关于删除，第四种和五种情况两种删除方法可以删除所有节点（左子树为空右子树为空也是一样的），唯一要考虑的是返回回来新的子树节点之后要接到原有子树节点上，所以就要设pre指针指之前的节点

第一遍代码

class Solution {
public:
    TreeNode* deleteSingleNode(TreeNode* target) {
        //只要找到目标节点（没找到null一样）就放入这个函数进行删除
        if(target == nullptr) return target;
        TreeNode* tmp = target->right;
        if(tmp == nullptr) {//if(tmp)是tmp != nullptr
            return target->left;//是target->left不是tmp->left
        }
        while(tmp->left) {
            tmp = tmp->left;
        }
        tmp->left = target->left;
        return target->right;
    }

    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;
        TreeNode* pre = nullptr;
        TreeNode* cur = root;
        while(cur) {
            //为了保证pre指向前一个节点（父节点），下面语句的顺序不能变
            if(cur->val == key) break;
            pre = cur;
            if(cur->val > key) cur = cur->left;
            else  cur = cur->right;
        }
        if(pre == nullptr) {
            return deleteSingleNode(cur);
        }
        if(cur == nullptr) return root;
        //要先处理cur等于nullptr的情况
        if(pre->val > cur->val) pre->left = deleteSingleNode(cur);
        else pre->right = deleteSingleNode(cur);
        return root;
    }
};

代码随想录代码
其判断删除之后的子树插入位置与第一遍代码不同，不需要单独判断cur是否为空指针

class Solution {
private:
    // 将目标节点（删除节点）的左子树放到 目标节点的右子树的最左面节点的左孩子位置上
    // 并返回目标节点右孩子为新的根节点
    // 是动画里模拟的过程
    TreeNode* deleteOneNode(TreeNode* target) {
        if (target == nullptr) return target;
        if (target->right == nullptr) return target->left;
        TreeNode* cur = target->right;
        while (cur->left) {
            cur = cur->left;
        }
        cur->left = target->left;
        return target->right;
    }
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;
        TreeNode* cur = root;
        TreeNode* pre = nullptr; // 记录cur的父节点，用来删除cur
        while (cur) {
            if (cur->val == key) break;
            pre = cur;
            if (cur->val > key) cur = cur->left;
            else cur = cur->right;
        }
        if (pre == nullptr) { // 如果搜索树只有头结点，别忘了处理这种情况，直接返回删去头节点的树
            return deleteOneNode(cur);
        }
        // pre 要知道是删左孩子还是右孩子
        if (pre->left && pre->left->val == key) {
            pre->left = deleteOneNode(cur);
        }
        if (pre->right && pre->right->val == key) {
            pre->right = deleteOneNode(cur);
        }
        return root;
    }
};

同样的思路自己实现

class Solution {
public:
    TreeNode* deleteOneNode(TreeNode* cur) {
        TreeNode* tmp = cur->right;
        if (tmp == nullptr) return cur->left;
        while (tmp->left != nullptr) {
            tmp = tmp->left;
        }
        tmp->left = cur->left;
        return cur->right;
    }

    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return nullptr;
        TreeNode* cur = root;
        TreeNode* pre = root;
        while (cur != nullptr && cur->val != key) {
            pre = cur;
            if (cur->val < key) cur = cur->right;
            else if (cur->val > key) cur = cur->left;
        }
        if (cur == nullptr) return root;
        if (root->val == key) return deleteOneNode(root); // 如果搜索树只有头结点，别忘了处理这种情况，直接返回删去头节点的树
        if (pre->val > key) pre->left = deleteOneNode(cur);
        if (pre->val < key) pre->right = deleteOneNode(cur);
        return root;
    }
};

3.3 leetcode 450：总结

大家会发现二叉搜索树删除节点比增加节点复杂的多

因为二叉搜索树添加节点只需要在叶子上添加就可以的，不涉及到结构的调整，而删除节点操作涉及到结构的调整
这里我们依然使用递归函数的返回值来完成把节点从二叉树中移除的操作

最后也给出了相应的迭代法，就是模拟递归法中的逻辑来删除节点，但需要一个pre记录cur的父节点，方便做删除操作，而且只需要考虑第四和第五种情况，通杀的

Asher Gu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录第二十二天 | 二叉搜索树：最近公共祖先（递归/迭代：leetcode 235），插入操作（递归/迭代：leetcode 701），删除节点（递归/迭代：leetcode 450）

二叉搜索树：寻找最近祖先，插入操作，删除节点（包含普通二叉树的方法）
复制链接

扫一扫