Find Middle Element of Linked List in DSA Javascript

Mental Model

To find the middle, use two pointers moving 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 exactly halfway.

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

Dry Run Walkthrough

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

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: Both pointers start 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: Try to move fast by 2 steps but reaches null, stop

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

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

Result:

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

Annotated Code

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let current = this.head;
    while (current.next) {
      current = current.next;
    }
    current.next = newNode;
  }

  findMiddle() {
    if (!this.head) return null; // empty list
    let slow = this.head;
    let fast = this.head;
    while (fast && fast.next) {
      slow = slow.next; // move slow by 1
      fast = fast.next.next; // move fast by 2
    }
    return slow.value;
  }
}

// Driver code
const list = new LinkedList();
[1, 2, 3, 4, 5].forEach(num => list.append(num));
const middle = list.findMiddle();
console.log(`Middle element is ${middle}`);

if (!this.head) return null; // empty list

handle empty list edge case

let slow = this.head; let fast = this.head;

initialize slow and fast pointers at head

while (fast && fast.next) {

loop until fast reaches end or next is null

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.value;

slow pointer is at middle node, return its value

Output

Middle element is 3

Complexity Analysis

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

Space: O(1) because we only use two pointers regardless of list size

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

Edge Cases

empty list

returns null since there is no middle

DSA Javascript

if (!this.head) return null; // empty list

list with one element

returns the single element as middle

DSA Javascript

while (fast && fast.next) {

list with even number of elements

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

DSA Javascript

while (fast && fast.next) {

When to Use This Pattern

When you need to find the middle of a linked list efficiently, use the slow and fast pointer pattern because it finds the middle in one pass without extra space.

Common Mistakes

Mistake: Moving slow and fast pointers incorrectly, like moving both by one step
Fix: Move slow by one step and fast by two steps each iteration

Mistake: Not checking if fast or fast.next is null before moving fast pointer
Fix: Add condition while (fast && fast.next) to avoid errors

Summary

Finds the middle element of a linked list using two pointers moving at different speeds.

Use when you want to find the middle without counting nodes or using extra space.

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

Practice

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

easy

A. Reverse the list and pick the last element

B. Use one pointer moving twice as fast as the other; when fast reaches end, slow is at middle

C. Count all nodes first, then traverse again to the middle node

D. Use two pointers moving at the same speed and pick the first pointer's position

Solution

1. Step 1: Understand two-pointer technique

   One pointer (fast) moves two nodes at a time, the other (slow) moves one node at a time.

2. Step 2: Identify middle when fast pointer reaches end

   When fast pointer reaches the end of the list, slow pointer will be at the middle node.

3. Final Answer:

   Use one pointer moving twice as fast as the other; when fast reaches end, slow is at middle -> Option B

4. Quick Check:

   Two-pointer technique = fast & slow pointers [OK]

Hint: Fast pointer moves 2x speed, slow pointer at middle when fast ends [OK]

Common Mistakes:

• Trying to reverse the list unnecessarily
• Counting nodes twice instead of using two pointers
• Moving both pointers at the same speed

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

easy

A. let slow = head.next; let fast = head;

B. let slow = null; let fast = head.next;

C. let slow = head; let fast = head;

D. let slow = head; let fast = null;

Solution

1. Step 1: Initialize both pointers at head

   Both slow and fast pointers start at the head node to begin traversal.

2. Step 2: Confirm correct initialization

   Starting both at head allows fast to move ahead and slow to lag behind properly.

3. Final Answer:

   let slow = head; let fast = head; -> Option C

4. Quick Check:

   Both pointers start at head [OK]

Hint: Start both slow and fast pointers at head node [OK]

Common Mistakes:

• Starting slow or fast at null or head.next incorrectly
• Swapping slow and fast initialization
• Starting fast pointer at null causing errors

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

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

const 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);

function findMiddle(head) {
  let slow = head;
  let fast = head;
  while (fast !== null && fast.next !== null) {
    slow = slow.next;
    fast = fast.next.next;
  }
  return slow.value;
}

console.log(findMiddle(head));

medium

A. 20

B. 50

C. 40

D. 30

Solution

1. Step 1: Trace slow and fast pointers through the list

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

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

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

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Middle element = 30 [OK]

Hint: Fast moves 2 steps, slow moves 1; slow ends at middle [OK]

Common Mistakes:

• Returning fast pointer value instead of slow
• Off-by-one error in loop condition
• Confusing node values during traversal

4. The following code is intended to find the middle element of a linked list, but it has a bug. What is the bug?

function findMiddle(head) {
  let slow = head;
  let fast = head.next;
  while (fast !== null && fast.next !== null) {
    slow = slow.next;
    fast = fast.next.next;
  }
  return slow.value;
}

medium

A. Fast pointer should start at head, not head.next

B. Slow pointer should start at head.next, not head

C. Loop condition should be while (fast !== null)

D. Return statement should return fast.value

Solution

1. Step 1: Analyze pointer initialization

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

2. Step 2: Correct initialization for accurate middle

   Fast pointer should start at head to ensure slow pointer reaches the true middle node.

3. Final Answer:

   Fast pointer should start at head, not head.next -> Option A

4. Quick Check:

   Fast pointer must start at head [OK]

Hint: Start fast pointer at head to avoid off-by-one errors [OK]

Common Mistakes:

• Starting fast pointer at head.next causing wrong middle
• Changing loop condition incorrectly
• Returning fast pointer value instead of slow

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 middle element?

hard

A. Initialize fast pointer at head.next and slow pointer at head

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

C. Move slow pointer twice and fast pointer once in the loop

D. Return fast pointer's value instead of slow pointer's value

Solution

1. Step 1: Understand default behavior

   Normally, both pointers start at head, so slow points to 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 move fewer steps, landing on the first middle node.

3. Final Answer:

   Initialize fast pointer at head.next and slow pointer at head -> Option A

4. Quick Check:

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

Hint: Start fast at head.next to get first middle in even lists [OK]

Common Mistakes:

• Swapping slow and fast initialization incorrectly
• Changing pointer movement speeds
• Returning fast pointer value without logic