力扣刷题记录（5）LeetCode：235、701、450

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

这道题可以用上篇文章中236. 二叉树的最近公共祖先 相同的解法。但可以根据二叉搜索树的特性提供一种更高效的写法。如果某一个结点的值在p、q之间，那么这个结点一定是p、q的最近公共祖先。因为如果如果你继续遍历的话那么一定会错过其中一个。

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

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

 

起初想用中序遍历，然后找到第一个大于val的结点，找到该结点后将val放到该结点的左边。那这样就会有问题，可能该结点的左边已经有节点了。所以最方便的思路是把val放到叶子结点的子节点中。那么我们就只需要根据当前结点与val的大小关系来遍历到叶子结点，再将val插入即可。

迭代法：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root==nullptr)
        {
            root=new TreeNode(val);
            return root;
        }
        TreeNode* temp=root;   
        while(temp)
        {
            if(val<temp->val)
            {
                //不为空就继续向左走
                if(temp->left)  temp=temp->left;
                else
                {
                    temp->left=new TreeNode(val);
                    break;
                }    
            }   
            else
            {
                //不为空就继续向右走
                if(temp->right) temp=temp->right;
                else{
                    temp->right=new TreeNode(val);
                    break;
                }
            } 
        }
        return root;
    }
};

递归法：

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. 删除二叉搜索树中的节点 

 

删除结点比添加结点要麻烦些，需要考虑多种情况：

1.未找到值为key的结点：直接返回根节点

2. 结点的左右孩子为空：直接释放该结点

3.结点的左孩子为空，右孩子不为空：该结点的父节点直接指向右孩子

4.结点的左孩子不为空，右孩子为空：该结点的父节点直接指向左孩子

5.结点的左右孩子都不为空：找到右子树最左边的结点，将该节点的左指针指向左子树

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
//一个大佬的解法
        if (root == nullptr) return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root->val == key) {
            // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
            if (root->left == nullptr && root->right == nullptr) {
                ///! 内存释放
                delete root;
                return nullptr;
            }
            // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            else if (root->left == nullptr) {
                auto retNode = root->right;
                ///! 内存释放
                delete root;
                return retNode;
            }
            // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
            else if (root->right == nullptr) {
                auto retNode = root->left;
                ///! 内存释放
                delete root;
                return retNode;
            }
            // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
            // 并返回删除节点右孩子为新的根节点。
            else {
                TreeNode* cur = root->right; // 找右子树最左面的节点
                while(cur->left != nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
                root = root->right;     // 返回旧root的右孩子作为新root
                delete tmp;             // 释放节点内存
                return root;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};