Leetcode 刷题笔记(十六) —— 二叉树篇之二叉搜索树的属性

系列文章目录

一、 数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十 一、栈与队列篇之 top-K 问题
十 二、二叉树篇之二叉树的前中后序遍历
十 三、二叉树篇之二叉树的层序遍历及相关题目
十 四、二叉树篇之二叉树的属性相关题目
十 五、 二叉树篇之二叉树的修改与构造
更新中 … …

---

前言

刷题路线来自 ：代码随想录

题录

700. 二叉搜索树中的搜索

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

示例 1:
输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

Example 2:
输入：root = [4,2,7,1,3], val = 5
输出：[]

题解：
方式一：当作普通的二叉树进行递归遍历

class Solution {
    TreeNode res = null;
    public TreeNode searchBST(TreeNode root, int val) {
        dfs(root, val);
        return res;
    }
    public void dfs (TreeNode root, int val) {
    	// 前序遍历找到结点
        if (root == null) return;
        if (root.val == val) res = root;
        dfs(root.left, val);
        dfs(root.right, val);
    }
}

带返回值的递归：返回和 val 相等的结点

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        return dfs(root, val);
    }
    public TreeNode dfs (TreeNode root, int val) {	
        if (root == null) return null;
        // 找到结点直接返回
        if (root.val == val) return root;
        // 递归左子树
        TreeNode left =  dfs (root.left, val);
        if (left != null) {
        	// 如果左子树找到结点，继续返回该结点
            return left;
        }
        // 没有找到，递归右子树
        return dfs(root.right, val);
    }
}

方式二：迭代法
根据二叉搜索树的左小右大性质，去觉得去左子树搜索还是去右子树搜索

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

方式三：利用二叉搜索树的性质递归

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        return dfs(root, val);
    }
    public TreeNode dfs (TreeNode root, int val) {
        if (root == null) return null;
        // 相等返回结点
        if (root.val == val) return root;
        if (root.val > val) {
            return dfs(root.left, val);
        } else {
            return dfs(root.right, val);
        }
    }
}

98. 验证二叉搜索树

Leetcode 链接
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：
输入：root = [2,1,3]
输出：true

示例 2：
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

题解：
易错点：

1. 遍历时只判断局部的左中右结点大小。二叉搜索树子树根结点值大于左子树所有结点的值。如：[3, 2, null, 1, 4] 中 1 2 4 局部满足二叉搜索树特点。但是 4 大于根节点 3，不是二叉搜索树。所以我们根据二叉搜索树的属性：中序遍历结果是递增的，遍历时保存上一个数进行比较即可。
2. 越界问题，如 [-2147483648] 应返回 true，如果 max 使用 int 类型，初始化肯定为Integer.MIN_VALUE，结果等于最大值返回了 false。

class Solution {
	// 使用 long，防止第一个结点为 int 最小值，相等后返回 false
    long max = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        // 左
        boolean left = isValidBST(root.left);
        if (left == false) {
            return false;
        }
        // 中
        if (max >= root.val) {
        	// 不满足二叉搜索树的性质
            return false;
        }
        // 保存结点的值
		max = root.val;
		// 右
        return left && isValidBST(root.right);
    }
}

优化：
可以使用 TreeNode 结点，初始化为 null，递归时候就知道是否第一次访问

class Solution {
    TreeNode max = null;
    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        // 左
        boolean left = isValidBST(root.left);
        if (left == false) {
            return false;
        }
        // 中
        if (max != null && max.val > root.val) {
        	不是第一次访问，并且中序遍历不是递增的
        	return false;
        }
        max = root;
        // 右
        return left && isValidBST(root.right);
    }
}

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

Leetcode 链接
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。差值是一个正数，其数值等于两值之差的绝对值。

示例 1：
输入：root = [4,2,6,1,3]
输出：1

示例 2：
输入：root = [1,0,48,null,null,12,49]
输出：1

题解：
利用性质：中序遍历结果是递增的

class Solution {
    TreeNode pre = null;
    int res = Integer.MAX_VALUE;
    public int getMinimumDifference(TreeNode root) {
        dfs(root);
        return res;
    }
    public void dfs(TreeNode root) {
        if (root == null) return;
        // 左
        dfs(root.left);
        // 中
        if (pre != null) {
        	// 不是第一次访问，取当前结点与上一个结点的差，和最小差中最小的
            res = Math.min(res, root.val - pre.val);
        }
        pre = root;
        // 右
        dfs(root.right);
    }
}

501. 二叉搜索树中的众数

Leetcode 链接
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

示例 1：
输入：root = [1,null,2,2]
输出：[2]

示例 2：
输入：root = [0]
输出：[0]

题解：
同样是中序遍历，使用 maxCount 来记录当初出现次数最多的结点值，count 来记录当前结点值出现次数，pre 记录上一个结点，用来和当前结点比较是不是 val 相等

class Solution {
    int count = 0;
    int maxCount = 0;
    TreeNode pre = null;
    List<Integer> res = new ArrayList<>();
    public int[] findMode(TreeNode root) {
        dfs(root);
        int[] resArr = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            resArr[i] = res.get(i);
        }
        return resArr;
    }
    public void dfs(TreeNode root) {
        if (root == null) return;
        // 左
        dfs(root.left);
        // 中   
        if (pre == null || root.val == pre.val) {
        	// 如果是第一次访问，或者和前一个结点值相等
            count++;
        } else {
        	// 不是第一次访问并且与前一个不相等，当前结点 val 出现次数 1
            count = 1;
        }
        if (count > maxCount) {
        	// 当前结点 val 出现次数大于出现次数最多的结点 val,清除返回列表 res
            res.clear();
            // 添加当前结点进去，并更新 maxCount 
            res.add(root.val);
            maxCount = count;
        } else if (count == maxCount) {
        	// 如果和 maxCount 相等，添加当前结点到返回列表
            res.add(root.val);
        }
        // 更新 pre 结点
        pre = root;
        // 右
        dfs(root.right);
    }
}

总结

1. 以二叉搜索树任何一个结点为根节点，左孩子小于根节点，右孩子大于根节点，并且左子树所有结点值都小于根节点值，右子树所有值都大于根节点值。做题时要注意只是局部满足小中大的关系是不行的
2. 中序遍历结果是递增的
3. 关于递归中用到是参数是使用形参传递的方式还是定义为全局变量
   全局变量：特点是任何一层递归访问和修改都是同步的，如返回值，二叉搜索树中的众数中的 count、pre。而像之前的深度就适合放在递归函数的参数中，这样的话向下递归之前的 deep 回退到这层时还是相等的。