BST Find Minimum Element in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the minimum element in a Binary Search Tree (BST)?

The minimum element in a BST is the leftmost node because all smaller values are stored to the left.

beginner

How do you find the minimum element in a BST?

Start at the root and keep moving to the left child until you reach a node with no left child. That node is the minimum.

intermediate

Why does the minimum element in a BST always lie in the left subtree?

Because BST property states left child nodes have smaller values than their parents, so the smallest value is found by going left repeatedly.

intermediate

What is the time complexity to find the minimum element in a BST?

The time complexity is O(h), where h is the height of the BST. In the worst case (skewed tree), it can be O(n).

beginner

Show the TypeScript code snippet to find the minimum element in a BST node.

function findMin(root: TreeNode | null): TreeNode | null {
  if (!root) return null;
  while (root.left !== null) {
    root = root.left;
  }
  return root;
}

Where is the minimum element located in a BST?

A Root node

B Rightmost node

C Leftmost node

D Any leaf node

The minimum element is always the leftmost node in a BST.

What do you do if the BST root has no left child when finding the minimum?

A Return null

B Search both children

C Go to the right child

D Return the root node

If the root has no left child, it is the minimum element.

What is the time complexity to find the minimum element in a balanced BST with n nodes?

A O(log n)

B O(n)

C O(1)

D O(n log n)

In a balanced BST, height h is about log n, so finding minimum is O(log n).

Which of these is NOT true about the minimum element in a BST?

A It is always the root

B It is the leftmost node

C It has no left child

D It is smaller than all other nodes

The minimum element is not always the root; it depends on the tree structure.

What happens if you try to find the minimum in an empty BST?

A Return root

B Return null

C Throw an error

D Return a default value

If the BST is empty (root is null), the function returns null.

Explain step-by-step how to find the minimum element in a BST.

Think about the BST property and left children.

Write a simple TypeScript function to find the minimum element in a BST and explain its time complexity.

Use a loop to go left until no more left child.

Practice

1. In a Binary Search Tree (BST), where is the minimum element always located?

easy

A. At any leaf node

B. At the rightmost node

C. At the root node

D. At the leftmost node

Solution

1. Step 1: Understand BST property

   In a BST, left child nodes have smaller values than their parents.

2. Step 2: Locate minimum element

   The smallest value is found by going left until no more left child exists.

3. Final Answer:

   At the leftmost node -> Option D

4. Quick Check:

   Minimum element = leftmost node [OK]

Hint: Minimum is always the leftmost node in BST [OK]

Common Mistakes:

• Confusing minimum with root node
• Thinking minimum is at rightmost node
• Assuming minimum can be any leaf

2. Which TypeScript code snippet correctly finds the minimum element in a BST node?

easy

A. while (node.right !== null) { node = node.right; } return node.value;

B. while (node.left !== null) { node = node.left; } return node.value;

C. if (node.value < min) min = node.value; return min;

D. return Math.min(node.value, node.left.value);

Solution

1. Step 1: Check traversal direction for minimum

   Minimum is found by moving left until no left child exists.

2. Step 2: Verify code correctness

   while (node.left !== null) { node = node.left; } return node.value; correctly loops left and returns node value; others are incorrect or incomplete.

3. Final Answer:

   while (node.left !== null) { node = node.left; } return node.value; -> Option B

4. Quick Check:

   Traverse left to find minimum [OK]

Hint: Traverse left child nodes until null to find minimum [OK]

Common Mistakes:

• Traversing right child instead of left
• Using Math.min without checking null nodes
• Not looping until leftmost node

3. What will be the output of the following TypeScript code?

class Node {
  constructor(public value: number, public left: Node | null = null, public right: Node | null = null) {}
}

const root = new Node(10, new Node(5, new Node(2), new Node(7)), new Node(15));

function findMin(node: Node): number {
  while (node.left !== null) {
    node = node.left;
  }
  return node.value;
}

console.log(findMin(root));

medium

A. 7

B. 5

C. 2

D. 10

Solution

1. Step 1: Analyze BST structure

   Root is 10, left child 5, left-left child 2, left-right child 7, right child 15.

2. Step 2: Trace findMin function

   Function moves left from 10 to 5, then to 2, which has no left child, so returns 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Minimum value in BST = 2 [OK]

Hint: Minimum is leftmost node value, here 2 [OK]

Common Mistakes:

• Returning root value instead of leftmost
• Confusing left and right child nodes
• Stopping traversal too early

4. Identify the bug in this TypeScript function to find the minimum element in a BST:

function findMin(node: Node | null): number {
  if (node === null) return -1;
  while (node.right !== null) {
    node = node.right;
  }
  return node.value;
}

medium

A. Traverses right child instead of left child

B. Returns -1 for empty tree, should throw error

C. Does not check if node is null before accessing value

D. Returns node.value before loop ends

Solution

1. Step 1: Check traversal direction

   Minimum element requires moving left, but code moves right.

2. Step 2: Identify correct fix

   Change 'node.right' to 'node.left' in the while loop to find minimum.

3. Final Answer:

   Traverses right child instead of left child -> Option A

4. Quick Check:

   Minimum found by left traversal, not right [OK]

Hint: Minimum is leftmost, so traverse left child nodes [OK]

Common Mistakes:

• Using right child traversal for minimum
• Ignoring null checks before access
• Returning default -1 instead of handling empty tree

5. Given a BST where some nodes have duplicate values, how would you modify the findMin function to return the smallest unique value?

hard

A. Traverse entire tree and collect all values, then find minimum

B. Return the first leftmost node value without checking duplicates

C. Traverse leftmost nodes and skip duplicates by checking parent values

D. Use rightmost node value as minimum to avoid duplicates

Solution

1. Step 1: Understand duplicates in BST

   Duplicates can appear on left or right; leftmost node may not be unique minimum.

2. Step 2: Modify approach to find unique minimum

   Traverse entire tree to collect all values, then find the smallest unique value.

3. Final Answer:

   Traverse entire tree and collect all values, then find minimum -> Option A

4. Quick Check:

   Full traversal needed for unique minimum [OK]

Hint: Traverse all nodes to find unique minimum value [OK]

Common Mistakes:

• Assuming leftmost node is always unique minimum
• Ignoring duplicates in traversal
• Using rightmost node as minimum