20150624 lintcode 总结 Validate Binary Search Tree

Validate Binary Search Tree

题目：http://www.lintcode.com/en/problem/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.   

Solution 1:

/**

 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
 

public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: True if the binary tree is BST, or false
     */
    public boolean isValidBST(TreeNode root) {
        // write your code here
        if(root==null){
     return true;
     }
        VBST result = helper(root);
        if (result.isValid()){
         return true;
        }else{
         return false;
        }
        
    }
    

    public  VBST helper(TreeNode root){
        
     VBST res = new VBST(root, true, 0, 0);
     int max=0;
     int min=0;
     
     if(root.left==null && root.right==null){
     res.setMax(root.val);
     res.setMin(root.val);
     return res;
     }else if(root.left==null){
         min=root.val;        
        }else if(root.right == null){
         max=root.val;      
        }
        
        //check root vs sub-tree
        if(root.left!=null){
     VBST vleft = helper(root.left);
         if(!vleft.isValid() || vleft.getMax()>=root.val){
         res.setValid(false);
         return res;
         }
         min=vleft.getMin();
        } 
        
        if(root.right!=null){
        VBST vright = helper(root.right);
        if(!vright.isValid()|| vright.getMin()<=root.val ){
     res.setValid(false);
     return res;
        }
        max=vright.getMax();
        }
        
        res.setMax(max);
        res.setMin(min);
        return res;


    } 
    
    public class VBST{
        private TreeNode root;
     private boolean valid;
        private int min;
        private int max;
        
        public VBST(TreeNode root, boolean valid, int min, int max){
            super();
            this.root = root;
            this.valid = valid;
            this.min = min;
            this.max = max;
        }
    
     public TreeNode getRoot() {
     return root;
     }
    
     public void setRoot(TreeNode root) {
     this.root = root;
     }
     
     public boolean isValid() {
     return valid;
     }
    
     public void setValid(boolean valid) {
     this.valid = valid;
     }
    
     public int getMin() {
     return min;
     }
    
     public void setMin(int min) {
     this.min = min;
     }
    
     public int getMax() {
     return max;
     }
    
     public void setMax(int max) {
     this.max = max;
     }
   
    }
    
    
}

总结：这方法并不是很好，但是过了。构造一个vBST的类，包含root, valid, max, min。当root==null的时候不max和min的设置会引起麻烦，所以避开了root==null的情况，但这样也使递归不方便。再想一个可以包括root==null的情况的方法....