Find Middle Element of Linked List in DSA Java

Mental Model

To find the middle, move two pointers at different speeds so when the fast one reaches the end, the slow one is in the middle.

Analogy: Imagine two friends walking on a path: one walks twice as fast as the other. When the faster friend reaches the end, the slower friend is halfway there.

head -> 1 -> 2 -> 3 -> 4 -> 5 -> null
slow ↑
fast ↑

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> 5

Goal: Find the middle element of the linked list

Step 1: Initialize slow and fast pointers at head (node 1)

head -> [slow->1, fast->1] -> 2 -> 3 -> 4 -> 5 -> null

Why: Start both pointers at the beginning to begin traversal

Step 2: Move slow by 1 step to node 2, fast by 2 steps to node 3

head -> 1 -> [slow->2] -> [fast->3] -> 4 -> 5 -> null

Why: Slow moves one step, fast moves two steps to find middle faster

Step 3: Move slow by 1 step to node 3, fast by 2 steps to node 5

head -> 1 -> 2 -> [slow->3] -> 4 -> [fast->5] -> null

Why: Continue moving pointers until fast reaches end

Step 4: Fast cannot move two steps further (end reached), stop

head -> 1 -> 2 -> [slow->3] -> 4 -> 5 -> null

Why: Fast pointer reached the end, slow is at middle

Result:

head -> 1 -> 2 -> [3] -> 4 -> 5 -> null
Middle element is 3

Annotated Code

DSA Java

public class LinkedList {
    static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head;

    public int findMiddle() {
        if (head == null) return -1; // empty list
        Node slow = head;
        Node fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next; // move slow by 1
            fast = fast.next.next; // move fast by 2
        }
        return slow.data; // slow is at middle
    }

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

        System.out.println("Middle element is " + list.findMiddle());
    }
}

Node slow = head; Node fast = head;

Initialize two pointers at the start of the list

while (fast != null && fast.next != null) {

Loop until fast reaches the end or one step before end

slow = slow.next; // move slow by 1

Advance slow pointer by one node

fast = fast.next.next; // move fast by 2

Advance fast pointer by two nodes

return slow.data; // slow is at middle

Return the data at slow pointer which is middle

Output

Middle element is 3

Complexity Analysis

Time: O(n) because we traverse the list once with two pointers

Space: O(1) because only two pointers are used regardless of list size

vs Alternative: Naive approach counts nodes first then traverses again to middle, costing O(n) + O(n) = O(n), this method finds middle in one pass

Edge Cases

Empty list

Returns -1 indicating no middle element

DSA Java

if (head == null) return -1; // empty list

List with one element

Returns the single element as middle

DSA Java

while (fast != null && fast.next != null) {

List with even number of elements

Returns the second middle element (e.g., for 4 elements returns 3rd node)

DSA Java

while (fast != null && fast.next != null) {

When to Use This Pattern

When you need to find the middle of a linked list efficiently, use two pointers moving at different speeds to find it in one pass.

Common Mistakes

Mistake: Moving both pointers by one step each time and then trying to find middle
Fix: Move one pointer by one step and the other by two steps to find middle in one pass

Mistake: Not checking if fast or fast.next is null before moving fast two steps
Fix: Add condition in while loop: fast != null && fast.next != null

Summary

Finds the middle element of a linked list using two pointers.

Use when you want the middle without counting nodes first.

The slow pointer moves half as fast as the fast pointer, so it lands in the middle when fast reaches the end.

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