Validate Binary Search Tree 解答

Question

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 -- Recursive

According to the question, we can write recursive statements. Note here whole left/right subtree should be smaller/greater than the root.

 /**
  * 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) {
         if (root == null)
             return true;
         if (root.left != null && !smallerThanRoot(root, root.left))
             return false;
         if (root.right != null && !greaterThanRoot(root, root.right))
             return false;
         if (isValidBST(root.left) && isValidBST(root.right))
             return true;
         return false;
     }

     private boolean greaterThanRoot(TreeNode root, TreeNode child) {
         if (child.val <= root.val)
             return false;
         if (child.left != null) {
             if (!greaterThanRoot(root, child.left))
                 return false;
         }
         if (child.right != null) {
             if (!greaterThanRoot(root, child.right))
                 return false;
         }
         return true;
     }

     private boolean smallerThanRoot(TreeNode root, TreeNode child) {
         if (child.val >= root.val)
             return false;
         if (child.left != null) {
             if (!smallerThanRoot(root, child.left))
                 return false;
         }
         if (child.right != null) {
             if (!smallerThanRoot(root, child.right))
                 return false;
         }
         return true;
     }
 }

Solution 2 -- Inorder Traversal

Inorder traversal of BST is an ascending array. Java Stack

 /**
  * 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) {
         // This problem can be looked as inorder traversal problem
         // Inorder traversal of BST is an ascending array
         List<Integer> inOrderResult = new ArrayList<Integer>();
         Stack<TreeNode> stack = new Stack<TreeNode>();
         TreeNode tmp = root;
         while (tmp != null || !stack.empty()) {
             if (tmp != null) {
                 stack.push(tmp);
                 tmp = tmp.left;
             } else {
                 TreeNode current = stack.pop();
                 inOrderResult.add(current.val);
                 tmp = current.right;
             }
         }
         // Traverse list
         if (inOrderResult.size() < 1)
             return true;
         int max = inOrderResult.get(0);
         for (int i = 1; i < inOrderResult.size(); i++) {
             if (inOrderResult.get(i) > max)
                 max = inOrderResult.get(i);
             else
                 return false;
         }
         return true;
     }
 }