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

Challenge - 5 Problems

❓ Predict Output

intermediate

Find maximum element in a BST - Output after insertions

Given the following JavaScript code that inserts elements into a Binary Search Tree (BST) and finds the maximum element, what is the printed output?

DSA Javascript

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    let current = this.root;
    while (true) {
      if (data < current.data) {
        if (!current.left) {
          current.left = newNode;
          break;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          break;
        }
        current = current.right;
      }
    }
  }

  findMax() {
    if (!this.root) return null;
    let current = this.root;
    while (current.right) {
      current = current.right;
    }
    return current.data;
  }
}

const bst = new BST();
bst.insert(15);
bst.insert(10);
bst.insert(20);
bst.insert(8);
bst.insert(12);
bst.insert(17);
bst.insert(25);
console.log(bst.findMax());

A 17

B 20

C 15

D 25

💡 Hint

The maximum element in a BST is the rightmost node.

In a BST, the maximum element is found by going as far right as possible from the root. Here, 25 is the rightmost node.

❓ Predict Output

intermediate

Output of findMax on empty BST

What is the output of the following code when findMax is called on an empty BST?

DSA Javascript

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  findMax() {
    if (!this.root) return null;
    let current = this.root;
    while (current.right) {
      current = current.right;
    }
    return current.data;
  }
}

const bst = new BST();
console.log(bst.findMax());

A null

B undefined

C 0

D Throws an error

💡 Hint

Check what findMax returns if root is null.

The method returns null explicitly if the tree is empty (root is null).

🔧 Debug

advanced

Identify the error in findMax method

What error will the following code produce when findMax is called on a BST with nodes?

DSA Javascript

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  findMax() {
    let current = this.root;
    while (current.right !== null) {
      current = current.right;
    }
    return current.data;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(20);
console.log(bst.findMax());

A TypeError: Cannot read property 'right' of null

B ReferenceError: bst.insert is not a function

C Output: 20

D SyntaxError: Unexpected token

💡 Hint

Check if insert method is defined in the BST class.

The BST class does not have an insert method defined, so calling bst.insert causes a ReferenceError.

❓ Predict Output

advanced

Output after removing maximum element

Given the BST and the removeMax method below, what is the output of findMax after removing the maximum element?

DSA Javascript

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    let current = this.root;
    while (true) {
      if (data < current.data) {
        if (!current.left) {
          current.left = newNode;
          break;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          break;
        }
        current = current.right;
      }
    }
  }

  findMax() {
    if (!this.root) return null;
    let current = this.root;
    while (current.right) {
      current = current.right;
    }
    return current.data;
  }

  removeMax() {
    if (!this.root) return null;
    let parent = null;
    let current = this.root;
    while (current.right) {
      parent = current;
      current = current.right;
    }
    if (!parent) {
      this.root = current.left;
    } else {
      parent.right = current.left;
    }
    return current.data;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(12);
bst.insert(20);
bst.removeMax();
console.log(bst.findMax());

A 15

B 20

C 12

D null

💡 Hint

Removing max removes the rightmost node, so max changes to its parent or left child.

The maximum 20 is removed. The new maximum is the next rightmost node 15.

🧠 Conceptual

expert

Why is findMax efficient in a BST?

Why does the findMax method in a Binary Search Tree run efficiently compared to searching maximum in an unsorted binary tree?

A Because BST stores elements in a linked list fashion making maximum retrieval O(1).

B Because BST uses hashing internally to find maximum quickly.

C Because BST stores elements so that the maximum is always the rightmost node, allowing direct traversal without checking all nodes.

D Because BST sorts elements after every insertion, so maximum is at the root.

💡 Hint

Think about the BST property and how it organizes data.

BST property ensures all right children are greater, so maximum is found by going right until no more right child exists, making it efficient.