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);
	}
}