Is This a Binary Search Tree?

                            Solution in C :

In C ++ :



The Node struct is defined as follows:
	struct Node {
		int data;
		Node* left;
		Node* right;
	}
*/  enum comp {LESS, GREATER};
    bool checkBST(Node* root,int minVal, int maxVal ){
        if(root==0)
            return true;
        int nVal=root->data;
        if(nVal<=minVal || nVal>=maxVal)
            return false;
        return checkBST(root->left,minVal,nVal) && checkBST(root->right,nVal, maxVal);
    }
	bool checkBST(Node* root) {
		if(root==0)
            return true;
        return checkBST(root->left, -1, root->data) && checkBST(root->right,root->data, 10001);
	}






In Java :



The Node class is defined as follows:
    class Node {
    int data;
    Node left;
    Node right;
     }
*/
    private boolean checkBST(Node n, int min, int max) {
        if(n == null) return true;
        return n.data > min && n.data < max && checkBST(n.left, min, n.data) && checkBST(n.right, n.data, max);
    }

    boolean checkBST(Node root) {
        if(root == null) return true;
        if(count == 0) return true;
        return checkBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }







In  python3 :



from collections import deque
""" Node is defined as
class node:
  def __init__(self, data):
      self.data = data
      self.left = None
      self.right = None
"""
def check_binary_search_tree_(root, lowest_value=0, highest_value=10000):
    min_v = lowest_value - 1
    max_v = highest_value + 1
    q = deque([(root, min_v, max_v)])
    while q:
        node, min_val, max_val = q.popleft()
        if not node: continue
        if node.data >= max_val or node.data <= min_val: return False
        if node.left: q.append((node.left, min_val, node.data))
        if node.right: q.append((node.right, node.data, max_val))
    return True