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.