day-22 代码随想录算法训练营（19）二叉树part08

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

思路一：根据二叉搜索树的特性，首先判断两个节点值的大小，然后按大小从根节点进行遍历

                1.首先每次判断中间节点是否在两个节点值中间或者等于其中一个节点，若符合直接返回root。

                2.不符合第一个条件表示两个节点一定在中间节点的一侧上，此时直接进行判断两个节点大于还是小于中间节点，直接往那一边进行递归查找

class Solution {
public:
    TreeNode* judge(TreeNode*root,TreeNode*first,TreeNode*second){
        if(first->val<=root->val && second->val>=root->val) 
            return root;
        TreeNode*res;
        if(second->val<root->val)
            res=judge(root->left,first,second);
        else
            res=judge(root->right,first,second);
        return res;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //思路：找到一个在两个节点中间的节点，或者等于较小值
        if(p->val>q->val) return judge(root,q,p);
        return judge(root,p,q);
    }
};

方法二：迭代，思路是一样的

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

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

思路一：判断大小情况

优化：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root==nullptr){
            return new TreeNode(val);
        }
        //根据大小直接跳转
        if(root->val>val) root->left=insertIntoBST(root->left,val);
        else root->right=insertIntoBST(root->right,val);
        return root;
    }
};

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

思路一：判断头结点是否要删除，判断是否在二叉搜索树中，找到要删除的节点，判断有没有子节点，作出处理

思路二：考虑到delete的方法，在删除时不用记录两个节点，只需要记录删除节点的子节点，然后把要删除的节点delete就行。思路跟复杂度差不多

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root==nullptr) return nullptr;//二叉搜索树找到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*temp=root;
                root=root->right;
                delete temp;
                return root;
            }
        }
        if(root->val>key) root->left=deleteNode(root->left,key);
        else if(root->val<key) root->right=deleteNode(root->right,key);
        return root;
    }
};

感觉递归的方法就是，代码能有多简洁就有多简洁