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

235. 二叉搜索树的最近公共祖先（题目链接：力扣）

思路：以为和昨晚的找二叉树的最近公共祖先差不多，只要剪枝一下就可以了，于是作出如下答案

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    if(root == p || root == q || root == NULL) return root;
    TreeNode* left = NULL;
    if(p->val < root->val || q->val < root->val) left = lowestCommonAncestor(root->left, p, q);
    TreeNode* right = NULL;
    if(p->val > root->val || q->val > root->val) right = lowestCommonAncestor(root->right, p, q);
    if(left != NULL && right != NULL) return root;
    if(left != NULL && right == NULL) return left;
    return right;
}

后来看了解析发现可以这样做：每当节点值刚好踏入[q.value, p.value]区间，该节点就是p、q的最近公共祖先，这样做其实就是从上往下的遍历，从上往下的思维，和昨天的回溯（从下网上的思维）正好相反，这点大家可以理解一下。

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){
        return lowestCommonAncestor(root->right, p, q);
    }else return root;
}

701. 二叉搜索树中的插入操作（题目链接：力扣）

思路：一开始还在想针对叶子节点、非叶子节点、根节点，左右节点该怎么插入，左右子树该怎么变化，于是写出如下代码（惯性思维考虑中序遍历二叉搜索树正好从小到大）

bool flag = false;
void insert(TreeNode* root, int val){
    if(root->left) insert(root->left, val);
    if(!flag && val < root->val){
        if(root->left == NULL){
            TreeNode* node = new TreeNode(val);
            root->left = node;
        }else{
            TreeNode* node = new TreeNode(val, root->left, NULL);
            root->left = node;
        }
        flag = true;
    }
    if(!flag && root->right) insert(root->right, val);
}

TreeNode* insertIntoBST(TreeNode* root, int val) {
    if(root == NULL) return new TreeNode(val);
    insert(root, val);
    if(flag) return root;
    return new TreeNode(val, root, NULL);
}

可以看出来，是比较繁琐的，不仅遍历过程中针对不同位置要做不同的插法，如果插入的节点值是整棵树中最大的，还要新增一个根节点。后来看了解析，直接从上到下，一条路径遍历到叶子节点，就可以确定插在哪里了，唯一要考虑的就是拿一个指针记录前一个节点，插入的时候做比较看是插在右节点还是插在左节点。

TreeNode* pre=NULL;
void traversal(TreeNode* root, int val){
    if(root == NULL){
        TreeNode* node = new TreeNode(val);
        if(pre->val < val) pre->right = node;
        else pre->left = node;
        return;
    }
    pre = root;
    if(val < root->val) traversal(root->left, val);
    else if(val > root->val) traversal(root->right, val);
}

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

450. 删除二叉搜索树中的节点（题目链接：力扣）

思路：一开始还是跟上一题差不多的思路，分情况对删除后的子树做不同操作。（这里挖个小坑，今晚用不带返回值的递归函数死活ac不了，后来加了个TreeNode*返回值就立马可以了）

TreeNode* deleteNode(TreeNode* root, int key) {
    if(root == NULL) return root;
    if(root->val == key){
        if(root->left && root->right){
            TreeNode* cur = root->right;
            while(cur->left){
                cur = cur->left;
            }
            cur->left = root->left;
            TreeNode* tmp = root->right;
            delete root;
            return tmp;
        }else if(root->left){
            TreeNode* tmp = root->left;
            delete root;
            return tmp;
        }else if(root->right){
            TreeNode* tmp = root->right;
            delete root;
            return tmp;
        }else{
            delete root;
            return NULL;
        }
    }
    else if(key < root->val) root->left = deleteNode(root->left, key);
    else if(key > root->val) root->right = deleteNode(root->right, key);
    return root;
}

又学习到一种很新颖的做法（对普通二叉树同样适用），就是只做一种删除操作（针对右子树为空的时候），否则就将该节点与右子树中最左下角的节点交换，途中可能会交换多次，最后一次一定会把要删除的节点换到叶子节点（右子树为空），这时候直接删除就可以了，因为这种交换最多使得要删除的节点的值不满足二叉搜索树的大小顺序，所以可以适用于二叉搜索树。（但是这样的话就不能剪枝了，效率肯定是不如上面的）

TreeNode* deleteNode(TreeNode* root, int key) {
    if(root == NULL) return root;
    if(root->val == key){
        if(root->right == NULL){
            TreeNode* tmp = root->left;
            delete root;
            return tmp;
        }
        TreeNode* cur = root->right;
        while(cur->left){
            cur = cur->left;
        }
        swap(cur->val, root->val);
    }
    root->left = deleteNode(root->left, key);
    root->right = deleteNode(root->right, key);
    return root;
}