No. 31 - Binary Search Tree Verification

No. 31 - Binary Search Tree Verification

Question: How to verify whether a binary tree is a binary search tree?

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

A node in binary tree is defined as:

struct BinaryTreeNode

{

     int                    nValue;

    BinaryTreeNode*        pLeft; 

    BinaryTreeNode*        pRight;

};

Analysis: 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. 

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 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.