BST Find Maximum Element in DSA Javascript - Time & Space Complexity

Time Complexity: BST Find Maximum Element

O(h)

Understanding Time Complexity

We want to know how long it takes to find the largest value in a Binary Search Tree (BST).

Specifically, how does the time grow as the tree gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

This code finds the maximum value by moving right until no more right child exists.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

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

How Execution Grows With Input

As the tree grows, the number of steps depends on the height of the rightmost path.

Input Size (n)	Approx. Operations
10	Up to 4-5 steps (if tree is balanced)
100	Up to 7-8 steps (balanced tree height)
1000	Up to 10 steps (balanced tree height)

Pattern observation: The steps grow slowly with tree height, not total nodes.

Final Time Complexity

Time Complexity: O(h)

This means the time depends on the tree height, which is the longest path from root to leaf.

Common Mistake

[X] Wrong: "Finding max always takes time proportional to the number of nodes (n)."

[OK] Correct: We only follow the right children, so time depends on tree height, not total nodes.

Interview Connect

Understanding how tree height affects search time helps you explain efficiency clearly in interviews.

Self-Check

"What if the BST is unbalanced and looks like a linked list? How would the time complexity change?"

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