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

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

        公共祖先：利用回溯从底向上搜索，遇到一个节点的左子树里有p，右子树里有q，那么当前节点就是最近公共祖先。

        在二叉搜索树中，从上向下去递归遍历，第一次遇到的节点是数值在[q, p]区间内那么它即为公共祖先。

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

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

        本题可以不改变整体结构，二叉搜索树本身是有序的，只要找到符合要求的叶子结点在下面添加新的节点即可。

class Solution {
public:
    TreeNode* parent;
    void traversal(TreeNode* node, int val) {
        if(!node) {
            TreeNode* n = new TreeNode(val);
            if(val > parent->val) 
            {
                parent->right = n;
            }
            else{
                parent->left = n;
            }
            return;  
        }
        parent = node;
        if(val > node->val) {
            traversal(node->right, val);
        }else{
            traversal(node->left, val);
        }
        return;

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

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

        这题删除节点后整个数需要重排序，排序的情况：

        1. 没有左右子节点，那么该节点直接删除

        2. 左节点或右节点有一个为空，那么直接返回另一个子节点

        3. 左右节点都不为空，那么把左节点平移到右字树上最小的节点左边也能符合二叉搜索树的规律。

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return root;
        if(root->val == key) {
            if(!root->left && !root->right) {
                delete root;
                return nullptr;
            }
            if(!root->left && root->right) {
                auto ptr = root->right;
                delete root;
                return ptr;
            }
            if(root->left && !root->right) {
                auto ptr = root->left;
                delete root;
                return ptr;
            }
            if(root->left && root->right) {
                auto MinNode = root->right;
                while(MinNode->left) {
                    MinNode = MinNode->left;
                }
                MinNode->left = root->left;
                auto tmp = root->right;
                delete root;
                return tmp;
            }
        }
        if(root->val < key) {
            root->right = deleteNode(root->right,key);
        }
        if(root->val > key) {
            root->left = deleteNode(root->left,key);
        }     
        return root;           
    }
};