BST Find Maximum Element in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find the maximum value in a BST by moving right.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

Aleft

Bchild

Cparent

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'left' instead of 'right' to find the maximum.

Not checking if the root is null before starting.

In a BST, the maximum element is found by moving to the right child until there is no right child left.

2fill in blank

medium

Complete the code to return null if the BST is empty.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

A!root

Broot === undefined

Croot.value === null

Droot.left === null

Attempts:

3 left

💡 Hint

Common Mistakes

Checking root.value instead of root itself.

Using root.left to check if tree is empty.

Checking if root is falsy (!root) covers null or undefined, meaning the tree is empty.

3fill in blank

hard

Fix the error in the loop condition to correctly traverse the BST to find the maximum.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

Aleft

Bvalue

Cright

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using current.left in the loop condition.

Checking current.value instead of current.right.

The loop should continue while current.right exists to move right until the maximum is found.

4fill in blank

hard

Fill both blanks to complete the function that finds the maximum value in a BST.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

A!root

Broot === null

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'left' instead of 'right' in the loop.

Checking 'root === null' instead of '!root'.

Check if root is falsy to handle empty tree, then move right while right child exists to find max.

5fill in blank

hard

Fill all three blanks to complete the function that finds the maximum value in a BST safely.

DSA Javascript

function findMax([1]) {
  if ([2]) return null;
  let current = root;
  while (current.[3] !== null) {
    current = current.right;
  }
  return current.value;
}

Drag options to blanks, or click blank then click option'

Aroot

B!root

Cright

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'node' instead of 'root' as parameter.

Not checking if root is null or undefined.

Moving left instead of right in the loop.

The function takes 'root' as parameter, checks if root is falsy, then moves right to find max.

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