98.验证二叉搜索树
98. 验证二叉搜索树 (中等)
题目描述
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/ \
1 3
输出: true
示例 2:
输入:
5
/ \
1 4
/ \
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。
题目解析
解法一: 递归
递归注意点: 判断二叉搜索树不能每次只判断当前节点和左右根节点, 而是要让当前节点大于左子树的最大值, 小于右子树的最小值, 才能保证全局最小.
// 获取二叉搜索树中最大值
public int getMaxValBST(TreeNode root) {
int max = root.val;
while (root != null) {
if (root.val > max) max = root.val;
root = root.right;
}
return max;
}
// 获取二叉搜索树中最小值
public int getMinValBST(TreeNode root) {
int min = root.val;
while (root != null) {
if (root.val < min) min = root.val;
root = root.left;
}
return min;
}
public boolean isValidBSTRecursive(TreeNode root) {
if (root == null) return true;
// 验证左子树
if (isValidBSTRecursive(root.left)) {
if (root.left != null) {
if (getMaxValBST(root.left) >= root.val) return false;
}
} else {
return false;
}
// 验证右子树
if (isValidBSTRecursive(root.right)) {
if (root.right != null) {
if (getMinValBST(root.right) <= root.val) return false;
}
} else {
return false;
}
return true;
}
解法二: 利用范围
我们可以从根节点进行 DFS，然后计算每个节点应该的取值范围，如果当前节点不符合就返回 false. 也就是利用根节点来去限定左右子节点的取值范围, 检查不通过就返回false.
例:
10
/ \
5 15
/ \ /
3 6 7
考虑 10 的范围
10(-inf,+inf)
考虑 5 的范围
10(-inf,+inf)
/
5(-inf,10)
考虑 3 的范围
10(-inf,+inf)
/
5(-inf,10)
/
3(-inf,5)
考虑 6 的范围
10(-inf,+inf)
/
5(-inf,10)
/ \
3(-inf,5) 6(5,10)
考虑 15 的范围
10(-inf,+inf)
/ \
5(-inf,10) 15(10,+inf）
/ \
3(-inf,5) 6(5,10)
考虑 7 的范围，出现不符合返回 false
10(-inf,+inf)
/ \
5(-inf,10) 15(10,+inf）
/ \ /
3(-inf,5) 6(5,10) 7（10,15）
// 利用范围判断
public boolean isValidBSTBound(TreeNode root) {
long minVal = (long)Integer.MIN_VALUE - 1;
long maxVal = (long)Integer.MAX_VALUE + 1;
return getAns(root, minVal, maxVal);
}
public boolean getAns(TreeNode root, long minVal, long maxVal) {
if (root == null) return true;
if (root.val <= minVal) return false;
if (root.val >= maxVal) return false;
return getAns(root.left, minVal, root.val) && getAns(root.right, root.val, maxVal);
}
解法三: 使用栈/队列模拟
BFS(DFS略)
public boolean isValidBST(TreeNode root) {
if (root == null || root.left == null && root.right == null) {
return true;
}
//利用三个队列来保存对应的节点和区间
Queue<TreeNode> queue = new LinkedList<>();
Queue<Integer> minValues = new LinkedList<>();
Queue<Integer> maxValues = new LinkedList<>();
//头结点入队列
TreeNode pNode = root;
queue.offer(pNode);
minValues.offer(null);
maxValues.offer(null);
while (!queue.isEmpty()) {
//判断队列的头元素是否符合条件并且出队列
Integer minValue = minValues.poll();
Integer maxValue = maxValues.poll();
pNode = queue.poll();
if (minValue != null && pNode.val <= minValue) {
return false;
}
if (maxValue != null && pNode.val >= maxValue) {
return false;
}
//左孩子入队列
if(pNode.left!=null){
queue.offer(pNode.left);
minValues.offer(minValue);
maxValues.offer(pNode.val);
}
//右孩子入队列
if(pNode.right!=null){
queue.offer(pNode.right);
minValues.offer(pNode.val);
maxValues.offer(maxValue);
}
}
return true;
}
解法四: 使用中序遍历
由于二叉搜索树BST的性质, 它的中序遍历序列将变成一个从小到大排序的序列, 因此我们只需要判断中序遍历序列是否为有序序列即可.
为了优化, 我们只需要在每一次遍历的时候与上一次遍历到的数据进行比较, 不合法直接返回false.
// 利用中序遍历序列
public boolean isValidInorder(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
TreeNode pre = null;
while (root != null || !stack.isEmpty()) {
// 压栈
while (root != null) {
stack.push(root);
root = root.left;
}
// 出栈
root = stack.pop();
if (pre != null && root.val <= pre.val) return false;
pre = root;
root = root.right;
}
return true;
}