数据结构与算法 ——二叉搜索树

二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性：
每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。
每个节点中的值必须小于（或等于）存储在其右子树中的任何值。

验证二叉搜索树

/**
 1. Definition for a binary tree node.
 2. public class TreeNode {
 3.     int val;
 4.     TreeNode left;
 5.     TreeNode right;
 6.     TreeNode(int x) { val = x; }
 7. }
 */
class Solution {
     public boolean isValidBST(TreeNode root) {
        return isValidBST(root, null, null);
    }
    public boolean isValidBST(TreeNode root,TreeNode min,TreeNode max){
        if (root == null) return true; 
        if (min != null && root.val <= min.val) return false;
        if (max != null && root.val >= max.val) return false; 
        return isValidBST(root.left, min, root) 
                && isValidBST(root.right, root, max);

    }    
}

在二叉搜索树中实现搜索操作
根据BST的特性，对于每个节点：

1. 如果目标值等于节点的值，则返回节点；
2. 如果目标值小于节点的值，则继续在左子树中搜索；
3. 如果目标值大于节点的值，则继续在右子树中搜索。

给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。

/**
 1. Definition for a binary tree node.
 2. public class TreeNode {
 3.     int val;
 4.     TreeNode left;
 5.     TreeNode right;
 6.     TreeNode(int x) { val = x; }
 7. }
 */
class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null ||root.val == val) return root;
        if(root.val < val){
            return searchBST(root.right,val);
        }else{
            return searchBST(root.left,val);
        }
    }
}

在二叉搜索树中实现插入操作
与搜索操作类似，对于每个节点，我们将：

1. 根据节点值与目标节点值的关系，搜索左子树或右子树；
2. 重复步骤 1 直到到达外部节点；
3. 根据节点的值与目标节点的值的关系，将新节点添加为其左侧或右侧的子节点。

给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。
输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。
注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。

/**
 * 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);
        if(root.val < val) 
            root.right =  insertIntoBST(root.right,val);
        if(root.val > val) 
            root.left = insertIntoBST(root.left,val);
        return root;
    }
}

在二叉搜索树中实现删除操作
根据其子节点的个数，我们需考虑以下三种情况：

1. 如果目标节点没有子节点，我们可以直接移除该目标节点。
2. 如果目标节只有一个子节点，我们可以用其子节点作为替换。
3. 如果目标节点有两个子节点，我们需要用其中序后继节点或者前驱节点来替换，再删除该目标节点。

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key
对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点； 如果找到了，删除它。

/**
 * 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 null; 
        if (root.val == key) {
            // 这两个 if 把情况 1 和 2 都正确处理了   
            if (root.left == null) return root.right; 
            if (root.right == null) return root.left;
            // 处理情况 3 
            TreeNode minNode = getMin(root.right); 
            root.val = minNode.val;
            root.right = deleteNode(root.right, minNode.val);
        } else if (root.val > key) { 
            root.left = deleteNode(root.left, key); 
        } else if (root.val < key) { 
            root.right = deleteNode(root.right, key); 
        }
        return root;
    }
    TreeNode getMin(TreeNode node) {
         // BST 最左边的就是最⼩的 
         while (node.left != null) 
            node = node.left;
            return node;
        }
}

总结于力扣