方法1 (实现简单，但却是错误的)

bool isBST(Node* node)
{
  if (node == NULL)
    return true;
     
  //如果左孩子大于根节点，则不是BST
  if (node->left != NULL && node->left->key> node->key)
    return false;
     
  //如果右孩子节点小于根节点，则不是BST
  if (node->right != NULL && node->right->key < node->key)
    return false;
   
  //递归的判断
  if (!isBST(node->left) || !isBST(node->right))
    return false;
     
  //检测完毕，所有条件通过，则是BST
  return true;
}

方法2 (结果正确，但是效率比较低)

//如果是BST，则返回true
bool isBST(Node * node )
{
        if ( node == NULL)
               return true;

        //如果左子树最大值大于根节点，则返回false
        if ( node->left != NULL && maxValue( node->left) > node->key)
               return false;

        //如果右子树最小值小于根节点，则返回false
        if ( node->right != NULL && minValue( node->right) < node->key)
               return false;

        //递归判断
        if (!isBST( node->left) || !isBST( node->right))
               return( false);

        //所有检测都通过，是BST
        return true;
}

方法3 (正确并且有效的)

#include <iostream>

struct Node
{
        int key;
        Node *left;
        Node *right;
};

bool isBSTUtil(Node * node, int min, int max);

//判断是否为BST
bool isBST(Node * node )
{
        return(isBSTUtil( node, INT_MIN, INT_MAX));
}

//如果是一颗二叉查找树，且值范围在[min, max]，则返回true
bool isBSTUtil(Node * node , int min , int max )
{
        //空树也是BST
        if ( node == NULL)
               return true;

        //如果节点值违反了最大/最小约束条件，则不是BST
        if ( node->key < min || node->key > max)
               return false;

        //递归检查子树
        return  isBSTUtil( node->left, min, node->key - 1) &&
              isBSTUtil( node->right, node->key + 1, max);
}


// 创建一个新的BST节点
Node *createNewNode(int item )
{
        Node *temp = new Node;
       temp->key = item;
       temp->left = temp->right = NULL;
        return temp;
}


int main()
{
    /* tree1的定义
            4
          /            2     5
        /        1   3 
    */
       Node *root = createNewNode(4);
       root->left = createNewNode(2);
       root->right = createNewNode(5);
       root->left->left = createNewNode(1);
       root->left->right = createNewNode(3);

        if (isBST(root))
              std::cout << "tree1 is BST\n";
        else
              std::cout << "tree1 is not BST\n";

        /* tree2的定义
            4
          /            2     5
        /     /
       1     3
       */
       root = createNewNode(4);
       root->left = createNewNode(2);
       root->left->left = createNewNode(1);
       root->right = createNewNode(5);
       root->right->left = createNewNode(3);

        if (isBST(root))
              std::cout << "tree2 is BST\n";
        else
              std::cout << "tree2 is not BST\n";

        return 0;
}

方法4(使用中序遍历)

//判断是否为BST
bool isBST(Node* root)
{
     static Node *prev = NULL;

     // 中序遍历这棵树，并保存前驱节点至prev中
     if (root)
     {
          if (!isBST(root->left))
               return false;

          // 检测节点值的合法性
          if (prev != NULL && root->key <= prev->key)
               return false;

          prev = root;

          //右子树
          return isBST(root->right);
     }

     return true;
}