Odd Even Linked List - Practice Coding Problems

Odd Even Linked List - Problem

Linked List Medium

Odd Even Linked List

You're given the head of a singly linked list and need to rearrange it in a specific pattern. Your task is to group all nodes at odd positions (1st, 3rd, 5th, etc.) together, followed by all nodes at even positions (2nd, 4th, 6th, etc.).

Important: We're talking about position indices, not the values stored in the nodes. The first node is at position 1 (odd), the second at position 2 (even), and so on.

Requirements:
• Maintain the relative order within each group
• Solve in O(1) extra space
• Achieve O(n) time complexity

Example: 1→2→3→4→5 becomes 1→3→5→2→4
The odd-positioned nodes (1,3,5) come first, then even-positioned nodes (2,4).

Input & Output

example_1.py — Basic Example

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

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

💡 Note: The odd-positioned nodes (1st, 3rd, 5th) are grouped first: 1→3→5, then the even-positioned nodes (2nd, 4th): 2→4. Final result: 1→3→5→2→4

example_2.py — Even Length

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

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

💡 Note: Odd positions: 2(1st)→3(3rd)→6(5th)→7(7th), Even positions: 1(2nd)→5(4th)→4(6th). Result: 2→3→6→7→1→5→4

example_3.py — Single Node

$ Input: head = [1]

› Output: [1]

💡 Note: A single node is already properly arranged since there are no even-positioned nodes to separate.

Constraints

The number of nodes in the linked list is in the range [0, 10⁴]
-10⁶ ≤ Node.val ≤ 10⁶
Follow up: Solve in O(1) extra space complexity and O(n) time complexity

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Recognize that we need to separate nodes based on their position (odd vs even)

Use Two Pointers

Initialize odd pointer at position 1, even pointer at position 2

Build Separate Chains

Connect all odd-positioned nodes together, all even-positioned nodes together

Link the Chains

Connect the end of odd chain to the beginning of even chain

Key Takeaway

🎯 Key Insight: By using two pointers to build separate chains for odd and even positioned nodes, we can rearrange the linked list in-place with optimal time and space complexity.

Asked in

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

The optimal solution uses two pointers to separate odd and even positioned nodes in a single pass. We maintain separate chains for odd and even nodes, then connect them at the end. This achieves O(n) time and O(1) space complexity, meeting all the problem constraints perfectly.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pointer Optimal Solution	O(n)	O(1)	Use two pointers to separate odd and even positioned nodes in a single pass

Two-Pointer Optimal Solution — Algorithm Steps

Initialize odd and even pointers to first and second nodes respectively
Keep track of the head of the even chain for later connection
Traverse the list, connecting odd nodes together and even nodes together
Connect the last odd node to the head of even chain
Return the original head (which is the first odd node)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set odd to first node, even to second node, remember even head

Build Chains

Connect odd nodes together and even nodes together separately

Connect Chains

Link the end of odd chain to the beginning of even chain

Code -

solution.c — C

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

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

struct ListNode* oddEvenList(struct ListNode* head) {
    if (!head || !head->next) return head;
    
    // Initialize pointers
    struct ListNode* odd = head;         // Points to current odd node
    struct ListNode* even = head->next;  // Points to current even node
    struct ListNode* evenHead = even;    // Remember start of even chain
    
    // Traverse and separate odd/even chains
    while (even && even->next) {
        // Connect current odd to next odd
        odd->next = even->next;
        odd = odd->next;
        
        // Connect current even to next even
        even->next = odd->next;
        even = even->next;
    }
    
    // Connect end of odd chain to start of even chain
    odd->next = evenHead;
    
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the linked list, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant number of pointers regardless of input size

✓ Linear Space

89.2K Views

High Frequency

~15 min Avg. Time

1.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-Pointer Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler