第四周第三天|力扣235、BST的最近公共祖先 701、BST中的插入操作 450、删除BST的节点

力扣235、BST的最近公共祖先

思路：要想找到公共祖先，对于BST而言，比二叉树的实现要更为容易，注意题目已经说明要找的节点一定在二叉树中，且不同节点数值不同，那么根据题目描述，利用BST的特性，不难有以下想法：
如果当前节点的数值大于所给的两个节点的数值，那么当前节点要往左子树走；
如果当前节点的数值小于所给的两个节点的数值，那么当前节点要往右子树走；
此外，当前节点的数值还可能介于两个节点的数值之间，此时返回当前节点即可。（因为两个节点分别分布在左右两颗子树中，无论再向哪一边遍历，都不可能找到公共祖先了，必然会漏掉一个节点）

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* traversal(TreeNode* cur,TreeNode* p,TreeNode* q){
        if(cur==nullptr)return nullptr;
        //左
        if(cur->val>p->val&&cur->val>q->val){
            TreeNode* left=traversal(cur->left, p, q);
            if(left!=nullptr)return left;
        }
        //右
        else if(cur->val<p->val&&cur->val<q->val){
            TreeNode* right=traversal(cur->right, p, q);
            if(right!=nullptr)return right;
        }

        return cur;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* result= traversal(root, p, q);
        return result;
    }
};

力扣501、BST的插入

思路：本题的关键是要明确根据BST的特性，新加入的节点不管取什么值，最终都会挂在某个叶子节点的下方。（注意题目保证新值和原节点中的任何值都不同）

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* traversal(TreeNode* cur,TreeNode* p,TreeNode* q){
        if(cur==nullptr)return nullptr;
        //左
        if(cur->val>p->val&&cur->val>q->val){
            TreeNode* left=traversal(cur->left, p, q);
            if(left!=nullptr)return left;
        }
        //右
        else if(cur->val<p->val&&cur->val<q->val){
            TreeNode* right=traversal(cur->right, p, q);
            if(right!=nullptr)return right;
        }

        return cur;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* result= traversal(root, p, q);
        return result;
    }
};

450、删除BST的节点

思路：删除的操作相比于插入BST的操作要难不少，因为插入操作从上面的分析中我们知道并不会改变BST的结构，新的节点一定会挂在原树叶子节点的下方，但是删除操作不可避免的要改变BST的结构，因此我们有必要好好分析一下会出现哪些情况:
1、一直找，找到空都未发现要删除的节点，根据BST的特性，说明要删除的节点不存在
2、找到了要删除的节点此时可能会发生四种情况：
要删除的节点是一个叶子节点，直接返回空就可以，注意手动释放内存（后面的情况也是一样）；
要删除的节点左子树为空右子树不为空，那么我们应该返回新的子树的根节点，也就是原子数根节点的右孩子；
要删除的节点左子树不为空右子树为空，那么我们应该返回新的子树的根节点，也就是原子数根节点的左孩子；
要删除的节点左右子树都不为空，那么我们要将原子树的左子树移到原子数的右子树的最小节点处，挂在它的左侧，也就是一直想左遍历，遍历到空为止，这就是原子数的左子树的新位置，根据BST的特性，这点应该是可以理解的。

执行完删除节点的操作，本题最重要的部分就完成了，接下来就是单层递归的逻辑，跟着BST的特性写就可以了。

代码：

/**
 * 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==nullptr)return nullptr;

        if(root->val==key){
            //如果找到了要删除的节点，第一种情况，左右孩子都为空，那么就直接返回Null
            if(root->left==nullptr&&root->right==nullptr){
                delete root;
                return nullptr;
            }
            //第二种情况，左孩子不为空，右孩子为空
            else if(root->left!=nullptr&&root->right==nullptr){
                TreeNode* temp=root->left;
               delete root;
               return temp;
            }
            //第三种情况，和第二种情况同理
            else if(root->left==nullptr&&root->right!=nullptr){
                TreeNode* temp=root->right;
                delete  root;
                return temp;
            }else{
                //左右孩子都不为空
                TreeNode* cur=root->right;
                while(cur->left!=nullptr){
                    cur=cur->left;
                }
                cur->left=root->left;
                TreeNode* temp=root->right;
                delete root;
                return temp;
            }
        }
        //单层递归的逻辑
        if(root->val>key){
            root->left=deleteNode(root->left, key);
        }
        if(root->val<key){
            root->right=deleteNode(root->right, key);
        }
        return root;
    }
};

注意：
理解好左右子树都不为空的情况；C++最好手动释放内存。