Given a binary tree, determine if it is a valid binary search tree (BST).
Assume a BST is defined as follows:
- The left subtree of a node contains only nodes with keys less than the node's key.
- The right subtree of a node contains only nodes with keys greater than the node's key.
- Both the left and right subtrees must also be binary search trees.
confused what "{1,#,2,3}"
means? > read more on how binary tree is serialized on OJ.
public class Solution {
/**
* A simple method is the following: do inorder traversal and then check if the values are in ascending order.
* @param root --TreeNode, the root node of a tree
* @return boolean. true if the input tree is a valid binary search tree, otherwise, false
* @author Averill Zheng
* @version 2014-06-10
* @since JDK 1.7
*/
public boolean isValidBST(TreeNode root){
boolean isValid = true;
Stack<TreeNode> nodes = new Stack<TreeNode>();
List<Integer> values = new ArrayList<Integer>();
if(root != null){
putNodesInStack(root, nodes);
while(!nodes.empty()){
TreeNode aNode = nodes.pop();
values.add(aNode.val);
if(aNode.right != null)
putNodesInStack(aNode.right, nodes);
}
}
if(!values.isEmpty()){
int size = values.size();
int first = values.get(0);
for(int i = 1; i < size; ++i){
if(first >= values.get(i)){
isValid = false;
break;
}
else
first = values.get(i);
}
}
return isValid;
}
private void putNodesInStack(TreeNode root, Stack<TreeNode> nodes){
while(root != null){
nodes.push(root);
if(root.left != null)
root = root.left;
else
root = null;
}
}
}
Another recursive solution:
public class Solution {
public boolean isValidBST(TreeNode root){
boolean isValid = true;
if(root != null)
isValid = checkHelper(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
return isValid;
}
private boolean checkHelper(TreeNode root, int min, int max){
boolean isValid = true;
if(root != null){
if(root.val <= min || root.val >= max)
isValid = false;
else{
if(root.left != null){
int leftMin = Math.max(Integer.MIN_VALUE, min);
int leftMax = Math.min(root.val, max);
isValid &= checkHelper(root.left, leftMin, leftMax);
}
if(root.right != null){
int rightMin = Math.max(root.val, min);
int rightMax = Math.min(Integer.MAX_VALUE, max);
isValid &= checkHelper(root.right, rightMin, rightMax);
}
}
}
return isValid;
}
}