二叉查找树

http://www.lintcode.com/zh-cn/problem/validate-binary-search-tree/#

错误点：1.　helper函数里先要判断 if(!left.isBst || !right.isBst)

　　　　2.　minVal 和maxVal的选择要选好。

注意点： 平衡二叉查找树  balanced BST   增删改查复杂度 O(n)

　　　　 BST 复杂度O(h)  h= 二叉树深度

类似中序遍历的解法：

(中序遍历)　　

ArrayList<Integer> result = new ArrayList<Integer>();
public ArrayList<Integer> inorderTraversal(TreeNode root) {
if(root == null) return result;
inorderTraversal(root.left);
result.add(root.val);
inorderTraversal(root.right);
return result;
}

public boolean isValidBST(TreeNode root) { 
    if(root == null) return true;
    if(root.left != null && root.val <= root.left.val) return false;
    if(!isValidBST(root.left)) return false;
    if(root.right != null){
        if(root.val >= root.right.val) return false;
    }
    if(!isValidBST(root.right)) return false;
    return true;
    10
  5   15
     6    20
}
//-----------------------------------------------------
private TreeNode lastNode = null;
public boolean isValidBST(TreeNode root) { 
    if(root == null) return true;
    if(!isValidBST(root.left)) return false;
    if(lastNode !=null && root.val <= lastNode.val) return false;
    lastNode = root;
    if(!isValidBST(root.right)) return false;
    return true;
}
//-------------------------------------------------------------------
class ResultType {
    private int minVal, maxVal;
    private boolean isBst;
    public ResultType(boolean isBst, int maxVal, int minVal) {
        this.isBst = isBst;
        this.maxVal = maxVal;
        this.minVal = minVal;
    }
}
public boolean isValidBST(TreeNode root) { 
    if(root == null) return true;
    return helper(root).isBst;
    
}
private ResultType helper(TreeNode root) {
    if(root == null) return new ResultType(true, Integer.MIN_VALUE, Integer.MAX_VALUE);
    ResultType left = helper(root.left);
    ResultType right = helper(root.right);
    if(!left.isBst) return new ResultType(false, 0, 0);
    if(!right.isBst) return new ResultType(false, 0, 0);
    int minVal = Math.min(root.val,left.minVal);
    int maxVal = Math.max(root.val, right.maxVal);
    if(root.left != null && root.val <= left.maxVal || root.right != null && root.val >= right.minVal)
        return new ResultType(false, 0, 0);
    return new ResultType(true, maxVal, minVal);
}

 int lastVal = Integer.MIN_VALUE;
 boolean firstNode = true;      //就是为了排除就1个结点，且值为MIN_VALUE的情况。
 public boolean isValidBST(TreeNode root) {
     if(root == null) return true;
     if(!isValidBST(root.left)) return false;   //相当于从上一直往左下遍历，遍历到头，相当于已经走过了左子和root,就是中序遍历的过程
     if(!firstNode && lastVal >= root.val) return false;
     firstNode = false;
     lastVal = root.val;
     if(!isValidBST(root.right)) return false;
     return true;
 }

分治

class ResultType {
     boolean isBST;
     int minVal, maxVal;
     public ResultType(boolean isBST, int minVal, int maxVal) {
         this.isBST = isBST;
         this.minVal = minVal;
         this.maxVal = maxVal;     
     }
 }
 private ResultType helper(TreeNode root) {
     if(root == null) {
         return new ResultType(true, Integer.MAX_VALUE, Integer.MIN_VALUE);  //空结点，不要对非空结点的max，min值产生影响。
     }
     ResultType left = helper(root.left);
     ResultType right = helper(root.right);
     if(!left.isBST || !right.isBST) {
         return new ResultType(false, 0, 0); //已经是false了，minVal 和maxVal取什么值无所谓，反正不会用它去比较。
     }
     if(root.left!= null &&left.maxVal >= root.val || root.right != null &&right.minVal <= root.val) return new ResultType(false, 0, 0);
     return new ResultType(true, Math.min(root.val, left.minVal), 
                                 Math.max(root.val, right.maxVal));
 }
  public boolean isValidBST(TreeNode root) {
    // write your code here
    return helper(root).isBST;
}
    
//第一次的想法，if条件设太多了，应该逐层考虑，不然各种条件分情况分不过来。-------------------------
    private void helper(TreeNode root) {
        if(root  == null || (root.left ==null && root.right == null) ) return true;
        if(root.left == null){
            if(root.val >= root.right.val) return false;
        }
        if(root.right == null){
            if(root.val <= root.left.val) return false;
        }
        if(root.right != null & root.left != null) {
            if(!(root.val > root.left.val && root.val < root.right.val)) return false;
        }
        return helper(root.left ) && helper(root.right);    
    }