算法D22 | 二叉树8 | 235. 二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点

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

相对于 二叉树的最近公共祖先 本题就简单一些了，因为 可以利用二叉搜索树的特性。 

题目链接/文章讲解：代码随想录

视频讲解：二叉搜索树找祖先就有点不一样了！| 235. 二叉搜索树的最近公共祖先_哔哩哔哩_bilibili

Python递归：

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root or root==p or root==q: return root
        if root.val > p.val and root.val > q.val:
            left = self.lowestCommonAncestor(root.left, p, q)
            if left: return left
        elif root.val < p.val and root.val < q.val:
            right = self.lowestCommonAncestor(root.right, p, q)
            if right: return right
        else:
            return root

C++递归：

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

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

本题比想象中的简单，大家可以先自己想一想应该怎么做，然后看视频讲解，就发现 本题为什么比较简单了。

题目链接/文章讲解：代码随想录

视频讲解：原来这么简单？ | LeetCode：701.二叉搜索树中的插入操作_哔哩哔哩_bilibili

思路： 可以不用修改树的结构，只要找到对的插入位置，空节点位置插入数值即可。这里root.left= 和root.right= 用来承接修改之后的底层树节点。

Python递归：

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root: return TreeNode(val)
        if root.val > val:
            root.left = self.insertIntoBST(root.left, val)
        if root.val < val:
            root.right = self.insertIntoBST(root.right, val)
        return root

C++递归：

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;
    }
};

如果是迭代法，则需要一个变量parent记录上一个节点，用于连接新节点。逻辑和迭代类似的。

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

相对于 插入操作，本题就有难度了，涉及到改树的结构 

题目链接/文章讲解：代码随想录

视频讲解：调整二叉树的结构最难！| LeetCode：450.删除二叉搜索树中的节点_哔哩哔哩_bilibili

Python递归：

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root: return # 1. 遍历结束没有找到key，返回None
        if root.val == key:
            # 2.找到key，左右孩子都空，直接返回空节点，不用处理
            # 3.左空右非空，删除节点，右孩子补位返回
            if not root.left: return root.right
            # 4.左非空右空，删除节点，左孩子补位返回
            elif not root.right: return root.left
            # 5.左右均非空，删除节点，左子树放到右子树最左边节点的左孩子位置，返回右孩子
            else:
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                tmp = root
                root = root.right
                return root
        # 1. 没有找到key，继续遍历 or 返回None
        if root.val > key: 
            root.left = self.deleteNode(root.left, key)
        if root.val < key:
            root.right = self.deleteNode(root.right, key)
        return root

C++递归：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root==nullptr) return root;
        if (root->val == key) {
            // 2.左右均为空，直接删除节点
            if (root->left==nullptr && root->right==nullptr) {
                delete root; // 释放内存
                return nullptr;
            } 
            // 3. 左空右非空，删除节点，右孩子补位返回
            else if (root->left == nullptr) {
                auto retNode = root->right;
                delete root; // 释放内存
                return retNode;
            }
            // 4. 左非空右空，删除节点，左孩子补位返回
            else if (root->right == nullptr) {
                auto retNode = root->left;
                delete root; // 释放内存
                return retNode;
            }
            // 5. 左右均非空，删除节点，左子树放到右子树最左边节点的左边，返回右子树           
            else {
                TreeNode* cur = root->right;
                while (cur->left!=nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left;
                // TreeNode* tmp = root;
                // root = root->right;
                // delete tmp;
                // return root;
                return root->right;
            }

        }
        // 1. 没找到key
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);        
        return root;
    }
};