**How to verify whether a binary tree is a binary search tree?**

__Question:__
For example, the tree in Figure 1 is a binary search tree.

Figure 1: A binary search tree |

A node in binary tree is defined as:

struct
BinaryTreeNode

{

int nValue;

BinaryTreeNode* pLeft;

BinaryTreeNode* pRight;

};

**Binary search tree is an important data structure. It has a specific character: Each node is greater than or equal to nodes in its left sub-tree, and less than or equal to nodes in its right sub-tree.**

__Analysis:__

*Solution 1: Verify value range of each node*
If a binary search tree is scanned with pre-order traversal
algorithm, the value in a root node is accessed to at first. After the root
node is visited, it begins to scan nodes in the left sub-tree. The value of
left sub-tree nodes should be less than or equal to the value of the root node.
If value of a left sub-tree node is greater than the value of the root node, it
violates the definition of binary search tree. It is similar for the right
sub-tree.

Therefore, when it visits a node in binary search tree, it
narrows the value range of left sub-tree and right sub-tree under the current
visited node. All nodes are visited with the pre-order traversal algorithm, and
their value is verified. If value in any node violates its corresponding range,
it is not a binary search tree.

The following sample code is implemented based on this pre-order
traversal solution:

bool
isBST_Solution1(BinaryTreeNode* pRoot)

{

int min =
numeric_limits<int>::min();

int max =
numeric_limits<int>::max();

return
isBSTCore_Solution1(pRoot, min, max);

}

bool
isBSTCore_Solution1(BinaryTreeNode* pRoot, int
min, int max)

{

if(pRoot ==
NULL)

return true;

if(pRoot->nValue
< min || pRoot->nValue > max)

return false;

return
isBSTCore_Solution1(pRoot->pLeft, min, pRoot->nValue)

&& isBSTCore_Solution1(pRoot->pRight, pRoot->nValue,
max);

}

In the code above, value of each node should be in the range
between min and max. The value of the
current visited node is the maximal value of its left sub-tree, and the minimal
value of its right sub-tree, so it updates the min and max arguments and verifies sub-trees recursively.

*Solution 2: Increasing in-order traversal sequence*
The first solution is based on pre-order traversal
algorithm. Let us have another try on in-order traversal. The in-order
traversal sequence of the binary search tree in Figure 1 is: 4, 6, 8, 10, 12,
14 and 16. It is noticeable that the sequence is increasingly sorted.

Therefore, a new solution is available: Nodes in a binary
tree is scanned with in-order traversal, and compare value of each node
against the value of the previously visited node. If the value of the previously
visited node is greater than the value of current node, it breaks the
definition of binary tree.

This solution might be implemented in C++ as the following
code:

bool isBST_Solution2(BinaryTreeNode*
pRoot)

{

int prev =
numeric_limits<int>::min();

return
isBSTCore_Solution2(pRoot, prev);

}

bool
isBSTCore_Solution2(BinaryTreeNode* pRoot, int&
prev)

{

if(pRoot ==
NULL)

return true;

return
isBSTCore_Solution2(pRoot->pLeft, prev) //
previous node

&& (pRoot->nValue >=
prev) // current node

&&
isBSTCore_Solution2(pRoot->pRight, prev = pRoot->nValue); // next node

}

The argument prev of the function isBSTCore_Solution2 above is the value of the previously visited
node in pre_order traversal.

The discussion about this problem is included in my book <Coding Interviews: Questions, Analysis & Solutions>, with some revisions. You may find the details of this book on Amazon.com, or Apress.

The author Harry He owns all the rights of this post. If you are going
to use part of or the whole of this ariticle in your blog
or webpages, please add a reference to http://codercareer.blogspot.com/. If you are going to use it in your books, please contact him via zhedahht@gmail.com . Thanks.