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

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

力扣

思路：

1. 利用二叉搜索树「有序」的特征；

2. 从上往下递归遍历，若中间节点为p、q公共祖先，则其数值必位于[p.val, q.val]区间内；

3. 最近公共祖先：遍历过程中第一次出现的符合条件的节点，即为“最近”。

4. 参数：当前节点，p，q；返回值：节点；单层递归逻辑：根据传入节点的值，向左或向右寻找区间[p.val, q.val]；

递归法：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root.valp.val && root.val>q.val){
            return lowestCommonAncestor(root.left,p,q);
        }
        return root;
    }
}

迭代法：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while(true){
            if(root.val>p.val && root.val>q.val){
                root = root.left;
            } else if (root.val

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

力扣

思路：

1. 按照二叉搜索树的规则进行遍历，遇到空节点时插入节点；

2. 【递归】参数：根节点，要插入的数值；返回值：节点；终止条件：遍历到空节点时返回插入的节点；单层递归逻辑：若根节点数值>要插入的数值，递归，并将返回值赋给根节点的左子树；若根节点数值<要插入的数值，递归，并将返回值赋给根节点的右子树；

递归法：

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if(root == null) return new TreeNode(val);
        if(root.valval){
            root.left = insertIntoBST(root.left,val);
        }
        return root;
    }
}

迭代法：

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if(root == null) return new TreeNode(val);
        TreeNode newRoot = root;
        TreeNode pre = null;
        while(root!=null){//找到叶子结点时，退出循环
            pre = root;
            if(root.valval){
                root = root.left;
            }
        }
        if(pre.val>val){
            pre.left = new TreeNode(val);
        }else{
            pre.right = new TreeNode(val);
        }
        return newRoot;
    }
}

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

力扣

思路：

1. 【递归】参数：根节点，要删除的节点的数值；返回值：节点；

2. 终止条件：遇到空节点返回；

3. 单层递归逻辑：（1）没找到要删除的节点，遇到空节点直接返回；（2）叶子结点，直接删除，返回null为根节点；（3）待删除节点左空右不空，删除后右孩子补位，返回右孩子为根节点；待删除节点左不空右空，删除后左孩子补位，返回左孩子为根节点；（4）待删除节点左右都不为空，则将左孩子放到右子树的最左面节点的左孩子上，返回待删除节点的右孩子为新的根节点；

递归法：

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        return delete(root,key);
    }
    private TreeNode delete(TreeNode node, int key){
        if(node==null) return null;
        if(node.val>key){
            node.left=delete(node.left,key);
        } else if (node.val

递归法2：

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if(root==null) return root;
        if(root.val==key){
            if(root.left==null){
                return root.right;
            } else if(root.right==null){
                return root.left;
            } else {
                TreeNode cur = root.right;
                while(cur.left!=null) {
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
                }
            }
        if(root.val>key) root.left=deleteNode(root.left, key);
        if(root.val < key) root.right = deleteNode(root.right, key);
        return root;
    }
}