4.5问题：

实现一个函数，检查一棵树是否为二叉查找树。

思考：

方法一：看到此题，闪过的第一个想法就是中序遍历，将所有的元素复制到数组中，然后检查数组是否有序。这种解法要多用一点儿内存，大部分情况下都没问题。唯一的问题是，它无法处理树中的重复值。例如，该算法无法区分下面这两棵树，因为这两者的中序遍历是一样的。

Valid BST [20.left = 20]

Invalid BST [20.right = 20]

要是假定这棵树不得包含重复值，那么这种做法还是行之有效的。

    //(中序遍历)判断二叉树是否为二叉查找树。限制条件为：该二叉树里面没有重复数值的结点。
    public static int last_printed = Integer.MIN_VALUE;
    public static boolean checkBST(Node n){
        if(n == null) return true;
        if(!checkBST(n.leftChild)) return false;
        if(n.data<=last_printed) return false;
        last_printed =  n.data;
        if(!checkBST(n.rightChild)) return false;
        return true;
    }

方法二：

一棵什么样的树才能成为二叉查找树？我们知道这棵树必须满足以下条件：对于每个结点，left.data<=current.data<right.data，但是这样还不够。更准确的说，成为二叉查找树的条件是：所有左边的结点必须小于或等于当前结点，而当前结点必须小于所有的右边的结点。

利用这一点，我们可以通过自上而下传递最小和最大值来解决这个问题。在迭代遍历整个树的过程中，我们会用逐渐变窄的范围来检查各个节点。

首先，从（min=int_min,max =int_max）这个范围开始，根节点显然落在其中。然后处理左子树，检查这些结点是否落在（min = int_min,max=root.data）范围内。然后在处理右子树，检查结点是否落在（min=root.data,max=int_max）范围内。然后，继续依此遍历整棵树。

    //最小、最大法。
    boolean checkBST2(Node n,int min,int max){
        if(n == null) return true;
        if(n.data<min || n.data >= max) return false;
        if(!checkBST2(n.leftChild,min,n.data) || !checkBST2(n.rightChild,n.data,max)) return false;
        return true;
    }
    boolean checkBST2(Node root){//重载
        return checkBST2(root,Integer.MIN_VALUE,Integer.MAX_VALUE);
    }

注意，在递归算法中，一定要确定种植条件以及结点为空的情况得到妥善的处理。

完整测试代码：

import java.util.*;
 
class Node {
    Node leftChild;
    Node rightChild;
    int data;
    
    Node(int newData) {//构造方法
        leftChild = null;
        rightChild = null;
        data = newData;
    }
}

class BinTreeTraverse{//创建的为完全二叉树。
    public static Node createMinimalBST(int arr[],int start,int end){
        if(end<start){
            return null;
        }
        int mid = (start+end)/2;
        Node n = new Node(arr[mid]);
        n.leftChild = createMinimalBST(arr,start,mid - 1);
        n.rightChild = createMinimalBST(arr,mid + 1,end);
        return n;
    }
    public static Node createMinimalBST(int array[]){//方法重载
        return createMinimalBST(array,0,array.length - 1);
    }
    
    //(中序遍历)判断二叉树是否为二叉查找树。限制条件为：该二叉树里面没有重复数值的结点。
    public static int last_printed = Integer.MIN_VALUE;
    public static boolean checkBST(Node n){
        if(n == null) return true;
        if(!checkBST(n.leftChild)) return false;
        if(n.data<=last_printed) return false;
        last_printed =  n.data;
        if(!checkBST(n.rightChild)) return false;
        return true;
    }
    
    //最小、最大法。
    boolean checkBST2(Node n,int min,int max){
        if(n == null) return true;
        if(n.data<min || n.data >= max) return false;
        if(!checkBST2(n.leftChild,min,n.data) || !checkBST2(n.rightChild,n.data,max)) return false;
        return true;
    }
    boolean checkBST2(Node root){//重载
        return checkBST2(root,Integer.MIN_VALUE,Integer.MAX_VALUE);
    }
    
    /**
     * 先序遍历
     */
    public static void preOrderTraverse(Node node){
        if (node == null)
            return;
        System.out.print(node.data + " ");
        preOrderTraverse(node.leftChild);
        preOrderTraverse(node.rightChild);
    }

    /**
     * 中序遍历
     */
    public static void inOrderTraverse(Node node) {
        if (node == null)
            return;
        inOrderTraverse(node.leftChild);
        System.out.print(node.data + " ");
        inOrderTraverse(node.rightChild);
    }

    /**
     * 后序遍历
     */
    public static void postOrderTraverse(Node node) {
        if (node == null)
            return;
        postOrderTraverse(node.leftChild);
        postOrderTraverse(node.rightChild);
        System.out.print(node.data + " ");
    }
}

class checkBST{
    public static void main(String[] args){
        int array[]=new int[9];
        for(int i=0;i<array.length;){
            array[i]=++i;
        }
        
        //建立二叉树以及遍历
        System.out.println("二叉树建立以及遍历：");
        BinTreeTraverse binTree = new BinTreeTraverse();
        Node root = binTree.createMinimalBST(array);
        
        System.out.println("先序遍历：");
        binTree.preOrderTraverse(root);
        System.out.println();
        
        System.out.println("中序遍历：");
        binTree.inOrderTraverse(root);
        System.out.println();
        
        System.out.println("后序遍历：");
        binTree.postOrderTraverse(root);
        
        System.out.println();
        if(binTree.checkBST2(root)){
            System.out.println("是二叉查找树");
        }else{
            System.out.println("不是二叉查找树");
        }
        
        System.exit(0);
    }
}