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

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

文章链接：代码随想录

视频链接：LeetCode:235.二叉搜索树的最近公共祖先

题目链接：力扣题目链接

解法1：迭代法

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
       while(root){
           // 目标值小于根节点，则向左遍历
           if(p -> val < root-> val && q->val < root->val) root = root->left; 
           // 目标值大于根节点，则向右遍历 
           else if(p -> val > root-> val && q->val > root->val) root= root->right;
           else{
               return root;
           }   
        } 
        return NULL; // 循环结束还没有，则返回空
    } 
};

解法2：递归

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 
        if(root == NULL) return root;

        if(p -> val < root-> val && q->val < root->val){  // 目标值小于根节点，向左遍历
            TreeNode* left = lowestCommonAncestor(root->left,p,q);
            if(left != NULL) return left;
        }
        if(p -> val > root-> val && q->val > root->val){  // 目标值大于根节点，向右遍历
            TreeNode* right = lowestCommonAncestor(root->right,p,q);
            if(right != NULL) return right;  
        }
        return root;  // 目标值在根节点两侧，则该点就是祖先
    }
};

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

 文章链接：代码随想录

视频链接：LeetCode:701.二叉搜索树中的插入操作

题目链接：力扣题目链接

解法1：迭代

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        // 如果传入的二叉树为空，则直接将根节点赋值然后返回
        if(root == NULL) {
            root = new TreeNode(val);
            return root;
        }
        TreeNode* cur = root;
        while(1){
            if(cur->val > val)  {
                // 如果左节点不为空则进行递归
                if(cur->left != NULL) cur = cur->left;  //左子树不为空，则继续遍历 
                else{
                    cur->left = new TreeNode(val); // 左子树为空，则直接添加二叉树节点，然后返回
                    break;
                }
           }
            // 目标值大于节点，向右遍历
            else if(cur->val < val)  {
                // 如果左节点不为空则进行递归
                if(cur->right != NULL) cur = cur->right;
                else{
                    cur->right = new TreeNode(val);
                    break;
                }
            }
        }
        return root;
    }
};

解法2：递归

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        // 当找到用空节点的时候，就赋值，返回
        if(root == NULL){  // [7]的左子树为空，则构造一个二叉树
            TreeNode* node = new TreeNode(val);
            return  node;
        }
        // 
        if(root->val > val){  // 遍历到root = [7],再向下进行递归
             root->left =  insertIntoBST(root->left, val); 
             // 然后把构造的二叉树，传给[7]的左子树
        }
        if(root->val < val){
            root->right =  insertIntoBST(root->right, val); 
            // 再对节点[4]进行，更新右子树[4]->[7]->[5]
        }
        return root; // 返回更新后的节点[7]->[5]
    }
};

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

 文章链接：代码随想录

视频链接：LeetCode:450.删除二叉搜索树中的节点

题目链接：力扣题目链接

解法1：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        //终止条件  没找到目标节点
        if(root == NULL) return NULL;
        // 找到目标节点
        if(root->val == key){
            // 节点左右孩子都为空
            if(root->left==NULL&&root->right==NULL) {
                delete root; // 释放内存
                return NULL; // 直接返回    
            }else if(root->left!=NULL&&root->right==NULL){ // 左孩子不为空，右孩子为空。返回左孩子
                TreeNode* tmp = root->left;
                delete root; // 释放内存
                return tmp; // 直接返回 
            }else if(root->left==NULL&&root->right!=NULL){ // 左孩子为空，右孩子不为空。返回右孩子
                TreeNode* tmp = root->right;
                delete root; // 释放内存
                return tmp; // 直接返回 
            }else{ // 左右孩子都不为空
                TreeNode* cur = root->right; // [9]
                while(cur->left!=NULL){cur = cur->left;} // 找到要最左侧的节点 [8]
                cur->left = root->left; //把要删除节点的左孩子妥善处理好 [8]->[5]
                TreeNode* tmp = root->right;
                delete root; // 释放内存
                return tmp; // 直接返回                 
            }
        }
        // 二叉搜索树明确了递归方向
        if(root->val > key){
            root->left = deleteNode(root->left, key); // 由这里接住，递归向上返回回来的节点
        }
        if(root->val < key){
            root->right = deleteNode(root->right, key); // 由这里接住，递归向上返回回来的节点，跟新右节点
        }
        // 左右都处理完，返回根节点
        return root;
    }
};