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

236. 二叉树的最近公共祖先

题目描述：

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

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

解答：

法一：

本题我的思路是先分别对于p和q进行寻找，记录路径。

然后对于p和q的路径序列再进行对比，找到第一个不同的元素，即为找到了最近的公共祖先。

代码实现：

class Solution {
public:
    bool Inorder(TreeNode* root, vector<int>path, vector<int>& result, TreeNode* p){
        if (root == NULL)
            return false;
 
        path.push_back(root->val);
        if (root->val == p->val){
            result = path;
            return true;
        }
        bool left = false, right = false;
        if (root->left)
            left = Inorder(root->left, path, result, p);
        if (root->right)
            right = Inorder(root->right, path, result, p);
        return left | right;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<int>resultP, resultQ;
        if (p == NULL || q == NULL)
            return p == NULL?q:p;
        //寻找p、q记录路径
        bool seekP = Inorder(root, {}, resultP, p);
        bool seekQ = Inorder(root, {}, resultQ, q);
        int size = resultP.size() > resultQ.size()?resultQ.size():resultP.size();
        int i = 0;
        //找最近公共祖先
        for (; i
            if (resultP[i] != resultQ[i])
                break;
        }
        TreeNode* ancestor = new TreeNode(resultP[i-1]);
        return ancestor;
    }
};

法二：

还有一种思路，二叉树自底向上进行寻找，找到第一个祖先节点。

但是怎样来实现自底向上这个过程呢？

回溯！而且后序遍历本身就是一个回溯的过程，最先处理的一定是叶子节点。

接下来第二个问题如何判断一个节点是节点q和节点p的公共祖先呢？

第一种情况，如果在一个节点的左子树中找到p（或q）右子树中找到q（或p）那这个节点即为p和q的公共祖先。

但是此处忽略了一种情况：p或q本身是公共祖先。

整体思路：

使用后序遍历，回溯的过程，就是自底向上遍历节点，一旦发现满足第一种情况的节点，就是最近公共节点了。

如果p或者q本身就是最近公共祖先，只需要找到一个节点是p或者q的时候，直接返回当前节点，无需继续递归子树。

依旧是递归三部曲：

（1）参数及返回值：要返回最近公共节点，返回值是TreeNode * ，那么如果遇到p或者q，就把q或者p返回。返回值不为空，就说明找到了q或者p。 

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

（2）终止条件： 为空或者找到了p或q

if (root == q || root == p || root == NULL) return root;

（3）内部处理逻辑：递归对左右子树进行访问，如果左右子树返回均不为空则返回root，如果有一个为空则返回非空的。

代码实现：

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

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

题目描述：

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

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

解答：

这个题乍一看感觉很复杂，如果改成在二叉搜索树中寻找一个数val呢？

只不过这道题寻找的数不存在，因此只需要在递归为NULL时将这个数val插入即可 。

依旧考虑递归三部曲：

（1）参数及返回值：参数两个，根节点和值val；返回值返回一个节点，可以利用返回值完成新加入的节点与其父节点的赋值操作。

（2）终止条件：遇到为NULL，创建新节点并返回即可。

（3）单层递归逻辑：按照在二叉搜索树中寻找的方式进行访问左右节点即可。

代码实现：

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

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

题目描述：

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

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

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

解答：

此题首先分为两步，找和删。

找很简单，递归+二叉搜索树的性质。

关键在于如何去删除？

删除时有三种情况：

（1）被删节点左右均空——直接返回NULL即可

（2）被删节点左空右非空——直接返回右子树

（3）被删节点左非空右空——直接返回左子树

（4）被删节点左右均非空——需要仔细考虑

        删除后需要进行调整，第一个问题调整谁上去？

        左右子树均可，此处以左子树上去为例。

        左子树上去之后右子树放到哪？

        二叉搜索树的性质，右子树的所有节点一定都大于左子树中的最大节点；左子树的最大节点在左子树的最右侧。

        所以放置于左子树的最右。

        （若调整右子树上去，则将 左子树放置于右子树的最左）

代码实现：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root == NULL)
            return NULL;
        if (root->val > key)
            root->left = deleteNode(root->left, key);
        if (root->val < key)
            root->right = deleteNode(root->right, key);
        if (root-> val == key){
            //情况一：左右均空
            if (root->left == NULL && root->right == NULL)
                return NULL;
            //情况二：左空右非空
            else if (root->left == NULL && root->right != NULL)
                return root->right;
            //情况三：左非空右空
            else if (root->left != NULL && root->right == NULL)
                return root->left;
            //情况四：左右均非空
            else {
                TreeNode* pre = root->left;
                while (pre->right != NULL)
                    pre = pre->right;
                pre->right = root->right;
                return root->left;
            }
        }
        return root;
 
    } 
};