BST Find Maximum Element in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the maximum value in the BST.

DSA Java

public int findMax(Node root) {
    if (root == null) {
        return Integer.MIN_VALUE;
    }
    Node current = root;
    while (current.[1] != null) {
        current = current.right;
    }
    return current.data;
}

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

Aright

Bchild

Cparent

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

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

Returning root data without traversal.

In a BST, the maximum element is found by going to the rightmost node. So, we keep moving to the right child until it is null.

2fill in blank

medium

Complete the code to handle the case when the BST is empty.

DSA Java

public int findMax(Node root) {
    if (root == [1]) {
        return Integer.MIN_VALUE;
    }
    Node current = root;
    while (current.right != null) {
        current = current.right;
    }
    return current.data;
}

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

Aroot

Bcurrent

Cnull

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if root equals 'root' instead of null.

Not handling empty tree case.

If the root is null, it means the tree is empty, so we return Integer.MIN_VALUE as a signal for no maximum.

3fill in blank

hard

Fix the error in the loop condition to correctly find the maximum element.

DSA Java

public int findMax(Node root) {
    if (root == null) {
        return Integer.MIN_VALUE;
    }
    Node current = root;
    while (current.[1] != null) {
        current = current.right;
    }
    return current.data;
}

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

Aparent

Bleft

Cdata

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Checking left child instead of right.

Checking data field in loop condition.

The loop should continue while the right child exists, so we check current.right != null.

4fill in blank

hard

Fill both blanks to complete the recursive method to find the maximum element.

DSA Java

public int findMax(Node root) {
    if (root == null) {
        return Integer.MIN_VALUE;
    }
    if (root.[1] == null) {
        return root.data;
    }
    return findMax(root.[2]);
}

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

Aright

Bleft

Cparent

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using left child instead of right child.

Returning root data without checking children.

If the right child is null, root is max. Otherwise, recurse on right child.

5fill in blank

hard

Fill all three blanks to complete the iterative method that finds the maximum element.

DSA Java

public int findMax(Node root) {
    if (root == null) {
        return [1];
    }
    Node current = root;
    while (current.[2] != null) {
        current = current.[3];
    }
    return current.data;
}

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

AInteger.MIN_VALUE

Bleft

Cright

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 0 instead of Integer.MIN_VALUE for empty tree.

Moving left instead of right in the loop.

Return Integer.MIN_VALUE if tree is empty. Move right while right child exists 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 are smaller and right child nodes are larger than the parent node.

2. Step 2: Locate maximum element

   The maximum element is the rightmost node because it has no larger right child.

3. Final Answer:

   At the rightmost node -> Option D

4. Quick Check:

   Maximum = rightmost node [OK]

Hint: Maximum is always the farthest right node in BST [OK]

Common Mistakes:

• Confusing maximum with root node
• Thinking maximum is at leftmost node
• Assuming maximum can be any leaf

2. Which of the following Java method signatures correctly finds the maximum element in a BST node class named Node?

easy

A. public int findMax(Node root) { while(root.right != null) root = root.right; return root.data; }

B. public int findMax(Node root) { return root.left.data; }

C. public int findMax(Node root) { if(root == null) return 0; return root.data; }

D. public int findMax(Node root) { while(root.left != null) root = root.left; return root.data; }

Solution

1. Step 1: Check traversal direction for maximum

   Maximum is found by moving right until no right child exists.

2. Step 2: Verify method logic

   public int findMax(Node root) { while(root.right != null) root = root.right; return root.data; } correctly loops while root.right is not null, then returns root.data.

3. Final Answer:

   public int findMax(Node root) { while(root.right != null) root = root.right; return root.data; } -> Option A

4. Quick Check:

   Traverse right to find max [OK]

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

Common Mistakes:

• Looping left child instead of right
• Returning root data without traversal
• Not checking for null root

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

class Node {
  int data;
  Node left, right;
  Node(int d) { data = d; left = right = null; }
}

public class BST {
  public static int findMax(Node root) {
    while(root.right != null) root = root.right;
    return root.data;
  }

  public static void main(String[] args) {
    Node root = new Node(10);
    root.left = new Node(5);
    root.right = new Node(20);
    root.right.right = new Node(30);
    System.out.println(findMax(root));
  }
}

medium

A. 20

B. 30

C. 10

D. 5

Solution

1. Step 1: Trace the BST structure

   Root=10, left=5, right=20, right.right=30. Maximum is rightmost node 30.

2. Step 2: Follow findMax method

   Loop moves from 10 to 20 to 30, then stops as 30.right is null, returns 30.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Rightmost node data = 30 [OK]

Hint: Follow right children to last node for max [OK]

Common Mistakes:

• Returning root data without traversal
• Confusing left and right children
• Ignoring right.right node

4. Identify the error in the following Java method to find the maximum element in a BST and select the corrected version.

public int findMax(Node root) {
  if(root == null) return -1;
  while(root.left != null) {
    root = root.left;
  }
  return root.data;
}

medium

A. Add recursive call instead of while loop

B. Return 0 instead of -1 when root is null

C. Change root.left to root.right in while loop

D. No error, code is correct

Solution

1. Step 1: Analyze traversal direction

   Maximum is found by moving right, but code moves left incorrectly.

2. Step 2: Correct the while loop

   Change while(root.left != null) to while(root.right != null) to find max correctly.

3. Final Answer:

   Change root.left to root.right in while loop -> Option C

4. Quick Check:

   Traverse right child for max [OK]

Hint: Max is rightmost, so loop on right child [OK]

Common Mistakes:

• Looping left child instead of right
• Returning wrong default value
• Thinking recursion is mandatory

5. Given a BST where some nodes have duplicate values, which approach correctly finds the maximum element considering duplicates?

public int findMaxWithDuplicates(Node root) {
  if(root == null) return Integer.MIN_VALUE;
  int maxVal = root.data;
  while(root.right != null) {
    root = root.right;
    if(root.data > maxVal) maxVal = root.data;
  }
  return maxVal;
}

What is the output of findMaxWithDuplicates for this BST? Root=15, root.left=10, root.right=20, root.right.right=20, root.right.right.right=25

hard

A. 25

B. 20

C. 15

D. Duplicate values cause error

Solution

1. Step 1: Understand BST with duplicates

   Duplicates can appear on right subtree; max is still rightmost largest value.

2. Step 2: Trace method execution

   Traverse right: 15 -> 20 -> 20 -> 25; maxVal updates to 25 at last node.

3. Final Answer:

   25 -> Option A

4. Quick Check:

   Rightmost node data = 25 [OK]

Hint: Rightmost node holds max even with duplicates [OK]

Common Mistakes:

• Stopping at first duplicate max value
• Assuming duplicates cause errors
• Ignoring rightmost traversal