BST Property and Why It Matters in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a node's left child value is greater than or equal to the node's value.

DSA Typescript

if (node.left && node.left.value [1] node.value) {
  return false;
}

Drag options to blanks, or click blank then click option'

A>=

B<

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '<=' instead of '>=' causes incorrect BST validation.

Confusing left and right child comparisons.

The BST property requires left child values to be less than the node's value.

2fill in blank

medium

Complete the code to check if a node's right child value is less than or equal to the node's value.

DSA Typescript

if (node.right && node.right.value [1] node.value) {
  return false;
}

Drag options to blanks, or click blank then click option'

A>

B<

C>=

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' or '>=' instead of '<=' causes wrong BST validation.

Mixing up left and right child checks.

The BST property requires right child values to be greater than the node's value.

3fill in blank

hard

Fix the error in the BST validation condition for the left subtree.

DSA Typescript

return isBST(node.left, [1], node.value) && isBST(node.right, node.value, max);

Drag options to blanks, or click blank then click option'

Anull

Bnode.value

Cmin

Dmax

Attempts:

3 left

💡 Hint

Common Mistakes

Passing node.value as min causes incorrect range checks.

Using max instead of min for left subtree boundaries.

The left subtree must have values between min and the current node's value.

4fill in blank

hard

Fill both blanks to complete the BST validation recursive calls with correct boundaries.

DSA Typescript

return isBST(node.left, [1], node.value) && isBST(node.right, node.value, [2]);

Drag options to blanks, or click blank then click option'

Amin

Bmax

Cnode.value

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping min and max in recursive calls.

Using node.value for both boundaries.

Left subtree values must be between min and node.value; right subtree values between node.value and max.

5fill in blank

hard

Fill all three blanks to complete the BST property check in the recursive function.

DSA Typescript

if (!node) return true;
if (node.value [1] min || node.value [2] max) return false;
return isBST(node.left, min, [3]) && isBST(node.right, node.value, max);

Drag options to blanks, or click blank then click option'

A<=

B>=

Cnode.value

Dmin

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '>' instead of '<=' or '>=' causes boundary errors.

Passing min instead of node.value as new max boundary.

Check if node.value is not less or equal to min, and not greater or equal to max. Then recurse with updated boundaries.

Practice

1. What is the main property that defines a Binary Search Tree (BST)?

easy

A. Left child nodes have smaller values, right child nodes have larger values

B. All nodes have exactly two children

C. Nodes are arranged in a circular linked list

D. Each node stores the sum of its children

Solution

1. Step 1: Understand BST node arrangement

   In a BST, every node's left child has a smaller value and the right child has a larger value.

2. Step 2: Compare with other options

   Other options describe different data structures or incorrect properties.

3. Final Answer:

   Left child nodes have smaller values, right child nodes have larger values -> Option A

4. Quick Check:

   BST property = Left smaller, right larger [OK]

Hint: Remember BST orders left < node < right [OK]

Common Mistakes:

• Thinking all nodes must have two children
• Confusing BST with binary tree
• Assuming nodes store sums

2. Which TypeScript interface correctly represents a BST node?

easy

A. interface Node { value: number; parent: Node; }

B. interface Node { value: number; left: Node | null; right: Node | null; }

C. interface Node { value: number; children: Node[]; }

D. interface Node { value: number; next: Node | null; prev: Node | null; }

Solution

1. Step 1: Identify BST node structure

   A BST node has a value and two pointers: left and right, which can be null.

2. Step 2: Check options

   interface Node { value: number; left: Node | null; right: Node | null; } matches this structure; others describe linked lists or generic trees.

3. Final Answer:

   interface Node { value: number; left: Node | null; right: Node | null; } -> Option B

4. Quick Check:

   BST node = value + left + right [OK]

Hint: BST nodes have left and right, not next/prev [OK]

Common Mistakes:

• Using next/prev like linked lists
• Using children array for BST
• Missing null for leaf nodes

3. What will be the in-order traversal output of this BST?

const root = {
  value: 10,
  left: { value: 5, left: null, right: null },
  right: { value: 15, left: null, right: null }
};
function inorder(node) {
  if (!node) return [];
  return [...inorder(node.left), node.value, ...inorder(node.right)];
}
console.log(inorder(root));

medium

A. [10, 5, 15]

B. [5, 15, 10]

C. [15, 10, 5]

D. [5, 10, 15]

Solution

1. Step 1: Understand in-order traversal

   In-order visits left subtree, then node, then right subtree.

2. Step 2: Apply traversal to given tree

   Left subtree: 5, root: 10, right subtree: 15, so output is [5, 10, 15].

3. Final Answer:

   [5, 10, 15] -> Option D

4. Quick Check:

   In-order = left, root, right = [5,10,15] [OK]

Hint: In-order traversal of BST gives sorted values [OK]

Common Mistakes:

• Confusing pre-order or post-order with in-order
• Mixing left and right subtree order
• Forgetting to return empty array for null

4. Identify the bug in this BST insertion function:

function insert(node, value) {
  if (!node) return { value, left: null, right: null };
  if (value < node.value) insert(node.left, value);
  else insert(node.right, value);
  return node;
}

medium

A. Node should have a parent pointer

B. Should compare value > node.value instead of <

C. Missing return when recursively inserting left or right

D. Function should not return anything

Solution

1. Step 1: Analyze recursive calls

   The recursive calls to insert do not assign their results back to node.left or node.right.

2. Step 2: Fix missing assignment

   We must assign: node.left = insert(node.left, value) or node.right = insert(node.right, value) to update the tree.

3. Final Answer:

   Missing return when recursively inserting left or right -> Option C

4. Quick Check:

   Recursive insert must update child pointers [OK]

Hint: Always assign recursive insert result to child pointer [OK]

Common Mistakes:

• Not assigning recursive call result
• Wrong comparison operator
• Expecting parent pointer in BST node

5. Given a BST, why is maintaining the BST property important when deleting a node?

hard

A. To ensure in-order traversal still returns sorted values

B. To keep the tree balanced automatically

C. To allow duplicate values in the tree

D. To convert the BST into a linked list

Solution

1. Step 1: Understand BST property role

   The BST property ensures left < node < right, which makes in-order traversal sorted.

2. Step 2: Effect of deletion on BST property

   If deletion breaks this property, in-order traversal won't be sorted, breaking BST usefulness.

3. Final Answer:

   To ensure in-order traversal still returns sorted values -> Option A

4. Quick Check:

   BST property keeps in-order sorted [OK]

Hint: BST property keeps traversal sorted after deletion [OK]

Common Mistakes:

• Thinking BST auto-balances on deletion
• Assuming duplicates are allowed by default
• Confusing BST with linked list