判断一颗树是否为二叉搜索树

  10
   /  \
  5   15     -------- binary tree (1)
     /  \
    6    20

假定当前结点值为k。对于二叉树中每个结点，判断其左孩子的值是否小于k，其右孩子的值是否大于k。如果所有结点都满足该条件，则该二叉树是一棵二叉搜索树。

很不幸的是，这个算法是错误的。考虑上面的二叉树，它符合上面算法的条件，但是它不是一棵二叉搜索树。

一开始就想了这个思路，想的太简单了！

方法1：

以前面提到的binary tree（1）为例，当我们从结点10遍历到右结点15时，我们知道右子树结点值肯定都在10和+INFINITY（无穷大）之间。当我们遍历到结点15的左孩子结点6时，我们知道结点15的左子树结点值都必须在10到15之间。显然，结点6不符合条件，因此它不是一棵二叉搜索树。该算法代码如下：

[java]  view plain  copy

1. isValidBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE)  

[java]  view plain  copy

1. public boolean isValidBST(BinaryTreeNode root, int min, int max) {  
2.         if (root == null)  
3.             return true;  
4.         if (root.value <= min || root.value >= max) {  
5.             return false;  
6.         }  
7.         return isValidBST_Two(root.pLeft, min, root.value)  
8.                 && isValidBST_Two(root.pRight, root.value, max);  
9.     }  

方法2：

中序遍历算法

因为一棵二叉搜索树的中序遍历后其结点值是从小到大排好序的，所以依此给出下面的解法。该解法时间复杂度也是O（n）。

[java]  view plain  copy

1. // 中序遍历，再判断数列是否递增  
2.     public boolean isValidBST(BinaryTreeNode root) {  
3.         ArrayList<Integer> alist = new ArrayList<Integer>();  
4.         preorder(root, alist);  
5.         Iterator<Integer> it = alist.iterator();  
6.         int current = Integer.MIN_VALUE;  
7.         while (it.hasNext()) {  
8.             int next = it.next();  
9.             if (current >= next) {  
10.                 return false;  
11.             }  
12.             current = next;  
13.         }  
14.         return true;  
15.     }  
16.   
17.     public void preorder(BinaryTreeNode root, ArrayList<Integer> alist) {  
18.         if (root == null)  
19.             return;  
20.         // if(root.pLeft!=null)  
21.         preorder(root.pLeft, alist);  
22.         alist.add(root.value);  
23.         // if(root.pRight!=null)  
24.         preorder(root.pRight, alist);  
25.     }