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

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

1. 学习链接：
2. 思路：二叉搜索树最大的特点就是有序，因此相较于二叉树的最近公共祖先，要更简单些。
3. 代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
        //如根据二叉搜索树的特点，果某节点为p和q的公共祖先，则其值一定会在[p, q]区间之内。
        if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
        return root;
        //满足该节点的值在[p, q]区间之内，返回。
    }
}

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

1. 学习链接：
2. 思路：寻找插入节点的上一个节点。可用新节点进行记录上一节点。
3. 代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) return new TreeNode(val);
        TreeNode pre = null;	//定义指针，用来保存插入节点的上一节点。
        TreeNode cur = root;	//定义操作节点。

        //寻找可插入节点的上一节点，并用pre记录
        while (cur != null) {
            pre = cur;			//保存上一节点
            if (cur.val > val) {
                cur = cur.left;
            } else if (cur.val < val) {
                cur = cur.right;
            }
        }

        //寻找到插入位置，通过比较新节点与上一节点的值，将其插入到左孩子位置或者右孩子位置。
        TreeNode node = new TreeNode(val);
        if (pre.val < val) {
            pre.right = node;
        } else if (pre.val > val) {
            pre.left = node;
        }
        return root;
    }
}

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

1. 学习文章链接：
2. 思路：删除节点的五种情况要分清
   1. 暂未找到删除节点
   2. 已找到删除节点（无左右孩子）
   3. 已找到删除节点（无右孩子）
   4. 已找到删除节点（无左孩子）
   5. 已找到删除节点（孩子都在）
      1. 寻找到删除节点右孩子的最下角的节点。
      2. 将删除节点的左孩子整体充当第一步寻找节点的左孩子。
      3. 将删除节点的右孩子移到删除节点的右孩子。
3. 代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        //第一种情况
        if (root == null) return root;
        
        if (root.val > key) {
            root.left = deleteNode(root.left, key);
        } else if (root.val < key) {
            root.right = deleteNode(root.right, key);
        } else {
            //
            if (root.left == null && root.right == null) {
                //第二种情况
                return null;
            } else if (root.right == null && root.left != null) {
                //第三种情况
                return root.left;
            } else if (root.right != null && root.left == null) {
                //第四种情况
                return root.right;
            } else {
                //第五种情况
                TreeNode cur = root.right;
                while(cur.left != null) {
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
            }
        }
        return root;
    }
}