Delete the Middle Node of a Linked List - Practice Coding Problems

Delete the Middle Node of a Linked List - Problem

You are given the head of a singly linked list. Your task is to delete the middle node and return the head of the modified linked list.

The middle node of a linked list of size n is defined as the ⌊n / 2⌋th node from the start using 0-based indexing, where ⌊x⌋ denotes the floor function (largest integer less than or equal to x).

Examples of middle nodes:

For n = 1: middle node is at index 0
For n = 2: middle node is at index 1
For n = 3: middle node is at index 1
For n = 4: middle node is at index 2
For n = 5: middle node is at index 2

Special case: If the linked list has only one node, return null (or empty list).

Input & Output

example_1.py — Basic Case

$ Input: head = [1,3,4,7,1,2,6]

› Output: [1,3,4,1,2,6]

💡 Note: The linked list has 7 nodes. The middle node is at index ⌊7/2⌋ = 3 (0-indexed), which contains value 7. After removing this node, we get [1,3,4,1,2,6].

example_2.py — Even Length

$ Input: head = [1,2,3,4]

› Output: [1,2,4]

💡 Note: The linked list has 4 nodes. The middle node is at index ⌊4/2⌋ = 2 (0-indexed), which contains value 3. After removing this node, we get [1,2,4].

example_3.py — Single Node

$ Input: head = [1]

› Output: []

💡 Note: The linked list has only 1 node. The middle node is at index ⌊1/2⌋ = 0. After removing this node, the list becomes empty, so we return null.

Constraints

The number of nodes in the list is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
Follow-up: Can you solve this in one pass?

Visualization

Tap to expand

Understanding the Visualization

Start Both Pointers

Both tortoise (slow) and hare (fast) start at the beginning of the linked list

Move at Different Speeds

In each iteration: tortoise moves 1 step, hare moves 2 steps

Hare Reaches the End

When hare reaches the end (or goes beyond), tortoise is exactly at the middle

Delete Middle Node

Use the previous pointer to safely delete the middle node found by tortoise

Key Takeaway

🎯 Key Insight: The two-pointer technique elegantly finds the middle in one pass by leveraging the mathematical relationship: when the fast pointer (2x speed) reaches the end, the slow pointer (1x speed) will be exactly at the middle position!

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses the two-pointer technique (tortoise and hare) to find the middle node in one pass. By moving the fast pointer 2 steps and slow pointer 1 step, when fast reaches the end, slow will be at the middle. We track the previous node to perform the deletion efficiently in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers - Fast & Slow (Optimal)	O(n)	O(1)	Use tortoise and hare technique to find middle in one pass
Two-Pass Approach (Count then Delete)	O(n)	O(1)	Count the length first, then traverse again to delete the middle node

Two Pointers - Fast & Slow (Optimal) — Algorithm Steps

Handle edge case: if only one node, return null
Initialize slow and fast pointers at head, and prev pointer for deletion
Move fast pointer 2 steps and slow pointer 1 step until fast reaches end
When loop ends, slow pointer is at middle node
Delete middle node using previous pointer: prev.next = slow.next

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set both slow and fast pointers at head

Move Different Speeds

Fast moves 2 steps, slow moves 1 step each iteration

Fast Reaches End

When fast reaches end, slow is at middle

Delete Middle

Use prev pointer to delete the middle node

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* deleteMiddle(struct ListNode* head) {
    // Edge case: empty list or single node
    if (!head || !head->next) {
        return NULL;
    }
    
    // Initialize pointers
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    struct ListNode* prev = NULL;
    
    // Move fast 2 steps, slow 1 step
    while (fast && fast->next) {
        prev = slow;
        slow = slow->next;
        fast = fast->next->next;
    }
    
    // Delete middle node (slow is at middle)
    prev->next = slow->next;
    free(slow);
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal through the list, fast pointer covers at most 2n steps

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers

✓ Linear Space

78.2K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers - Fast & Slow (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler