LeetCode之二叉搜索树

530. 二叉搜索树的最小绝对差

/**
 * 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 {
    // 用于存储前一个节点的值
    int pre;
    // 用于存储当前最小差值
    int ans;

    public int getMinimumDifference(TreeNode root) {
        // 初始化前一个节点值为-1（表示未设置）
        pre = -1;
        // 初始化最小差值为最大值
        ans = Integer.MAX_VALUE;
        // 调用深度优先搜索方法
        dfs(root);
        // 返回最小差值
        return ans;
    }

    private void dfs(TreeNode root) {
        if (root == null) {
            // 如果当前节点为空，返回
            return;
        }
        // 先遍历左子树
        dfs(root.left);

        // 处理当前节点
        if (pre == -1) {
            // 如果前一个节点的值未设置，设置为当前节点的值
            pre = root.val;
        } else {
            // 更新最小差值
            ans = Math.min(ans, root.val - pre);
            // 更新前一个节点的值为当前节点的值
            pre = root.val;
        }
        // 接着遍历右子树
        dfs(root.right);
    }
}

230. 二叉搜索树中第 K 小的元素

/**
 * 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 int kthSmallest(TreeNode root, int k) {
        // 创建一个列表用于存储二叉搜索树中节点的值
        List<Integer> result = new ArrayList<>();
        // 调用辅助方法来填充列表
        helper(root, result);
        // 返回列表中第 k 小的元素（列表索引从 0 开始，所以 k-1）
        return result.get(k - 1);
    }

    public void helper(TreeNode root, List<Integer> result) {
        // 如果当前节点为空，直接返回
        if (root == null) {
            return;
        }
        // 递归遍历左子树
        helper(root.left, result);
        // 将当前节点的值添加到列表中
        result.add(root.val);
        // 递归遍历右子树
        helper(root.right, result);
    }

}

98. 验证二叉搜索树

/**
 * 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 boolean isValidBST(TreeNode root) {
        // 入口调用辅助方法，传入最小可能值和最大可能值，这里使用 Long 类型的最小最大值代表无穷小和无穷大
        return helper(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public boolean helper(TreeNode root, long lower, long upper) {
        // 根据二叉搜索树的性质，左子树的值小于根节点，右子树的值大于根节点
        // 递归地判断当前节点的值是否在给定的上下限范围内

        // 边界条件，如果当前节点为 null，说明已经遍历到叶子节点的子节点，可认为是合法的二叉搜索树，返回 true
        if (root == null) {
            return true;
        }

        // 如果当前节点的值小于等于下限或者大于等于上限，说明不是合法的二叉搜索树，返回 false
        if (root.val <= lower || root.val >= upper) {
            return false;
        }

        // 递归检查左子树，左子树的所有节点值应该小于当前节点值，所以上限变为当前节点值
        // 递归检查右子树，右子树的所有节点值应该大于当前节点值，所以下限变为当前节点值
        return helper(root.left, lower, root.val) && helper(root.right, root.val, upper);
    }

}