leetcode--Validate Binary Search Tree

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;
	}
}