概念：每个结点都比左儿子大，比右儿子小，严格的搜索二叉树没有重复的值

法一： 

/*
* 概念：每个结点都比左儿子大，比右儿子小，严格的搜索二叉树没有重复的值
step:   1)中序遍历得到的数组的升序的
*/
int preData = INT_MIN;
bool isBST(Node* head) {
	if (head == NULL)
		return true;
	bool isLeftBST = isBST(head->left);
	if (!isLeftBST)//如果左树不是，就直接返回false
		return false;
	if (preData >= head->data)//如果根的data比左的小，就返回false
		return false;
	else {
		preData = head->data;
	}
	return isBST(head->right);
}

法二：（思路与法一差不多)

//判断是否为搜索二叉树2
#include<list>
#include<algorithm>
bool isBST2(Node* head) {
	if (head == NULL)
		return false;
	list<int> L;
	process(head, L);
	int sz = L.size();
	list<int>::iterator end = --L.end();
	for (list<int>::iterator it = L.begin();it != end;)
		if (*it >= *(++it))
			return false;
	return true;
}
void process(Node* head, list<int>& L) {
	if (head == NULL)
		return;
	process(head->left, L);
	L.push_back(head->data);
	process(head->right, L);
}

法三：

递归

/*
条件：左右子树均是搜索二叉树，且左边max<根值，右边min>根值
注意：要递归则每次规模必须一样，而左边寻找的是max，右边寻找的是min，
	  所以只能同时满足，即返回{是不是搜，min,max}.
*/
class ReturnData {
public:
	bool isSBT;
	int min;
	int max;
	ReturnData(bool isB, int mi, int ma) {
		isSBT = isB;
		min = mi;
		max = ma;
	}
};
bool isBSTFun(Node* head) {
	return process1(head)->isSBT;
}
ReturnData* process1(Node* head) {
	//因为为空，max和min没法设置，所以返回NULL,但是用的时候需要判断
	if (head == NULL)
		return NULL;//返回值不能是ReturnData类型
	ReturnData* leftData = process1(head->left);
	ReturnData* rightData = process1(head->right);
	int minData = head->data;
	int maxData = head->data;
	if (leftData != NULL) {
		minData = min(minData, leftData->min);
		maxData = max(maxData, leftData->max);
	}
	if (rightData != NULL) {
		minData = min(minData, rightData->min);
		maxData = max(maxData, rightData->max);
	}
	bool isBST = true;//先假设是搜索树，若不满足条件就置为false
	//如果左边不空，且左边不是搜索树或者左边min>根值，则false
	if (leftData != NULL && (!leftData->isSBT || leftData->min >= head->data))
		isBST = false;
	if (rightData != NULL && (!rightData->isSBT || rightData->max <= head->data))
		isBST = false;
	return &(ReturnData(isBST, minData, maxData));
}