BST Find Maximum Element in DSA Javascript

Mental Model

In a Binary Search Tree, the biggest number is always the rightmost node because bigger values go to the right.

Analogy: Imagine a line of people sorted by height, where the tallest person is always at the end of the line on the right side.

      10
     /  \
    5    15
          \
           20
            \
             25
             ↑ (start here)

Dry Run Walkthrough

Input: BST with nodes 10 -> 5, 15 -> 20 -> 25; find max element

Goal: Find the largest value in the BST by moving right until no more right child

Step 1: Start at root node 10

10 ↑ -> 5 -> 15 -> 20 -> 25 -> null

Why: We begin at the root to find the maximum

Step 2: Move right from 10 to 15

10 -> 5 -> 15 ↑ -> 20 -> 25 -> null

Why: Right child might have bigger value

Step 3: Move right from 15 to 20

10 -> 5 -> 15 -> 20 ↑ -> 25 -> null

Why: Keep moving right to find bigger values

Step 4: Move right from 20 to 25

10 -> 5 -> 15 -> 20 -> 25 ↑ -> null

Why: Continue moving right until no more right child

Step 5: No right child from 25, stop here

10 -> 5 -> 15 -> 20 -> 25 ↑ -> null

Why: Rightmost node is the maximum

Result:

10 -> 5 -> 15 -> 20 -> 25 ↑ -> null; Maximum element is 25

Annotated Code

DSA Javascript

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

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

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

  findMax() {
    if (!this.root) {
      return null;
    }
    let current = this.root;
    while (current.right) {
      current = current.right; // move right to find bigger value
    }
    return current.value; // rightmost node value is max
  }
}

// Driver code
const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(20);
bst.insert(25);
console.log("Maximum element is", bst.findMax());

while (current.right) {

keep moving right to find the largest value

current = current.right; // move right to find bigger value

advance current pointer to right child

return current.value; // rightmost node value is max

return the value of the rightmost node

Output

Maximum element is 25

Complexity Analysis

Time: O(h) because we only move down the right children where h is tree height

Space: O(1) because we use only a few variables, no extra data structures

vs Alternative: Compared to scanning all nodes O(n), this is faster since max is always rightmost

Edge Cases

Empty tree

Returns null because there is no maximum

DSA Javascript

if (!this.root) {
      return null;
    }

Tree with one node

Returns the single node's value as max

DSA Javascript

while (current.right) {
      current = current.right;
    }

When to Use This Pattern

When asked to find the maximum in a BST, look for the rightmost node because BSTs keep bigger values on the right.

Common Mistakes

Mistake: Trying to check left children or scanning entire tree for max
Fix: Only move right until no more right child to find max efficiently

Summary

Finds the largest value in a BST by moving right until no more right child.

Use when you need the maximum element quickly in a BST.

The maximum is always the rightmost node in a BST.

Practice

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

easy

A. At any leaf node

B. At the leftmost node

C. At the root node

D. At the rightmost node

Solution

1. Step 1: Understand BST property

   In a BST, left child nodes have smaller values and right child nodes have larger values than their parent.

2. Step 2: Locate maximum element

   The maximum element is the largest value, so it must be the rightmost node in the tree.

3. Final Answer:

   At the rightmost node -> Option D

4. Quick Check:

   Maximum = 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 of the following JavaScript code snippets correctly finds the maximum element in a BST node structure where each node has left and right properties?

easy

A. function findMax(node) { while(node.right) { node = node.right; } return node.value; }

B. function findMax(node) { while(node.left) { node = node.left; } return node.value; }

C. function findMax(node) { return node.value; }

D. function findMax(node) { if(!node) return null; return findMax(node.left); }

Solution

1. Step 1: Check traversal direction

   To find maximum, we must move right until no more right child exists.

2. Step 2: Verify code correctness

   function findMax(node) { while(node.right) { node = node.right; } return node.value; } correctly loops while node.right exists, then returns node.value.

3. Final Answer:

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

4. Quick Check:

   Traverse rightmost node to get max [OK]

Hint: Loop right child until none to find max [OK]

Common Mistakes:

• Looping left child instead of right
• Returning root value without traversal
• Recursing incorrectly on left child

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

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

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

function findMax(node) {
  while(node.right) {
    node = node.right;
  }
  return node.value;
}

console.log(findMax(root));

medium

A. 20

B. 10

C. 15

D. 5

Solution

1. Step 1: Trace the tree structure

   Root is 10, right child 15, right of 15 is 20. The rightmost node is 20.

2. Step 2: Follow findMax function

   The function moves right until no right child. It stops at node with value 20 and returns it.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   Rightmost node value = 20 [OK]

Hint: Output is value of rightmost node [OK]

Common Mistakes:

• Returning root value instead of max
• Confusing left and right children
• Not following loop to last right node

4. The following code is intended to find the maximum element in a BST but does not work correctly. What is the error?

function findMax(node) {
  if (!node.right) {
    return node.value;
  }
  return findMax(node.left);
}

medium

A. It should check node.left instead of node.right

B. It should return node.right.value instead of node.value

C. It should recurse on node.right, not node.left

D. It should use a loop instead of recursion

Solution

1. Step 1: Analyze recursion direction

   The code checks if node.right is null, then returns node.value. Otherwise, it recurses on node.left.

2. Step 2: Identify correct recursion path

   To find max, recursion must go right, not left. So it should recurse on node.right.

3. Final Answer:

   It should recurse on node.right, not node.left -> Option C

4. Quick Check:

   Max found by going right child [OK]

Hint: Recurse or loop right child to find max [OK]

Common Mistakes:

• Recursing left child instead of right
• Returning wrong node value
• Thinking loop is mandatory over recursion

5. Given a BST where some nodes may have duplicate values, which approach correctly finds the maximum element considering duplicates are allowed only on the right subtree?

function findMax(node) {
  while(node.right && node.right.value >= node.value) {
    node = node.right;
  }
  return node.value;
}

What is the main reason for the condition node.right.value >= node.value in the loop?

hard

A. To avoid infinite loops by stopping if right child is smaller

B. To move right only if the right child is greater or equal, handling duplicates correctly

C. To ensure the maximum is always strictly greater than current node

D. To skip nodes with equal values on the left subtree

Solution

1. Step 1: Understand duplicates in BST

   Duplicates allowed only on right subtree means equal values can appear on right child nodes.

2. Step 2: Analyze loop condition

   The loop moves right while right child exists and its value is greater or equal to current node, ensuring duplicates are included in max search.

3. Final Answer:

   To move right only if the right child is greater or equal, handling duplicates correctly -> Option B

4. Quick Check:

   Right child >= current node handles duplicates [OK]

Hint: Include equal right child to handle duplicates [OK]

Common Mistakes:

• Ignoring duplicates on right subtree
• Using strict greater than instead of greater or equal
• Confusing left subtree duplicates