LeetCode OJ：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.

一开始是这样做的：

 class Solution {
 public:
     bool isValidBST(TreeNode* root) {
        return checkValid(root, INT_MIN, INT_MAX);
     }

     bool checkValid(TreeNode * root, int left, int right)
     {
         if(root == NULL)
             return true;
         return(root->val > left && root->val < right && checkValid(root->left, left, root->val) ]
             && checkValid(root->right, root->val, right));
     }
 };

然而并不能通过，因为leetCode增加了两个新的测试用例，把INT_MAX以及INT_MIN也囊括进去了。

那么就只好用中序遍历的方法来了(一开始想的是先中序遍历一遍，然后根据遍历的到的值是不是升序排列的来判断这个二叉树是不是BST，但是后来发现传入一个引用的参数可以实现一边递归一边比较)，代码如下：

 class Solution{
 public:
     bool isValidBST(TreeNode* root) {
         TreeNode * helper = NULL;
         return inOrder(root, helper);
     }

     bool inOrder(TreeNode * root, TreeNode * & prev){//注意这里的是引用
         if(root == NULL)
             return true;
         bool left = inOrder(root->left, prev);
         if(prev != NULL && prev->val >= root->val)
             return false;
         prev = root;
         bool right = inOrder(root->right, prev);
         return left && right;
     }
 };

当然上面的也可以采用迭代的方式来做:

 class Solution {
 public:
     bool isValidBST(TreeNode* root) {
         stack<TreeNode *> s;
         TreeNode * pre = NULL;
         if(root == NULL)
             return true;
         while(root || !s.empty()){
             while(root != NULL){
                 s.push(root);
                 root = root->left;
             }

             root = s.top();
             s.pop();
             if(pre != NULL && root->val <= pre->val) return false;

             pre = root;
             root = root->right;
         }
         return true;
     }
 };

下面是java版本的代码，首先还是不可行的Integer.MAX_VALUE方法，但是还是贴下吧：

 /**
  * 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) {
         return checkValid(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
     }

     boolean checkValid(TreeNode root, int left, int right){
         if(root == null)
             return true;
         if(root.val <= left || root.val >= right){
             return false;
         }
         return checkValid(root.left, left, root.val)
             && checkValid(root.right, root.val, right);
     }
 }

那么只有遍历树了，然后来判断, 这里使用非递归的方法来写:

 public class Solution {
     public boolean isValidBST(TreeNode root) {
         Stack<TreeNode> stack = new Stack<TreeNode>();
         HashMap<TreeNode, Integer> map = new HashMap<TreeNode, Integer>();
         List<Integer> list = new ArrayList<Integer>();
           if(root == null)
             return true;
           stack.push(root);
           while(!stack.isEmpty()){
               TreeNode node = stack.peek();
               while(node.left != null && !map.containsKey(node.left)){
                   stack.push(node.left);
                   map.put(node.left, 1);
                   node = node.left;
               }
               stack.pop();
               list.add(node.val);
               if(node.right != null && !map.containsKey(node.right)){
                   stack.push(node.right);
                   map.put(node.right, 1);
               }
           }
           for(int i = 0; i < list.size() - 1; ++i){
               if(list.get(i) >= list.get(i+1))
                 return false;
           }
           return true;
     }
 }