#2095 - Delete the Middle Node of a Linked List

MediumLinked List

Given the head of a linked list, delete the middle node and return the modified head. The middle node is the ⌊n / 2⌋-th node (0-indexed), where n is the list length. If the list has one node, return null.

Input	Output
[1,3,4,7,1,2,6]	[1,3,4,1,2,6] (removed node 7 at index 3)
[1,2,3,4]	[1,2,4] (removed node 3 at index 2)
[2,1]	[2] (removed node 1 at index 1)

Solution Space

Try it

/**
 * Deletes the middle node (index ⌊n/2⌋) from a singly linked list.
 * Uses slow/fast pointers where fast starts 2 steps ahead
 * so slow lands on the node BEFORE the middle.
 *
 * @param head Head of the linked list (1 ≤ n ≤ 10⁵)
 * @returns Head of the modified list
 */
export function deleteMiddle(head: ListNode | null): ListNode | null {
  if (!head || !head.next) return null;

  let slow: ListNode = head;
  // Fast starts two steps ahead so slow stops one before middle
  let fast: ListNode | null = head.next.next;

  while (fast && fast.next) {
    slow = slow.next!;
    fast = fast.next.next;
  }

  // slow is now the node before the middle; skip over the middle
  slow.next = slow.next!.next;

  return head;
}

Approach: slow/fast pointers – fast moves 2 steps, slow moves 1. By starting fast two nodes ahead, slow stops just before the middle node, allowing a single-pointer deletion.

Time: O(n) – one pass through the list.

Space: O(1) – only pointer variables.

Alternative approaches:

Approach	Idea	Time	Space
Two-pass	First pass counts nodes, second pass deletes at index ⌊n/2⌋	O(n)	O(1)
Dummy node + slow/fast	Use a dummy node before head; start both pointers at dummy. Advance fast by 1 first, then loop both.	O(n)	O(1)

Why the fast-start method is preferred: Single pass with no dummy node allocation; minimal pointer arithmetic.

#328 Odd Even Linked List

#2130 Maximum Twin Sum of a Linked List