代码随想录第十七天|701.二叉搜索树中的插入操作 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点

class Solution {
public:
    void dfs(TreeNode* &root, int val){
        if(root==NULL)
        {
            root=new TreeNode(val);
            return;
        }
        else{
            if(root->val>val)
              dfs(root->left,val);
            else
              dfs(root->right,val);
        }
    }
    TreeNode* insertIntoBST(TreeNode* root, int val) {
         dfs(root,val);
         return root;
    } 
};

class Solution {
public:
    TreeNode *res=NULL;
    //二叉搜索树的性质 从上自下遍历 如果遇到在范围之间一定是最近公共祖先 否则沿着一条边遍历
    TreeNode* travel(TreeNode* root, TreeNode* p, TreeNode* q){
        if(root==NULL)
           return NULL;
        else{
            if(root->val>p->val&&root->val>q->val){
                  return travel(root->left,p,q);
            }else if(root->val<p->val&&root->val<q->val){
                  return travel(root->right,p,q);
            }else{
                 return root;
            }   
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
          return travel(root,p,q);
    }
};

思路：我们需要仔细观察二叉搜索树的性质 当找到一个val在p q之间的结点就说明已经找到最近公共祖先 

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->right;   // 把root节点保存一下，下面来删除    // 返回旧root的右孩子作为新root
                delete root;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
                return tmp;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

思路：需要二刷

还是一条线的遍历

首先root为空说明没找到returnNULL

然后找到分几种情况 返回根节点

这个时候就需要有东西去承接根节点

root->left 或者root->right

然后返回root 最后一直返回到主函数 返回root

当要删除的是根节点的时候就直接返回 不需要递归 很难的题需要二刷

delete函数返回的是被删除完的子树的根节点

删除普通节点的操作

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;
        if (root->val == key) {
            if (root->right == nullptr) { // 这里第二次操作目标值：最终删除的作用
                return root->left;
            }
            TreeNode *cur = root->right;
            while (cur->left) {
                cur = cur->left;
            }
            swap(root->val, cur->val); // 这里第一次操作目标值：交换目标值其右子树最左面节点。
        }
        root->left = deleteNode(root->left, key);
        root->right = deleteNode(root->right, key);
        return root;
    }
};

思路：

首先 第一次我们会遍历到我们需要删除的结点 但此时如果我们想要删除结点很麻烦

但是我们只要有一个子树为空就返回另一个子树不就好了

这个时候如果右子树直接返回 别问我为什么左子树不行 因为这样写代码有一个通用的逻辑 否则在右子树最左边 这个时候交换val 这个时候目标节点一定没有