BST Find Minimum Element in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find minimum element in a BST

What is the output of the following TypeScript code that finds the minimum element in a Binary Search Tree (BST)?

DSA Typescript

class Node {
  value: number;
  left: Node | null;
  right: Node | null;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function findMin(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.left !== null) {
    current = current.left;
  }
  return current.value;
}

const root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
root.left.left = new Node(2);
root.left.right = new Node(7);
root.right.right = new Node(20);

console.log(findMin(root));

A 2

B 5

C 7

D 10

💡 Hint

The minimum element in a BST is the leftmost node.

The function traverses the left children until it reaches the leftmost node, which holds the minimum value 2.

❓ Predict Output

intermediate

Minimum element when BST has only right children

What will the output be when finding the minimum element in a BST where all nodes only have right children?

DSA Typescript

class Node {
  value: number;
  left: Node | null;
  right: Node | null;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function findMin(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.left !== null) {
    current = current.left;
  }
  return current.value;
}

const root = new Node(3);
root.right = new Node(5);
root.right.right = new Node(7);
root.right.right.right = new Node(10);

console.log(findMin(root));

A 7

B 5

C 3

D 10

💡 Hint

If there are no left children, the root is the minimum.

Since there are no left children, the root node value 3 is the minimum.

🔧 Debug

advanced

Identify the error in this BST minimum finder

What error will this TypeScript code produce when trying to find the minimum element in a BST?

DSA Typescript

class Node {
  value: number;
  left: Node | null;
  right: Node | null;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function findMin(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.left) {
    current = current.right;
  }
  return current.value;
}

const root = new Node(8);
root.left = new Node(3);
root.left.left = new Node(1);

console.log(findMin(root));

A TypeError: Cannot read property 'left' of null

B 8

C 1

D 10

💡 Hint

Check the direction of traversal inside the while loop.

The code incorrectly moves to current.right inside the loop that checks current.left, causing current to become null and then accessing left property causes TypeError.

🧠 Conceptual

advanced

Why does finding minimum in BST take O(h) time?

Why does finding the minimum element in a Binary Search Tree take time proportional to the height (h) of the tree?

A Because the minimum element is always the root node, so it takes constant time.

B Because the minimum is always found by traversing the left children from the root down to the leaf, which can be up to height h.

C Because the minimum element is found by traversing all nodes in the tree, which takes O(n) time.

D Because the minimum element is always the rightmost leaf, so traversal goes right h times.

💡 Hint

Think about how you move from root to the smallest value in a BST.

In a BST, the smallest value is the leftmost node. Traversing left children from root to leaf can take up to h steps, where h is the tree height.

❓ Predict Output

expert

Output of findMin on a BST with duplicate values

What is the output of the following code that finds the minimum element in a BST containing duplicate values?

DSA Typescript

class Node {
  value: number;
  left: Node | null;
  right: Node | null;
  constructor(value: number) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function findMin(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.left !== null) {
    current = current.left;
  }
  return current.value;
}

const root = new Node(10);
root.left = new Node(10);
root.left.left = new Node(5);
root.left.left.left = new Node(5);
root.right = new Node(15);

console.log(findMin(root));

A 15

B 10

C null

D 5

💡 Hint

Duplicates can appear on the left side; minimum is still the leftmost node.

The leftmost node has value 5, even though duplicates exist, so 5 is the minimum.