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

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

题目链接：235. 二叉搜索树的最近公共祖先
文章讲解：代码随想录#235. 二叉搜索树的最近公共祖先
视频讲解：二叉搜索树找祖先就有点不一样了！| 235. 二叉搜索树的最近公共祖先

题目描述

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例1

输入：root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出：6
节点 2 和节点 8 的最近公共祖先是 6。

示例2

输入：root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出：2
节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

提示

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉搜索树中。

思路

二叉搜索树是有序树，从根节点向叶子节点遍历的过程中，如果中间节点大于p && 中间节点小于q 或者 中间节点大于q && 中间节点小于p，说明中间节点是q和p的公共祖先。

递归参考代码

struct TreeNode* getCommonAncestor(struct TreeNode *cur, struct TreeNode* p, struct TreeNode* q) {
    if (cur == NULL) return cur;

    if (cur->val > p->val && cur->val > q->val) { // root的值大于q、p，需要向左子树遍历
        struct TreeNode* node = getCommonAncestor(cur->left, p, q);
        if (node != NULL) return node;
    }

    if (cur->val < p->val && cur->val < q->val) { // root的值浊于q、p，需要向右子树遍历
        struct TreeNode* node = getCommonAncestor(cur->right, p, q);
        if (node != NULL) return node;
    }

    // 其他情况，说明root就是公共节点，val值是相等的
    return cur;
}


struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    return getCommonAncestor(root, p, q);
}

迭代参考代码

struct TreeNode* getCommonAncestor(struct TreeNode *cur, struct TreeNode* p, struct TreeNode* q) {
    while (cur) {
        if (cur->val > p->val && cur->val > q->val) { // root的值大于q、p，需要向左子树遍历
        cur = cur->left;
        } else if (cur->val < p->val && cur->val < q->val) { // root的值浊于q、p，需要向右子树遍历
            cur = cur->right;
        } else {
            // 其他情况，说明root就是公共节点，val值是相等的
            return cur;
        }        
    }
    // 遍历完root都没有找到，说明不存在公共祖先
    return NULL;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    return getCommonAncestor(root, p, q);
}

---

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

题目链接：701.二叉搜索树中的插入操作
文章讲解：代码随想录#701.二叉搜索树中的插入操作
视频讲解：原来这么简单？ | LeetCode：701.二叉搜索树中的插入操作

题目描述

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

示例1

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]

示例2

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

提示

• 树中的节点数将在 [0, 104]的范围内。
• -10^8 <= Node.val <= 10^8
• 所有值 Node.val 是 独一无二 的。
• -10^8 <= val <= 10^8
• 保证 val 在原始BST中不存在。

思路

已知二叉搜索树是有充树，向其添加节点时，并没有要求插入后调整树的结构，那我们只需要遍历整个树，找到合适叶子节点，向叶子节点下面添加即可。

参考代码

struct TreeNode* insertIntoBST(struct TreeNode* root, int val) {
    if (root == NULL) {
        struct TreeNode* new = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        new->val = val;
        new->left = NULL;
        new->right = NULL;
        return new;
    }

    if (root->val > val) { // 当前节点的值大于目标值，需要向左遍历节点
        struct TreeNode* node = insertIntoBST(root->left, val);
        if (node != NULL) {
            root->left = node;
            return root;
        }
    } else if (root->val < val) { // 当前节点的值小于目标值，需要向右遍历节点
        struct TreeNode* node = insertIntoBST(root->right, val);
        if (node != NULL) {
            root->right = node;
            return root;
        }
    } 
    return NULL; // 要插入的节点等于当前节点，异常返回null
}

---

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

题目链接：450.删除二叉搜索树中的节点
文章讲解：代码随想录#450.删除二叉搜索树中的节点
视频讲解：调整二叉树的结构最难！| LeetCode：450.删除二叉搜索树中的节点

题目描述

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。

示例1

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例2

输入：root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

提示

• 节点数的范围 [0, 104].
• -10^5 <= Node.val <= 10^5
• 节点值唯一
• root 是合法的二叉搜索树
• -10^5 <= key <= 10^5

思路

二叉搜索树删除节点比较麻烦，因为删除节点后，需要调整树结构保证删除节点后仍然是一棵二叉搜索树。
关于删除节点，需要分析以下五种情况：
①没有找到要删除的节点，遍历完整个树后直接返回
②找到的节点左右孩子都为空，直接删除，返回NULL
③找到的节点左孩子为空，右孩子不为空，删除节点后，右孩子补位，返回右孩子节点
④找到的节点右孩子为空，左孩子不为空，删除节点后，左孩子补位，返回右孩子节点
⑤【比较麻烦，需要调整树结构】找到的节点左右孩子都不为空，删除节点后，将左子树的头结点指向删除节点的右子树的最左孩子节点上，返回删除节点的右孩子
第五点就是在调整树结构，对于要删除的节点来说，它左子数的所有节点都小于它右子树的最左孩子节点。

参考代码

struct TreeNode* deleteNode(struct TreeNode* root, int key){
    if (root == NULL) return root; // 情况一，没有找到要删除的节点
    if (root->val == key) {
        if (root->left == NULL && root->right == NULL) { // 情况二
            free(root); 
            return NULL;
        } else if (root->left == NULL && root->right != NULL) { // 情况三
            struct TreeNode* tmp = root->right;
            free(root);
            return tmp;
        } else if (root->left != NULL && root->right == NULL) { // 情况四
            struct TreeNode* tmp = root->left;
            free(root);
            return tmp;
        } else { // 情况五
            struct TreeNode* lchild = root->left;
            struct TreeNode* rchild = root->right;
            struct TreeNode* tmp = rchild;
            while(tmp->left) {
                tmp = tmp->left;
            }
            tmp->left = lchild; // 将左子树的头结点指向删除节点的右子树的最左孩子节点
            free(root);
            return rchild;
        }
    }
    if (root->val > key) { // 当前节点的值大于目标值，需要向左遍历节点
        root->left = deleteNode(root->left, key);
    }
    if (root->val < key) { // 当前节点的值小于目标值，需要向右遍历节点
        root->right = deleteNode(root->right, key);
    }
    return root;
}