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

原创已于 2024-03-31 10:41:53 修改 · 436 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2024-03-31 10:34:30 首次发布

博客主要围绕二叉搜索树展开，涉及到二叉搜索树的最近公共祖先查找、插入操作以及删除节点等算法内容，这些都是信息技术领域中数据结构与算法方面的关键操作。

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

class Solution {
public:
    int l, r;
    TreeNode* solve(TreeNode* node) {
        TreeNode* left = NULL;
        TreeNode* right = NULL;
        if (node == NULL)
            return node;
        if (node->val <= r && node->val >= l)
            return node;
        if (node->val < l)
            right = solve(node->right);
        if (node->val > r)
            left = solve(node->left);
        if (left == NULL && right != NULL)
            return right;
        if (left != NULL && right == NULL)
            return left;
        else
            return NULL;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        l = min(p->val,q->val), r = max(q->val,p->val);
        TreeNode* ret = solve(root);
        return ret;
    }
};

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

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

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

class Solution {
public:
    int k;
    TreeNode* solve(TreeNode* node) {
        if (node == NULL)
            return node;
        if (node->val == k) {
            if (node->left == NULL && node->right == NULL) {
                
                return NULL;
            }
            if (node->left != NULL && node->right == NULL) {
               
                return node->left;
            }
            if (node->left == NULL && node->right != NULL) {
               
                return node->right;
            }
            if (node->left != NULL && node->right != NULL) {
                TreeNode* a = node->right;
                while (a->left != NULL)
                    a = a->left;
                a->left = node->left;
               
                node = node->right;
              
                return node;
            }
        }
        if (node->val > k)
            node->left = solve(node->left);
        if (node->val < k)
            node->right = solve(node->right);
        return node;
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        k = key;
        if (root != NULL && !root->left && !root->right && root->val == key)
            return root->left;
       TreeNode* ret= solve(root);
        return ret;
    }
};