check_bst

check_bst.c

node* new_node(val) {
    node* n = malloc(sizeof(node));
    n->val = val;
    n->left = NULL;
    n->right = NULL;
    return n;
}

void test(){
  /*
          4
        /       \
      2             5
    /       \
  1             3
  */

  node root = new_node(4);
  root->left = new_node(2);
  root->right = new_node(5);
  root->left->left = new_node(1);
  root->left->right = new_node(3);
  printf ("%d", isBinarySearchTree(root));

  /*

          5
        /       \
      3             2
    /       \
  1             4
  */
  node* root1 = new_node(5);
  root1->left = new_node(3);
  root1->right = new_node(2);
  root1->left->left = new_node(1);
  root1->left->right = new_node(4);
  printf ("Result: %d. Expected: 0", isBinarySearchTree(root1));

  /*
          3
        /       \
      2             5
    /       \
  1             4
  */
  node* root2 = new_node(3);
  root2->left = new_node(2);
  root2->right = new_node(5);
  root2->left->left = new_node(1);
  root2->left->right = new_node(4);
  printf ("Result: %d. Expected: 0", isBinarySearchTree(root2));
    
    
  /*
            5
          /     \
        2          8
      /     \
    1          4
           /       \
         3          6
  */
  node* root3 = new_node(5);
  root3->left = new_node(2);
  root3->right = new_node(8);
  root3->left->left = new_node(1);
  root3->left->right = new_node(4);
  root3->left->right->left = new_node(3);
  root3->left->right->right = new_node(6);
  printf ("Result: %d. Expected: 0", isBinarySearchTree(root3));
}

check_bst.py

class Node:
    def __init__(self, val):
        self.left = None
        self.right = None
        self.val = val


def run_test(tree, root, expected):
    result = isBinarySearchTree(root)
    print(tree)
    print("Result: %d. Expected: %d. %s" %
          (result, expected, "ERROR" if result != expected else ""))
    print("-------------------")


def test():
    tree = """
                    4
                /       \\
            2               5
        /       \\
    1               3
    """

    root = Node(4)
    root.left = Node(2)
    root.right = Node(5)
    root.left.left = Node(1)
    root.left.right = Node(3)
    run_test(tree, root, 1)

    tree = """
                    5
                /       \\
            3               2
        /       \\
    1               4
    """
    root1 = Node(5)
    root1.left = Node(3)
    root1.right = Node(2)
    root1.left.left = Node(1)
    root1.left.right = Node(4)
    run_test(tree, root1, 0)

    tree = """
                    3
                /       \\
            2               5
        /       \\
    1               4
    """
    root2 = Node(3)
    root2.left = Node(2)
    root2.right = Node(5)
    root2.left.left = Node(1)
    root2.left.right = Node(4)
    run_test(tree, root2, 0)

    tree = """
            5
          /     \\
        2          8
      /     \\
    1          4
           /       \\
         3          6
    """
    root3 = Node(5)
    root3.left = Node(2)
    root3.right = Node(8)
    root3.left.left = Node(1)
    root3.left.right = Node(4)
    root3.left.right.left = Node(3)
    root3.left.right.right = Node(6)
    run_test(tree, root3, 0)

    tree = """
            6
          /     \\
        2          8
      /     \\
    1          4
           /       \\
         3          5
    """
    root4 = Node(6)
    root4.left = Node(2)
    root4.right = Node(8)
    root4.left.left = Node(1)
    root4.left.right = Node(4)
    root4.left.right.left = Node(3)
    root4.left.right.right = Node(5)
    run_test(tree, root4, 1)


def isBinarySearchTree(x):
    return True

test()