leetcode 98. 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.

Example 1:

    2
   / \
  1   3

Binary tree  [2,1,3] , return true.

Example 2:

    1
   / \
  2   3

Binary tree  [1,2,3] , return false.

Subscribe to see which companies asked this question.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isValidBST(TreeNode root) {
        mTreeNode mroot=help(root);
        help(mroot,root);
        return mark;
    }

    boolean mark = true;

    public mTreeNode help(TreeNode root) {
        if(root==null)return null;
        mTreeNode mroot=new mTreeNode(0,0);
        if(root.left==null&&root.right==null){
            mroot=new mTreeNode(root.val,root.val);
        }
        mroot.left=help(root.left);
        mroot.right=help(root.right);
        if(root.left!=null&&root.right==null){
            mroot.min=Math.min(root.val,mroot.left.min);
            mroot.max=Math.max(root.val,mroot.left.max);
        }else if(root.left==null&&root.right!=null){
            mroot.min=Math.min(root.val,mroot.right.min);
            mroot.max=Math.max(root.val,mroot.right.max);
        }else if(root.left!=null&&root.right!=null){
            mroot.min=Math.min(Math.min(root.val,mroot.left.min),Math.min(root.val,mroot.right.min));
            mroot.max=Math.max(Math.max(root.val,mroot.left.max),Math.max(root.val,mroot.right.max));
        }
        return mroot;
    }

    public void help(mTreeNode mroot,TreeNode root){
        if(mroot==null){return;}
        if(mroot.left!=null){
            if(mroot.left.max>=root.val){
                mark=false;
                return;
            }
        }
        if(mroot.right!=null){
            if(mroot.right.min<=root.val){
                mark=false;
                return;
            }
        }
        help(mroot.left,root.left);
        help(mroot.right,root.right);
    }
    
    static public class mTreeNode {
        int min;
        int max;
        mTreeNode left;
        mTreeNode right;

        mTreeNode(int x,int y) {
            min = x;
            max=y;
        }
    }
}