Validate if Tree is BST in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of BST Validation on a Simple Tree

What is the output of the following code that checks if a binary tree is a BST?

DSA Javascript

class Node {
  constructor(val, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function isBST(root, min = -Infinity, max = Infinity) {
  if (!root) return true;
  if (root.val <= min || root.val >= max) return false;
  return isBST(root.left, min, root.val) && isBST(root.right, root.val, max);
}

const tree = new Node(10, new Node(5), new Node(15, new Node(6), new Node(20)));
console.log(isBST(tree));

A false

B SyntaxError

C TypeError

D true

💡 Hint

Check if all nodes in the left subtree are less than the root and all nodes in the right subtree are greater.

The node with value 6 is in the right subtree of 10 but less than 10, which violates BST rules, so the function returns false.

❓ Predict Output

intermediate

Result of BST Validation on a Perfect BST

What will be printed after running this code that validates a perfect BST?

DSA Javascript

class Node {
  constructor(val, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function isBST(root, min = -Infinity, max = Infinity) {
  if (!root) return true;
  if (root.val <= min || root.val >= max) return false;
  return isBST(root.left, min, root.val) && isBST(root.right, root.val, max);
}

const tree = new Node(8, new Node(3, new Node(1), new Node(6)), new Node(10, null, new Node(14)));
console.log(isBST(tree));

A false

B true

C ReferenceError

D undefined

💡 Hint

All left children are less and right children are greater than their parent nodes.

The tree satisfies BST properties at every node, so the function returns true.

🔧 Debug

advanced

Identify the Error in BST Validation Code

What error will this code produce when checking if a tree is a BST?

DSA Javascript

class Node {
  constructor(val, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function isBST(root, min = -Infinity, max = Infinity) {
  if (!root) return true;
  if (root.val <= min || root.val >= max) return false;
  return isBST(root.left, min, root.val) && isBST(root.right, root.val, max);
}

const tree = new Node(10, new Node(5), new Node(15));
console.log(isBST(tree));

A false

B SyntaxError

C true

D Logic error: returns false for valid BST

💡 Hint

Check the comparison operators in the condition that returns false.

The code uses < and > instead of <= and >=, so it wrongly rejects valid BST nodes equal to min or max.

🧠 Conceptual

advanced

Understanding BST Validation Limits

Why is it necessary to pass min and max values when validating if a tree is a BST?

A To store the sum of all node values

B To count the number of nodes in the tree

C To keep track of the allowed value range for each node during recursion

D To balance the tree during validation

💡 Hint

Think about how BST rules apply to all descendants, not just immediate children.

Passing min and max helps ensure every node fits within the valid range defined by its ancestors, enforcing BST properties.

🚀 Application

expert

Output of BST Validation on a Large Tree with Duplicate Values

Given the following tree with duplicate values, what will the BST validation function return?

DSA Javascript

class Node {
  constructor(val, left = null, right = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function isBST(root, min = -Infinity, max = Infinity) {
  if (!root) return true;
  if (root.val <= min || root.val >= max) return false;
  return isBST(root.left, min, root.val) && isBST(root.right, root.val, max);
}

const tree = new Node(10,
  new Node(5,
    new Node(3),
    new Node(7, new Node(7), null)
  ),
  new Node(15, null, new Node(20))
);
console.log(isBST(tree));

A false

B true

C RangeError

D TypeError

💡 Hint

BSTs do not allow duplicate values on the same side; check the duplicate 7 in the left subtree.

The duplicate 7 in the left subtree violates the strict less-than rule for left children, so the function returns false.