代码随想录训练营第二十二天|235.二叉搜索树的最近公共祖先701.二叉搜索树中的插入操作450.删除二叉搜索树中的节点

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

思路：因为二叉树为二叉搜索树，如果两个目标值为p和q，那么从上到下遍历，第一个遇到的p<cur<q，即为最近公共祖先，采用递归算法：

输入值：二叉树根节点，p,q  输出值：最近公共祖先节点

终止条件：找到p<cur<q,或者cur为nullptr

单层循环：如果cur->val>q->val,向左遍历，cur->val<p->val,向右遍历

class Solution {
public:
    TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
        if(cur == NULL)
            return cur;
        if (cur->val > p->val && cur->val > q->val)
        {
            TreeNode *left = traversal(cur->left, p, q);
            if (left != nullptr)
                {return left;}
        }
        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){
        return traversal(root, p, q);
    }
};

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

思路：重构二叉树太复杂了，可以采用查询空节点，然后插入的方式。

采用递归的方法：

输入：二叉树的根节点和要插入的值

终止条件：找到合适的空节点（节点为空）

单层循环：比较要插入的值和cur->val，大于就去右子树遍历，小于就去左子树遍历，每层把newroot返回回溯

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

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

思路：

采用递归算法，

单层逻辑一种有5种情况：

找不到key==cur->val；找到key==cur->val,cur左右子树为空；左子树为空；右子树为空；左右子树都不是空。

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root == nullptr)return nullptr;
        if(root->val == key){
            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;
                TreeNode *tmp = root;
                root = root->right;
                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;
    }
};