BST Property and Why It Matters in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the BST property?

In a Binary Search Tree (BST), for every node, all values in its left subtree are smaller, and all values in its right subtree are larger than the node's value.

beginner

Why does the BST property matter for searching?

Because the BST property keeps smaller values to the left and larger to the right, it allows fast searching by deciding which subtree to explore next, reducing the search space quickly.

beginner

How does the BST property help in inserting a new value?

When inserting, the BST property guides where to place the new value by comparing it with nodes, moving left if smaller or right if larger, ensuring the tree stays ordered.

intermediate

What happens if the BST property is violated?

If the BST property is broken, searching and inserting become inefficient because the tree loses its order, possibly turning into a list and slowing operations to linear time.

beginner

Explain the BST property using a real-life example.

Think of a phone book sorted by names: all names starting with A come before B, and so on. This order helps you quickly find a name by skipping large sections, just like BST property helps find values fast.

What must be true for every node in a BST?

A All values in left and right subtrees are equal

B Left subtree values are larger, right subtree values are smaller

C Left subtree values are smaller, right subtree values are larger

D No specific order is required

The BST property requires left subtree values to be smaller and right subtree values to be larger than the node.

Why does the BST property improve search speed?

A It stores values randomly

B It allows skipping half of the tree at each step

C It duplicates values for faster access

D It uses a queue to find values

Because values are ordered, you can decide to go left or right, skipping half the nodes each time.

If a new value is smaller than a node's value, where should it go in a BST?

A Left subtree

B Right subtree

C At the node itself

D Anywhere in the tree

Smaller values go to the left subtree to maintain the BST property.

What is a consequence of violating the BST property?

A Search and insert become slower

B Tree becomes balanced automatically

C Values get sorted faster

D No effect on operations

Violating the property can make the tree unorganized, slowing down operations.

Which real-life example best illustrates the BST property?

A A shuffled deck of cards

B A pile of unsorted papers

C A random list of names

D A sorted phone book

A sorted phone book helps find names quickly, similar to how BST property organizes values.

Describe the BST property and explain why it is important for efficient searching.

Think about how the tree guides you to find values quickly.

Explain what could happen if the BST property is not maintained in a tree.

Consider how the tree's structure affects speed.

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