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

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

思路

1. 二叉搜索树：利用比较性质，左<中<右
2. 普通二叉树，从底层往上找，每次返回root

代码

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (p->val > q->val) swap(p, q);
        // if (root->val >= p->val && root->val <= q->val) return root;
        if (root->val < p->val) return lowestCommonAncestor(root->right, p, q);
        if (root->val > q->val) return lowestCommonAncestor(root->left, p, q);
        return root;
    }
};

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

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

思路

1. 递归：利用二叉搜索数性质，找到合适的nullptr进行添加
2. 迭代：类似递归，不过添加的时候需要记录添加的父节点，然后看放在左侧还是右侧

代码

1. 递归

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

2. 迭代

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
       if (!root){
           TreeNode* node = new TreeNode(val);
           return node;
       }
       auto parent = root;
       auto cur = 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->right = node;
        if (val < parent->val) parent->left = node;
        return root;
    }
};

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

思路

1. 二叉搜索树：思路好想，就是找到那个点，然后右子树和左子树要合并，然后代替，主要要考虑进行树合并之后，如何删掉root节点
2. 普通树：找到这个点了，然后把这个点和右子树的最左侧的点，交换，再次找到这个点发现没有右子树，然后就返回空值了，其实相当于把右子树最左的点移动过来
3. 迭代：找到要删除的点一定要知道他的父节点是哪个，然后删除节点，删除节点也是满足右子树和左子树合并的要求

代码

1. 二叉搜索树

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) return nullptr;
        if (root->val == key){
            if (root->left!= nullptr && root->right != nullptr){
                TreeNode* a = root->right; // 找右子树最左面的节点
                while(a->left != nullptr) {
                    a = a->left;
                }
                a->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
                root = root->right;     // 返回旧root的右孩子作为新root
                delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
                return root;
            }
            else if (!root->left && root->right) {
                auto a = root->right;
                delete root;
                return a;
            }
            else if (!root->right && root->left) {
                auto a = root->left;
                delete root;
                return a;
            }
            else {
                delete root;
                return nullptr;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

2. 没有进行比较的递归

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) return nullptr;
        if (root->val == key){
            if (root->right == nullptr) return root->left;
            auto a = root->right;
            while (a->left) a = a->left;
            swap(root->val, a->val);
        }
        root->left = deleteNode(root->left, key);
        root->right = deleteNode(root->right, key);
        return root;
    }
};

3. 迭代

class Solution {
public:
    TreeNode* deletenode(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;
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) return nullptr;
        TreeNode* pre = nullptr;
        TreeNode* cur = root;
        while (cur){
            if (cur->val == key) break;
            pre = cur;
            if (cur->val > key) cur = cur->left;
            else cur = cur->right;
        }
        if (pre == nullptr) return deletenode(cur);
        if (pre->left && pre->left->val == key) {
            pre->left = deletenode(cur);
        }
        if (pre->right && pre->right->val == key) {
            pre->right = deletenode(cur);
        }
        return root;
    }
};