BST Find Minimum Element in DSA Typescript - Time & Space Complexity

Time Complexity: BST Find Minimum Element

O(h)

Understanding Time Complexity

Finding the smallest value in a Binary Search Tree (BST) helps us quickly access the minimum data. We want to understand how the time it takes grows as the tree gets bigger.

How does the search time change when the tree has more nodes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

This code finds the minimum element by moving left until no more left child exists.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Moving from a node to its left child.
• How many times: At most once per level down the left side of the tree.

How Execution Grows With Input

Each step moves one level down the left side of the tree until the smallest node is found.

Input Size (n)	Approx. Operations (steps down left)
10	Up to 4-5 steps (depends on tree shape)
100	Up to 6-7 steps
1000	Up to 9-10 steps

Pattern observation: The number of steps grows with the height of the tree, not the total nodes.

Final Time Complexity

Time Complexity: O(h) where h is the tree height

This means the time depends on how tall the tree is, not how many nodes it has in total.

Common Mistake

[X] Wrong: "Finding the minimum always takes time proportional to the total number of nodes."

[OK] Correct: The search only follows the left children, so it depends on the tree height, which can be much smaller than total nodes.

Interview Connect

Understanding how tree height affects search time helps you explain why balanced trees are faster. This skill shows you can analyze and improve data structure performance.

Self-Check

What if the BST is perfectly balanced? How would the time complexity change?

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