Day 22 235. 二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点

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

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

百度百科中最近公共祖先的定义为：“对于有根树 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节点中间即可找到最近的公共祖先；

	TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q){
        if(cur == NULL)	reeturn nullptr;
        if (cur->val > p->val && cur->val > q->val) {   // 左
            TreeNode* left = traversal(cur->left, p, q);
            if (left != NULL) {
                return left;
            }
        }

       	if (cur->val < p->val && cur->val < q->val) {   // 右
            TreeNode* right = traversal(cur->right, p, q);
            if (right != NULL) {
                return right;
            }
        }
        return cur;
    }

​ 题解代码如下：

class Solution {
public:
    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;
    }
};

二叉搜索树中的插入操作

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

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

提示：

• 给定的树上的节点数介于 0 和 10^4 之间
• 每个节点都有一个唯一整数值，取值范围从 0 到 10^8
• -10^8 <= val <= 10^8
• 新值和原始二叉搜索树中的任意节点值都不同

​ 由于题目给出的提示是可以不限制二叉树的结构的，那么可以不改变二叉树结构的情况下将所有元素全部插入到叶节点；

​ 递归实现如下：

    TreeNode* traversal(TreeNode* root, int val) {
        if (root == NULL) {//此时为叶子节点
            TreeNode* node = new TreeNode(val);
            return node;//返回包含新节点的父节点
        }
        if (root->val > val) root->left = traversal(root->left, val);//利用二叉搜索树性质寻找传入节点位置
        if (root->val < val) root->right = traversal(root->right, val);
        return root;//返回上层节点，最终返回根节点
    }

删除二叉搜索树中的节点

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

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

首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为 $O(h)$，h 为树的高度。

示例:

​ 难度来了，改变二叉搜索树的结构；

​ 那么就有四种删除情况需要讨论：

​ 1.删除叶子节点（左右都为空的节点）：最简单的操作方式；

​ 2.删除左不为空右为空的节点：让该节点的父节点指向左子节点;

​ 3.删除左为空右不为空的节点：让该节点的父节点指向右子节点;

​ 4.删除左右都不为空的节点：可以用左子树的最右下的节点(或右子树最左下的节点)替代当前节点来接收原本的右子树(或左子树)，然后直接用父节点指向此节点的左子树(或右子树)；此处代码实现需要new一个TreeNode型的临时节点来存储节点，注意内存释放；

​ 整体代码实现如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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 NULL;
            }
            else if(root->left && !root->right){//左子树非空，右子树为空
                TreeNode* tNode = root->left;//实现用root->left替换root;
                delete root;
                return tNode;
            }
            else if(root->right && !root->left){//左子树为空，右子树非空
                TreeNode* tNode = root->right;//实现用root->right替换root;
                delete root;
                return tNode;
            }
            else{//左右子树均非空
            //此处选择左子树替换的方式实现，定义cur为右子树节点
                TreeNode* cur = root->right;
                while(cur->left)    cur = cur->left;//得到右子树左下角的节点
                cur->left = root->left;// 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* temp = root;
                root = root->right;// 返回旧root的右孩子作为新root
                delete temp;
                return root;
            }
        }
        if(root->val > key) root->left = deleteNode(root->left, key);
        if(root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};
    if(root->val > key) root->left = deleteNode(root->left, key);
        if(root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};