[Java][LeetCode-98]樹

解法1：遞歸

    public boolean isValidBST(TreeNode root) {
        return validate(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }
    private boolean validate(TreeNode node, long min, long max){
        if(node == null){return true;}
        if(node.val <= min || node.val >= max){ return false;}
        return validate(node.left,min,node.val) && validate(node.right, node.val,max);
    }

解法2：迭代

class Solution {
  LinkedList<TreeNode> stack = new LinkedList();
  LinkedList<Integer> uppers = new LinkedList(),
          lowers = new LinkedList();

  public void update(TreeNode root, Integer lower, Integer upper) {
    stack.add(root);
    lowers.add(lower);
    uppers.add(upper);
  }

  public boolean isValidBST(TreeNode root) {
    Integer lower = null, upper = null, val;
    update(root, lower, upper);

    while (!stack.isEmpty()) {
      root = stack.poll();
      lower = lowers.poll();
      upper = uppers.poll();

      if (root == null) continue;
      val = root.val;
      if (lower != null && val <= lower) return false;
      if (upper != null && val >= upper) return false;
      update(root.right, val, upper);
      update(root.left, lower, val);
    }
    return true;
  }
}

解法3：BST中序遍歷遞增性

class Solution {

    public boolean isValidBST(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        double inorder = -Double.MAX_VALUE;
        while(!stack.isEmpty() || root != null){
            while( root!= null){
                stack.push(root);
                root = root.left;    
            }
            root = stack.pop();
            if(root.val <= inorder) {return false;}
            inorder = root.val;
            root = root.right;
        }
        return true;
    }

}

LeetCode鏈接

解法4：
遞歸+中序遍歷性質

class Solution {
 public boolean isValidBST(TreeNode root) {
    return validByInorderTraversal(root,new long[]{Long.MIN_VALUE});
  }
                                   
  private boolean validByInorderTraversal(TreeNode root,long[] prev){
      if(root == null)
          return true;
      if(!validByInorderTraversal(root.left,prev)){
          return false;
      }
      if(root.val <= prev[0]) 
          return false;
      
      prev[0] = root.val; 
      if(!validByInorderTraversal(root.right,prev)){
          return false;
      }
      return true;
  }                                 
    
}