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

最新推荐文章于 2024-11-23 17:42:15 发布

me_llamo

最新推荐文章于 2024-11-23 17:42:15 发布

阅读量686

点赞数 12

文章标签：算法

本文链接：https://blog.csdn.net/weixin_45182267/article/details/140613102

版权

碎碎念：加油哇
参考：代码随想录

235. 二叉搜索树的最近公共祖先

题目链接

235. 二叉搜索树的最近公共祖先

思想

当前的遍历节点，如果比p和q都大的话，p和q的公共祖先应该在这个遍历到的节点的左子树，同理，当前的遍历节点如果比p和q都小的话，所求的公共祖先应该在这个遍历到的节点的右子树种。如果一个节点的值在p和q之间，那么当前这个节点就是公共节点。
最近的公共节点：如果节点在p和q之间，也就是p和q分别在左子树和右子树，不论往哪边遍历，都会错过p或者q，所以找到的一定是最近的公共节点。
递归法：
递归三部曲：

参数和返回值：返回找到的p和q的最近公共祖先
终止条件：遍历到空，返回
单层递归的逻辑：没有中的逻辑，所以不谈遍历顺序；
如果当前的数值比p和q都大，向左搜索，记得用变量接返回值，判断一下找到没有；
如果当前的数值比p和q都小，向右搜索，记得用变量接返回值，判断一下找到没有；
剩下的情况：return cur。
迭代法：
只要当前遍历的节点不为空就继续遍历，如果当前的数值比p和q都大，向左搜索，如果当前的数值比p和q都小，向右搜索，其他的情况返回当前节点即可。

题解

// cpp 递归法 
class Solution {
public:
    TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode*q){
        if (cur == NULL) return NULL;
        if (cur->val > p->val && cur->val > q->val){
            TreeNode* left = traversal(cur->left, p, q);
            if (left != NULL) return left;
        }
        if (cur->val < p->val && cur->val < q->val) {
            TreeNode* right = traversal(cur->right, p, q);
            if (right != NULL) return right;
        }
        return cur;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root, p, q);
    }
};

# python 迭代法
class Solution:
    def traversal(self, cur, p, q):
        while cur:
            if (cur.val > q.val and cur.val > p.val):
                cur = cur.left
            elif (cur.val < q.val and cur.val < p.val):
                cur = cur.right
            else:
                return cur

    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.traversal(root, p, q)

反思

迭代法比较好写，是因为二叉搜索树帮我们确定了搜索的方向。

701.二叉搜索树中的插入操作

题目链接

701.二叉搜索树中的插入操作

思想

递归法：
递归三部曲：

递归参数和返回值：返回值是插入新节点以后的新二叉树的根节点
终止条件：如果root==NULL，找到了要插入节点的位置，定义新节点，返回节点。
单层递归逻辑：
如果值比当前节点的值小，那么向左递归，记得用root的letft接住返回值；
如果值比当前节点的值大，那么向右递归，用root的right接住返回值；
返回root。
这样一层一层返回，就会把修改好的树的根节点返回了。

迭代法：
二叉搜索树，帮我们明确的搜索的方向。

题解

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

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if root is None:
            node = TreeNode(val)
            return node

        cur = root
        pre = root
        while (cur):
            pre = cur
            if cur.val > val:
                cur = cur.left
            else:
                cur = cur.right
            
        node = TreeNode(val)
        if val < pre.val:
            pre.left = node
        else:
            pre.right = node
        return root

450.删除二叉搜索树中的节点

题目链接

450.删除二叉搜索树中的节点

思想

添加节点不用修改二叉树的结构，但是删除节点不可避免需要改变结构，而且二叉搜索树的结构是不一听的。
分几种条件：

没找到要删除的节点
找到了要删除的节点：
2.1 删掉的节点是叶子节点（左为空，右为空）：直接删掉叶子节点，return NULL
2.2 删掉的节点左不空，右为空：将待删除节点的左子树返回
2.3 删掉的节点左为空，右不空：将待删除节点的右子树返回
2.4 删掉的节点左不空，右不空：可以选择左孩子继位，也可以选择右孩子继位，这里选择右孩子继位，那么左子树就要放到右子树最左边的节点下面。（因为我们要找到的是比删除掉的节点堪堪大一点的节点，这个节点在右子树的最左下角。）

递归三部曲：

参数和返回值：返回删掉目标值后新的根节点，返回值是节点（在单层递归的时候需要拿当前层的left或者right接住）；
终止条件：找到需要删除的点，写删除节点的逻辑；
单层递归逻辑：如果删除节点小于root的值，向左递归，注意要用root的left接住返回值；如果要删除大于root的值，向右递归，用root的right接住返回值。返回root。

题解

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root; // 1. 没找到要删除的节点
        if (root->val == key) {
            // 2.1 删掉的节点是叶子节点（左为空，右为空）
            if (root->left == nullptr && root->right == nullptr) {
                delete root;
                return nullptr;
            }
            else if (root->left == nullptr) {
                // 2.2 删掉的节点左不空，右为空：将待删除节点的左子树返回
                auto retNode = root->right;
                delete root;
                return retNode;
            }
            else if (root->right == nullptr) {
                // 2.3 删掉的节点左为空，右不空：将待删除节点的右子树返回
                auto retNode = root->left;
                delete root;
                return retNode;
            }
            else {
                // 2.4 删掉的节点左不空，右不空：可以选择左孩子继位，也可以选择右孩子继位，这里选择右孩子继位，那么左子树就要放到右子树最左边的节点下面。
                TreeNode* cur  = root->right;  // 用来找到右子树最左边的节点
                while (cur->left) cur = cur->left;
                cur->left = root->left;
                TreeNode* tmp = root; // 保存一下 一会儿释放内存
                root = root->right;
                delete tmp;
                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:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if root is None:
            return root
        if root.val == key:
            if root.left is None and root.right is None:
                return None
            elif root.left is None:
                return root.right
            elif root.right is None:
                return root.left
            else:
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right
            
        if root.val > key:
            root.left = self.deleteNode(root.left, key)
        if root.val < key:
            root.right = self.deleteNode(root.right, key)
        return root