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

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the maximum element in a BST

What is the output of the following TypeScript code that finds the maximum 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 findMax(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.right !== null) {
    current = current.right;
  }
  return current.value;
}

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

console.log(findMax(root));

A 20

B 15

C 12

D 10

💡 Hint

The maximum element in a BST is the rightmost node.

In a BST, the maximum value is found by going as far right as possible. Here, the rightmost node has value 20.

❓ Predict Output

intermediate

Output of findMax on a single-node BST

What will be printed when findMax is called on a BST with only one node?

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 findMax(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.right !== null) {
    current = current.right;
  }
  return current.value;
}

const root = new Node(42);
console.log(findMax(root));

A null

B 0

C 42

D undefined

💡 Hint

If there is only one node, it is both minimum and maximum.

Since the tree has only one node with value 42, that is the maximum.

🔧 Debug

advanced

Identify the error in this BST maximum finder

What error will this TypeScript code produce when trying to find the maximum 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 findMax(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.right.right = new Node(20);
root.right.left = new Node(12);

console.log(findMax(root));

A Returns 20 correctly

B Throws a TypeError at runtime

C Returns null

D Returns 5 (minimum value), not maximum

💡 Hint

Check which child pointer is used to traverse to find maximum.

The code incorrectly traverses left children, which leads to the minimum value, not maximum.

❓ Predict Output

advanced

Output when BST is empty

What is the output of the following code when the BST is empty (null root)?

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 findMax(root: Node | null): number | null {
  if (!root) return null;
  let current = root;
  while (current.right !== null) {
    current = current.right;
  }
  return current.value;
}

const root = null;
console.log(findMax(root));

A 0

B null

C undefined

D Throws a TypeError

💡 Hint

Check the base case for an empty tree.

The function returns null immediately if the root is null, indicating no maximum.

🧠 Conceptual

expert

Why does traversing right child nodes find the maximum in a BST?

In a Binary Search Tree (BST), why does moving to the right child repeatedly lead to the maximum element?

A Because in BST, right child nodes always have values greater than their parent nodes

B Because left child nodes contain the maximum values in BST

C Because BST nodes are arranged randomly, so right traversal finds max by chance

D Because the root node always contains the maximum value

💡 Hint

Recall the BST property about left and right children values.

By definition, BST nodes have all right children greater than the node itself, so moving right leads to the largest value.

Practice

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

easy

A. At the rightmost node

B. At the leftmost node

C. At the root node

D. At any leaf node

Solution

1. Step 1: Understand BST property

   In a BST, left child nodes are smaller and right child nodes are larger than the parent node.

2. Step 2: Locate maximum element

   The maximum element is found by moving to the rightmost node because it has the largest value.

3. Final Answer:

   At the rightmost node -> Option A

4. Quick Check:

   Maximum element = rightmost node [OK]

Hint: Maximum is always the rightmost node in BST [OK]

Common Mistakes:

• Thinking maximum is at the root
• Confusing leftmost with maximum
• Assuming maximum can be any leaf

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

easy

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

B. return Math.max(node.value, findMax(node.left), findMax(node.right));

C. if(node.left === null) return node.value; else return findMax(node.left);

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

Solution

1. Step 1: Identify correct traversal direction

   To find maximum in BST, traverse right child nodes until no more right child exists.

2. Step 2: Check code correctness

   while(node.right !== null) { node = node.right; } return node.value; uses a while loop to move right until right child is null, then returns node value.

3. Final Answer:

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

4. Quick Check:

   Traverse right until null, then return value [OK]

Hint: Traverse right child nodes until none left [OK]

Common Mistakes:

• Traversing left instead of right
• Using recursion incorrectly
• Using Math.max on subtree values (not BST property)

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

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

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

const root = new Node(10, new Node(5), new Node(15, null, new Node(20)));
console.log(findMax(root));

medium

A. 10

B. 5

C. 15

D. 20

Solution

1. Step 1: Understand tree structure

   Root is 10, left child 5, right child 15, and 15's right child is 20.

2. Step 2: Trace findMax function

   Function moves right from 10 to 15, then to 20, which has no right child, so returns 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Rightmost node value = 20 [OK]

Hint: Rightmost node value is maximum [OK]

Common Mistakes:

• Returning root value instead of rightmost
• Confusing left and right children
• Not following right child chain fully

4. The following TypeScript function is intended to find the maximum element in a BST. What is the error?

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

medium

A. It returns undefined because node.value is missing

B. It causes infinite loop if node.left is null

C. It traverses left instead of right, so returns minimum instead of maximum

D. It throws error because Node type is incorrect

Solution

1. Step 1: Analyze traversal direction

   The function moves left child nodes, which leads to the minimum element in BST.

2. Step 2: Identify correct traversal for maximum

   Maximum element requires moving right child nodes, not left.

3. Final Answer:

   It traverses left instead of right, so returns minimum instead of maximum -> Option C

4. Quick Check:

   Left traversal = minimum, not maximum [OK]

Hint: Traverse right for max, left for min [OK]

Common Mistakes:

• Confusing left and right child traversal
• Assuming left traversal finds maximum
• Ignoring BST property of ordering

5. Given a BST where some nodes have only left children, how would you modify the findMax function to correctly find the maximum element even if the tree is skewed left?

hard

A. Return the root node's value directly since left skew means root is max

B. Traverse right child nodes until null; if none, return current node's value

C. Traverse left child nodes until null and return that value

D. Use recursion: return Math.max(node.value, findMax(node.left));

Solution

1. Step 1: Understand left skewed BST

   In a BST, values in left subtree < node <= values in right subtree. Even if some nodes have no right children, the maximum is found by traversing right until null.

2. Step 2: Modify findMax logic

   Traverse right child nodes until null; if no right child exists, current node is max.

3. Final Answer:

   Traverse right child nodes until null; if none, return current node's value -> Option B

4. Quick Check:

   Right traversal or current node if no right child [OK]

Hint: Check right child; if none, current node is max [OK]

Common Mistakes:

• Assuming root is always max in left skew
• Traversing left to find max
• Using recursion unnecessarily for simple right traversal