Segregate even and odd nodes in a Linked List

Last Updated : 27 May, 2026

Given a Linked List of integers, The task is to modify the linked list such that all even numbers appear before all the odd numbers in the modified linked list. Also, preserve the order of even and odd numbers.

Examples: 

Input:

2056958077

Output:

2056958078

Explanation: 8,2,4,6 are the even numbers so they appear first and 17,15,9 are odd numbers that appear later.

Input:

2056958079

Output:

2056958080

Explanation: There is no even number. So no need for modification.

Try It Yourself
redirect icon

Table of Content

Extraction of Even and Appending Odds - O(n) Time O(1) Space

The Idea is to traverse the list and extract all even nodes while maintaining order. Build a separate even list and finally append the remaining odd nodes.

1. Create an empty result list
2. Traverse the input list and move all even value nodes from the original list to the result list. If our original list was 17->15->8->12->10->5->4->1->7->6. Then after this step, we get original list as 17->15->5->1->7 and result list as 8->12->10->4->6
3. Append the remaining original list to the end of res and return result

C++ 
#include <iostream>
using namespace std;

class Node
{
  public:
    int data;
    Node *next;

    Node(int val)
    {
        data = val;
        next = nullptr;
    }
};

Node *divide(Node *head)
{

    // Result list to hold even nodes
    Node *resStart = nullptr;
    Node *resEnd = nullptr;

    // Pointers for the original list
    Node *curr = head;
    Node *prev = nullptr;

    // Move all even nodes from original
    // to result
    while (curr != nullptr)
    {

        // If current node is even
        if (curr->data % 2 == 0)
        {

            // Remove the current even node
            // from the original list
            if (prev != nullptr)
            {
                prev->next = curr->next;
            }
            else
            {
                // If the even node is at the head
                head = curr->next;
            }

            // Add the current even node to the result list
            if (resStart == nullptr)
            {
                resStart = curr;
                resEnd = resStart;
            }
            else
            {
                resEnd->next = curr;
                resEnd = resEnd->next;
            }

            curr = curr->next;
        }

        // If the node is odd, just move to the next
        else
        {
            prev = curr;
            curr = curr->next;
        }
    }

    // If there are no even nodes, return
    // the original list
    if (resStart == nullptr)
        return head;

    // Append the remaining original list
    // (odd nodes) to the result list
    resEnd->next = head;

    // Return the result list (starting with even nodes)
    return resStart;
}

// Driver Code
int main()
{

    // Creating linked list: 17->15->8->9->2->4->6
    Node *head = new Node(17);
    head->next = new Node(15);
    head->next->next = new Node(8);
    head->next->next->next = new Node(9);
    head->next->next->next->next = new Node(2);
    head->next->next->next->next->next = new Node(4);
    head->next->next->next->next->next->next = new Node(6);


    head = divide(head);

    Node *curr = head;
    while (curr != nullptr)
    {
        cout << curr->data;
        if (curr->next != nullptr)
            cout << "->";
        curr = curr->next;
    }

    return 0;
}
Java 
import java.util.*;

class Node {
  public int data;
  public Node next;

  public Node(int val) {
    data = val;
    next = null;
  }
}

public class GfG {
  public static Node divide(Node head) {

    // Result list to hold even nodes
    Node resStart = null;
    Node resEnd = null;

    // Pointers for the original list
    Node curr = head;
    Node prev = null;

    // Move all even nodes from original
    // to result
    while (curr!= null) {

      // If current node is even
      if (curr.data % 2 == 0) {

        // Remove the current even node
        // from the original list
        if (prev!= null) {
          prev.next = curr.next;
        } else {
          // If the even node is at the head
          head = curr.next;
        }

        // Add the current even node to the result list
        if (resStart == null) {
          resStart = curr;
          resEnd = resStart;
        } else {
          resEnd.next = curr;
          resEnd = resEnd.next;
        }

        curr = curr.next;
      }

      // If the node is odd, just move to the next
      else {
        prev = curr;
        curr = curr.next;
      }
    }

    // If there are no even nodes, return
    // the original list
    if (resStart == null)
      return head;

    // Append the remaining original list
    // (odd nodes) to the result list
    resEnd.next = head;

    // Return the result list (starting with even nodes)
    return resStart;
  }

  public static void main(String[] args) {

    // Creating linked list: 17->15->8->9->2->4->6
    Node head = new Node(17);
    head.next = new Node(15);
    head.next.next = new Node(8);
    head.next.next.next = new Node(9);
    head.next.next.next.next = new Node(2);
    head.next.next.next.next.next = new Node(4);
    head.next.next.next.next.next.next = new Node(6);


    head = divide(head);

    Node curr = head;
    while (curr!= null) {
      System.out.print(curr.data);
      if (curr.next!= null)
        System.out.print("->");
      curr = curr.next;
    }
  }
}
Python 
class Node:
    def __init__(self, val):
        self.data = val
        self.next = None

def divide(head):

    # Result list to hold even nodes
    resStart = None
    resEnd = None

    # Pointers for the original list
    curr = head
    prev = None

    # Move all even nodes from original
    # to result
    while curr is not None:

        # If current node is even
        if curr.data % 2 == 0:

            # Remove the current even node
            # from the original list
            if prev is not None:
                prev.next = curr.next
            else:
                # If the even node is at the head
                head = curr.next

            # Add the current even node to the result list
            if resStart is None:
                resStart = curr
                resEnd = resStart
            else:
                resEnd.next = curr
                resEnd = resEnd.next

            curr = curr.next

        # If the node is odd, just move to the next
        else:
            prev = curr
            curr = curr.next

    # If there are no even nodes, return
    # the original list
    if resStart is None:
        return head

    # Append the remaining original list
    # (odd nodes) to the result list
    resEnd.next = head

    # Return the result list (starting with even nodes)
    return resStart

# Driver Code
if __name__ == '__main__':

    # Creating linked list: 17->15->8->9->2->4->6
    head = Node(17)
    head.next = Node(15)
    head.next.next = Node(8)
    head.next.next.next = Node(9)
    head.next.next.next.next = Node(2)
    head.next.next.next.next.next = Node(4)
    head.next.next.next.next.next.next = Node(6)

    head = divide(head)

    curr = head
    while curr is not None:
        print(curr.data, end='' if curr.next is None else '->')
        curr = curr.next
C# 
using System;

public class Node
{
  public int data;
  public Node next;

  public Node(int val)
  {
      data = val;
      next = null;
  }
}

public class GfG
{
  public static Node divide(Node head)
  {
      // Result list to hold even nodes
      Node resStart = null;
      Node resEnd = null;

      // Pointers for the original list
      Node curr = head;
      Node prev = null;

      // Move all even nodes from original
      // to result
      while (curr!= null)
      {
          // If current node is even
          if (curr.data % 2 == 0)
          {
              // Remove the current even node
              // from the original list
              if (prev!= null)
              {
                  prev.next = curr.next;
              }
              else
              {
                  // If the even node is at the head
                  head = curr.next;
              }

              // Add the current even node to the result list
              if (resStart == null)
              {
                  resStart = curr;
                  resEnd = resStart;
              }
              else
              {
                  resEnd.next = curr;
                  resEnd = resEnd.next;
              }

              curr = curr.next;
          }

          // If the node is odd, just move to the next
          else
          {
              prev = curr;
              curr = curr.next;
          }
      }

      // If there are no even nodes, return
      // the original list
      if (resStart == null)
          return head;

      // Append the remaining original list
      // (odd nodes) to the result list
      resEnd.next = head;

      // Return the result list (starting with even nodes)
      return resStart;
  }

  public static void Main()
  {
      // Creating linked list: 17->15->8->9->2->4->6
      Node head = new Node(17);
      head.next = new Node(15);
      head.next.next = new Node(8);
      head.next.next.next = new Node(9);
      head.next.next.next.next = new Node(2);
      head.next.next.next.next.next = new Node(4);
      head.next.next.next.next.next.next = new Node(6);

      head = divide(head);

      Node curr = head;
      while (curr!= null)
      {
          Console.Write(curr.data);
          if (curr.next!= null)
              Console.Write("->");
          curr = curr.next;
      }
  }
}
JavaScript 
class Node {
  constructor(val) {
    this.data = val;
    this.next = null;
  }
}

function divide(head) {
  // Result list to hold even nodes
  let resStart = null;
  let resEnd = null;

  // Pointers for the original list
  let curr = head;
  let prev = null;

  // Move all even nodes from original
  // to result
  while (curr!== null) {
    // If current node is even
    if (curr.data % 2 === 0) {
      // Remove the current even node
      // from the original list
      if (prev!== null) {
        prev.next = curr.next;
      } else {
        // If the even node is at the head
        head = curr.next;
      }

      // Add the current even node to the result list
      if (resStart === null) {
        resStart = curr;
        resEnd = resStart;
      } else {
        resEnd.next = curr;
        resEnd = resEnd.next;
      }

      curr = curr.next;
    }

    // If the node is odd, just move to the next
    else {
      prev = curr;
      curr = curr.next;
    }
  }

  // If there are no even nodes, return
  // the original list
  if (resStart === null) return head;

  // Append the remaining original list
  // (odd nodes) to the result list
  resEnd.next = head;

  // Return the result list (starting with even nodes)
  return resStart;
}

// Driver Code
let head = new Node(17);
head.next = new Node(15);
head.next.next = new Node(8);
head.next.next.next = new Node(9);
head.next.next.next.next = new Node(2);
head.next.next.next.next.next = new Node(4);
head.next.next.next.next.next.next = new Node(6);

head = divide(head);

let curr = head;
while (curr!== null) {
  process.stdout.write(curr.data.toString());
  if (curr.next!== null) process.stdout.write("->");
  curr = curr.next;
}

Output
8->2->4->6->17->15->9

Time Complexity: O(n)
Auxiliary Space: O(1)

Maintaining Start and End - O(n) Time O(1) Space

The idea is to maintain two separate lists for even and odd nodes using dummy nodes. During traversal, append nodes to their respective lists and finally connect the even list to the odd list.

  • Initialize pointers for even and odd list , say evenStart , evenEnd and oddStart , oddEnd.
  • Separate nodes into even and odd lists during traversal. 
  • Link the end of the even list to the start of the odd list.
  • Update the original list's head to the even list's head.
C++ 
#include <bits/stdc++.h>
using namespace std;

struct Node {
    int data;
    Node* next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Function to segregate even and odd nodes 
// and return the head of the new list.
Node* divide(Node* head) {
  
    // We create dummy nodes to avoid extra 
    // condition checks in the while loop.
    Node* eStart = new Node(0);
    Node* oStart = new Node(0);
    
    // Pointers to the end of the even and
    // odd lists
    Node* eEnd = eStart;
    Node* oEnd = oStart;

    // Node to traverse the list
    Node* curr = head;

    while (curr != nullptr) {
        int val = curr->data;

        // If current value is even, add it 
        // to the even list
        if (val % 2 == 0) {
            eEnd->next = curr;
            eEnd = eEnd->next;
        } else { // Else to the odd list
            oEnd->next = curr;
            oEnd = oEnd->next;
        }

        // Move to the next node
        curr = curr->next;
    }

    // Terminate the odd list
    oEnd->next = nullptr;

    // Combine even and odd lists
    eEnd->next = oStart->next;

    // Return the new head of the 
    // combined list (even head)
    Node* newHead = eStart->next;

    // Clean up starting dummy nodes
    delete eStart;
    delete oStart;

    return newHead;
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << node->data << " ";
        node = node->next;
    }
}

int main() {
    // Let us create a sample linked list as following
    // 0->1->4->6->9->10->11
    Node* head = new Node(0);
    head->next = new Node(1);
    head->next->next = new Node(4);
    head->next->next->next = new Node(6);
    head->next->next->next->next = new Node(9);
    head->next->next->next->next->next = new Node(10);
    head->next->next->next->next->next->next = new Node(11);

    cout << "Original Linked list: ";
    printList(head);

    head = divide(head);

    cout << "\nModified Linked list: ";
    printList(head);

    return 0;
}
C 
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

// Function to create a new node
struct Node* newNode(int x) {
    struct Node* temp = 
      (struct Node*)malloc(sizeof(struct Node));
    temp->data = x;
    temp->next = NULL;
    return temp;
}

// Function to segregate even and odd nodes 
// and return the head of the new list.
struct Node* divide(struct Node* head) {
  
    // We create dummy nodes to avoid extra 
    // condition checks in the while loop.
    struct Node* eStart = newNode(0);
    struct Node* oStart = newNode(0);
    
    // Pointers to the end of the even and odd lists
    struct Node* eEnd = eStart;
    struct Node* oEnd = oStart;

    // Node to traverse the list
    struct Node* curr = head;

    while (curr != NULL) {
        int val = curr->data;

        // If current value is even, add it to the even list
        if (val % 2 == 0) {
            eEnd->next = curr;
            eEnd = eEnd->next;
        } else { // Else to the odd list
            oEnd->next = curr;
            oEnd = oEnd->next;
        }

        // Move to the next node
        curr = curr->next;
    }

    // Terminate the odd list
    oEnd->next = NULL;

    // Combine even and odd lists
    eEnd->next = oStart->next;

    // Return the new head of the combined list (even head)
    struct Node* newHead = eStart->next;

    // Clean up dummy nodes
    free(eStart);
    free(oStart);

    return newHead;
}

// Function to print the linked list
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}

int main() {
    // Let us create a sample linked list as following
    // 0->1->4->6->9->10->11
    struct Node* head = newNode(0);
    head->next = newNode(1);
    head->next->next = newNode(4);
    head->next->next->next = newNode(6);
    head->next->next->next->next = newNode(9);
    head->next->next->next->next->next = newNode(10);
    head->next->next->next->next->next->next = newNode(11);

    printf("Original Linked list: ");
    printList(head);

    head = divide(head);

    printf("\nModified Linked list: ");
    printList(head);

    return 0;
}
Java 
import java.util.*;

class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

public class GfG {

    // Function to segregate even and odd nodes
    // and return the head of the new list.
    public static Node divide(Node head) {

        // We create dummy nodes to avoid extra 
        // condition checks in the while loop.
        Node eStart = new Node(0);
        Node oStart = new Node(0);

        // Pointers to the end of the even and odd lists
        Node eEnd = eStart;
        Node oEnd = oStart;

        // Node to traverse the list
        Node curr = head;

        while (curr != null) {
            int val = curr.data;

            // If current value is even, add it to the even list
            if (val % 2 == 0) {
                eEnd.next = curr;
                eEnd = eEnd.next;
            } else { // Else to the odd list
                oEnd.next = curr;
                oEnd = oEnd.next;
            }

            // Move to the next node
            curr = curr.next;
        }

        // Terminate the odd list
        oEnd.next = null;

        // Combine even and odd lists
        eEnd.next = oStart.next;

        // Return the new head of the combined list (even head)
        return eStart.next;
    }

    // Function to print the linked list
    public static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }

    public static void main(String[] args) {
        // Let us create a sample linked list as following
        // 0->1->4->6->9->10->11
        Node head = new Node(0);
        head.next = new Node(1);
        head.next.next = new Node(4);
        head.next.next.next = new Node(6);
        head.next.next.next.next = new Node(9);
        head.next.next.next.next.next = new Node(10);
        head.next.next.next.next.next.next = new Node(11);

        System.out.print("Original Linked list: ");
        printList(head);

        head = divide(head);

        System.out.print("\nModified Linked list: ");
        printList(head);
    }
}
Python 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# Function to segregate even and odd nodes
# and return the head of the new list.
def divide(head):
  
    # We create dummy nodes to avoid extra 
    # condition checks in the while loop.
    eStart = Node(0)
    oStart = Node(0)

    # Pointers to the end of the even and odd lists
    eEnd = eStart
    oEnd = oStart

    # Node to traverse the list
    curr = head

    while curr:
        val = curr.data

        # If current value is even, add it to the even list
        if val % 2 == 0:
            eEnd.next = curr
            eEnd = eEnd.next
        else:  # Else to the odd list
            oEnd.next = curr
            oEnd = oEnd.next

        # Move to the next node
        curr = curr.next

    # Terminate the odd list
    oEnd.next = None

    # Combine even and odd lists
    eEnd.next = oStart.next

    # Return the new head of the combined list (even head)
    return eStart.next

# Function to print the linked list
def printList(node):
    while node:
        print(node.data, end=" ")
        node = node.next

if __name__ == "__main__":
    # Let us create a sample linked list as following
    # 0->1->4->6->9->10->11
    head = Node(0)
    head.next = Node(1)
    head.next.next = Node(4)
    head.next.next.next = Node(6)
    head.next.next.next.next = Node(9)
    head.next.next.next.next.next = Node(10)
    head.next.next.next.next.next.next = Node(11)

    print("Original Linked list: ", end="")
    printList(head)

    head = divide(head)

    print("\nModified Linked list: ", end="")
    printList(head)
C# 
using System;

class Node {
    public int data;
    public Node next;

    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Function to segregate even and odd nodes
    // and return the head of the new list.
    public static Node divide(Node head) {
        
        // We create dummy nodes to avoid extra 
        // condition checks in the while loop.
        Node eStart = new Node(0);
        Node oStart = new Node(0);

        // Pointers to the end of the even and odd lists
        Node eEnd = eStart;
        Node oEnd = oStart;

        // Node to traverse the list
        Node curr = head;

        while (curr != null) {
            int val = curr.data;

            // If current value is even, add it to the even list
            if (val % 2 == 0) {
                eEnd.next = curr;
                eEnd = eEnd.next;
            } else { // Else to the odd list
                oEnd.next = curr;
                oEnd = oEnd.next;
            }

            // Move to the next node
            curr = curr.next;
        }

        // Terminate the odd list
        oEnd.next = null;

        // Combine even and odd lists
        eEnd.next = oStart.next;

        // Return the new head of the combined list (even head)
        return eStart.next;
    }

    // Function to print the linked list
    public static void PrintList(Node node) {
        Node curr = node;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
    }

    public static void Main() {
        // Let us create a sample linked list as following
        // 0->1->4->6->9->10->11
        Node head = new Node(0);
        head.next = new Node(1);
        head.next.next = new Node(4);
        head.next.next.next = new Node(6);
        head.next.next.next.next = new Node(9);
        head.next.next.next.next.next = new Node(10);
        head.next.next.next.next.next.next = new Node(11);

        Console.Write("Original Linked list: ");
        PrintList(head);

        head = divide(head);

        Console.Write("\nModified Linked list: ");
        PrintList(head);
    }
}
JavaScript 
class Node {
    constructor(data)
    {
        this.data = data;
        this.next = null;
    }
}

// Function to segregate even and odd nodes
// and return the head of the new list.
function divide(head)
{

    // We create dummy nodes to avoid extra
    // condition checks in the while loop.
    let eStart = new Node(0);
    let oStart = new Node(0);

    // Pointers to the end of the even and odd lists
    let eEnd = eStart;
    let oEnd = oStart;

    // Node to traverse the list
    let curr = head;

    while (curr !== null) {
        let val = curr.data;

        // If current value is even, add it to the even list
        if (val % 2 === 0) {
            eEnd.next = curr;
            eEnd = eEnd.next;
        }
        else { // Else to the odd list
            oEnd.next = curr;
            oEnd = oEnd.next;
        }

        // Move to the next node
        curr = curr.next;
    }

    // Terminate the odd list
    oEnd.next = null;

    // Combine even and odd lists
    eEnd.next = oStart.next;

    // Return the new head of the combined list (even head)
    return eStart.next;
}

// Function to print the linked list
function printList(node)
{
    let curr = node;
    while (curr !== null) {
        process.stdout.write(curr.data + " ");
        curr = curr.next;
    }
}

// Let us create a sample linked list as following
// 0->1->4->6->9->10->11
let head = new Node(0);
head.next = new Node(1);
head.next.next = new Node(4);
head.next.next.next = new Node(6);
head.next.next.next.next = new Node(9);
head.next.next.next.next.next = new Node(10);
head.next.next.next.next.next.next = new Node(11);

process.stdout.write("Original Linked list: ");
printList(head);

head = divide(head);

process.stdout.write("\nModified Linked list: ");
printList(head);

Output
8->2->4->6->17->15->9

Time Complexity: O(n)
Auxiliary Space: O(1)

Comment
Article Tags:
Linked List
DSA
Amazon

Explore