Find Middle Element of Linked List in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple Node class for a linked list.

DSA Java

class Node {
    int data;
    Node [1];

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

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

Atail

Bprev

Chead

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using 'head' or 'tail' inside the Node class.

The 'next' field points to the next node in the linked list.

2fill in blank

medium

Complete the code to initialize the slow pointer to the head of the linked list.

DSA Java

Node slow = [1];

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

Atail

Bhead

Cnull

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing slow to null or tail.

Using 'next' which is a field, not a variable.

The slow pointer starts at the head of the linked list.

3fill in blank

hard

Fix the error in the while loop condition to avoid NullPointerException when finding the middle node.

DSA Java

while (fast != null && fast.[1] != null) {
    slow = slow.next;
    fast = fast.next.next;
}

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

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Checking fast.prev which does not exist in singly linked list.

Not checking fast.next leading to NullPointerException.

We check fast.next to ensure fast.next.next is safe to access.

4fill in blank

hard

Fill both blanks to complete the method that returns the middle node's data.

DSA Java

public int findMiddle(Node [1]) {
    Node slow = [1];
    Node fast = [1];
    while (fast != null && fast.[2] != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow.data;
}

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

Ahead

Bnode

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' inside the method instead of the parameter.

Checking fast.prev which is invalid.

The method parameter is 'node' but inside the method 'head' should be replaced with 'node' to use the passed list. The loop checks fast.next.

5fill in blank

hard

Fill all three blanks to complete the main method that creates a linked list and prints its middle element.

DSA Java

public static void main(String[] args) {
    Node head = new Node(1);
    head.next = new Node(2);
    head.next.next = new Node(3);
    head.next.next.next = new Node(4);
    head.next.next.next.next = new Node(5);

    [1] finder = new [2]();
    int middle = finder.[3](head);
    System.out.println("Middle element: " + middle);
}

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

AFindMiddle

BFindMiddleElement

CfindMiddle

DFindMiddleNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong class names or method names.

Calling method on class instead of instance.

The class name is 'FindMiddleElement' and the method to find middle is 'findMiddle'.

Practice

1. What is the main idea behind finding the middle element of a singly linked list using the two-pointer technique?

easy

A. Use two pointers both moving one step at a time

B. Count all nodes first, then traverse half the count again

C. Use one slow pointer moving one step and one fast pointer moving two steps until fast reaches the end

D. Reverse the list and pick the first element

Solution

1. Step 1: Understand the two-pointer technique

   The slow pointer moves one node at a time, while the fast pointer moves two nodes at a time.

2. Step 2: Identify when to stop

   When the fast pointer reaches the end (null), the slow pointer will be at the middle node.

3. Final Answer:

   Use one slow pointer moving one step and one fast pointer moving two steps until fast reaches the end -> Option C

4. Quick Check:

   Two-pointer technique = slow one step, fast two steps [OK]

Hint: Move fast pointer twice as fast as slow pointer [OK]

Common Mistakes:

• Moving both pointers at the same speed
• Counting nodes first then traversing again
• Stopping when slow pointer reaches null

2. Which of the following Java code snippets correctly initializes two pointers to find the middle of a linked list named head?

easy

A. Node slow = head; Node fast = head;

B. Node slow = null; Node fast = head;

C. Node slow = head.next; Node fast = head.next.next;

D. Node slow = head; Node fast = head.next;

Solution

1. Step 1: Initialize both pointers at the start

   Both slow and fast pointers should start at the head node to cover the entire list.

2. Step 2: Check initialization correctness

   Node slow = head; Node fast = head; initializes both pointers to head, which is correct for the two-pointer approach.

3. Final Answer:

   Node slow = head; Node fast = head; -> Option A

4. Quick Check:

   Both pointers start at head [OK]

Hint: Start both pointers at head node [OK]

Common Mistakes:

• Starting slow pointer at null
• Starting fast pointer ahead causing null errors
• Skipping nodes at initialization

3. What will be the output of the following Java code snippet that finds the middle element of a linked list?

class Node {
  int data;
  Node next;
  Node(int d) { data = d; next = null; }
}

public class Test {
  public static void main(String[] args) {
    Node head = new Node(10);
    head.next = new Node(20);
    head.next.next = new Node(30);
    head.next.next.next = new Node(40);
    head.next.next.next.next = new Node(50);

    Node slow = head, fast = head;
    while (fast != null && fast.next != null) {
      slow = slow.next;
      fast = fast.next.next;
    }
    System.out.println(slow.data);
  }
}

medium

A. 40

B. 20

C. 50

D. 30

Solution

1. Step 1: Trace slow and fast pointers

   Initially, slow=10, fast=10. After first loop: slow=20, fast=30. Second loop: slow=30, fast=50. Third loop: fast.next is null, loop ends.

2. Step 2: Identify slow pointer position at loop end

   Slow pointer is at node with data 30, which is the middle element.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Middle element = 30 [OK]

Hint: Slow pointer at middle when fast reaches end [OK]

Common Mistakes:

• Printing fast pointer data instead of slow
• Off-by-one errors in loop condition
• Assuming middle is first or last node

4. Identify the error in the following code snippet that attempts to find the middle element of a linked list and fix it:

Node slow = head;
Node fast = head.next;
while (fast != null && fast.next != null) {
  slow = slow.next;
  fast = fast.next.next;
}
System.out.println(slow.data);

medium

A. Print fast.data instead of slow.data

B. Initialize fast pointer to head instead of head.next

C. Move slow pointer two steps instead of one

D. Change while condition to only check fast != null

Solution

1. Step 1: Analyze pointer initialization

   Fast pointer starts at head.next, which causes the slow pointer to point to the first middle in even-length lists.

2. Step 2: Correct initialization for consistent middle

   Initialize fast pointer at head to find the second middle element in even-length lists.

3. Final Answer:

   Initialize fast pointer to head instead of head.next -> Option B

4. Quick Check:

   Fast pointer starts at head for correct middle [OK]

Hint: Start fast pointer at head for correct middle [OK]

Common Mistakes:

• Starting fast pointer at head.next causing off-by-one
• Incorrect loop condition causing null pointer
• Moving slow pointer incorrectly

5. Given a singly linked list with an even number of nodes, how can you modify the two-pointer approach to return the first middle element instead of the second?

hard

A. Initialize fast pointer to head.next and use the same loop condition

B. Initialize slow pointer to head.next and fast pointer to head

C. Change loop condition to fast.next != null

D. Move slow pointer two steps and fast pointer one step

Solution

1. Step 1: Understand default behavior

   Starting both pointers at head returns the second middle in even-length lists.

2. Step 2: Modify initialization to get first middle

   Starting fast pointer at head.next causes slow pointer to land on the first middle.

3. Final Answer:

   Initialize fast pointer to head.next and use the same loop condition -> Option A

4. Quick Check:

   Fast starts at head.next for first middle [OK]

Hint: Start fast pointer one step ahead for first middle [OK]

Common Mistakes:

• Changing loop condition incorrectly
• Moving pointers in wrong directions
• Starting slow pointer ahead causing errors