Rearrange a linked list such that all even and odd positioned nodes are together

Rearrange a linked list in such a way that all odd position nodes are together and all even positions node are together, 
Examples:

Input:   1->2->3->4
Output:  1->3->2->4

Input:   10->22->30->43->56->70
Output:  10->30->56->22->43->70

The important thing in this question is to make sure that all below cases are handled 

1. Empty linked list 
2. A linked list with only one node 
3. A linked list with only two nodes 
4. A linked list with an odd number of nodes 
5. A linked list with an even number of nodes

The below program maintains two pointers ‘odd’ and ‘even’ for current nodes at odd and even positions respectively. We also store the first node of even linked list so that we can attach the even list at the end of odd list after all odd and even nodes are connected together in two different lists.

Implementation:

C++

// C++ program to rearrange a linked list in such a
// way that all odd positioned node are stored before
// all even positioned nodes
#include<bits/stdc++.h>
using namespace std;

// Linked List Node
class Node
{
    public:
    int data;
    Node* next;
};

// A utility function to create a new node
Node* newNode(int key)
{
    Node *temp = new Node;
    temp->data = key;
    temp->next = NULL;
    return temp;
}

// Rearranges given linked list such that all even
// positioned nodes are before odd positioned.
// Returns new head of linked List.
Node *rearrangeEvenOdd(Node *head)
{
    // Corner case
    if (head == NULL)
        return NULL;

    // Initialize first nodes of even and
    // odd lists
    Node *odd = head;
    Node *even = head->next;

    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node *evenFirst = even;

    while (1)
    {
        // If there are no more nodes, then connect
        // first node of even list to the last node
        // of odd list
        if (!odd || !even || !(even->next))
        {
            odd->next = evenFirst;
            break;
        }

        // Connecting odd nodes
        odd->next = even->next;
        odd = even->next;

        // If there are NO more even nodes after
        // current odd.
        if (odd->next == NULL)
        {
            even->next = NULL;
            odd->next = evenFirst;
            break;
        }

        // Connecting even nodes
        even->next = odd->next;
        even = odd->next;
    }

    return head;
}

// A utility function to print a linked list
void printlist(Node * node)
{
    while (node != NULL)
    {
        cout << node->data << "->";
        node = node->next;
    }
    cout << "NULL" << endl;
}

// Driver code
int main(void)
{
    Node *head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);

    cout << "Given Linked List\n";
    printlist(head);

    head = rearrangeEvenOdd(head);

    cout << "Modified Linked List\n";
    printlist(head);

    return 0;
}

// This is code is contributed by rathbhupendra

C

// C program to rearrange a linked list in such a
// way that all odd positioned node are stored before
// all even positioned nodes
#include<bits/stdc++.h>
using namespace std;

// Linked List Node
struct Node
{
    int data;
    struct Node* next;
};

// A utility function to create a new node
Node* newNode(int key)
{
    Node *temp = new Node;
    temp->data = key;
    temp->next = NULL;
    return temp;
}

// Rearranges given linked list such that all even
// positioned nodes are before odd positioned.
// Returns new head of linked List.
Node *rearrangeEvenOdd(Node *head)
{
    // Corner case
    if (head == NULL)
        return NULL;

    // Initialize first nodes of even and
    // odd lists
    Node *odd = head;
    Node *even = head->next;

    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node *evenFirst = even;

    while (1)
    {
        // If there are no more nodes, then connect
        // first node of even list to the last node
        // of odd list
        if (!odd || !even || !(even->next))
        {
            odd->next = evenFirst;
            break;
        }

        // Connecting odd nodes
        odd->next = even->next;
        odd = even->next;

        // If there are NO more even nodes after
        // current odd.
        if (odd->next == NULL)
        {
            even->next = NULL;
            odd->next = evenFirst;
            break;
        }

        // Connecting even nodes
        even->next = odd->next;
        even = odd->next;
    }

    return head;
}

// A utility function to print a linked list
void printlist(Node * node)
{
    while (node != NULL)
    {
        cout << node->data << "->";
        node = node->next;
    }
    cout << "NULL" << endl;
}

// Driver code
int main(void)
{
    Node *head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);

    cout << "Given Linked List\n";
    printlist(head);

    head = rearrangeEvenOdd(head);

    cout << "\nModified Linked List\n";
    printlist(head);

    return 0;
}

Java

// Java program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes
class GfG
{

// Linked List Node
static class Node
{
    int data;
    Node next;
}

// A utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.data = key;
    temp.next = null;
    return temp;
}

// Rearranges given linked list
// such that all even positioned
// nodes are before odd positioned.
// Returns new head of linked List.
static Node rearrangeEvenOdd(Node head)
{
    // Corner case
    if (head == null)
        return null;

    // Initialize first nodes of even and
    // odd lists
    Node odd = head;
    Node even = head.next;

    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node evenFirst = even;

    while (1 == 1)
    {
        // If there are no more nodes,
        // then connect first node of even
        // list to the last node of odd list
        if (odd == null || even == null ||
                        (even.next) == null)
        {
            odd.next = evenFirst;
            break;
        }

        // Connecting odd nodes
        odd.next = even.next;
        odd = even.next;

        // If there are NO more even nodes
        // after current odd.
        if (odd.next == null)
        {
            even.next = null;
            odd.next = evenFirst;
            break;
        }

        // Connecting even nodes
        even.next = odd.next;
        even = odd.next;
    }
    return head;
}

// A utility function to print a linked list
static void printlist(Node node)
{
    while (node != null)
    {
        System.out.print(node.data + "->");
        node = node.next;
    }
    System.out.println("NULL") ;
}

// Driver code
public static void main(String[] args)
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);

    System.out.println("Given Linked List");
    printlist(head);

    head = rearrangeEvenOdd(head);

    System.out.println("Modified Linked List");
    printlist(head);
}
}

// This code is contributed by Prerna saini

Python3

# Python3 program to rearrange a linked list
# in such a way that all odd positioned
# node are stored before all even positioned nodes

# Linked List Node
class Node:
    def __init__(self, d):
        self.data = d
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    # A utility function to create
    # a new node
    def newNode(self, key):
        temp = Node(key)
        self.next = None
        return temp

    # Rearranges given linked list
    # such that all even positioned
    # nodes are before odd positioned.
    # Returns new head of linked List.
    def rearrangeEvenOdd(self, head):

        # Corner case
        if (self.head == None):
            return None

        # Initialize first nodes of
        # even and odd lists
        odd = self.head
        even = self.head.next

        # Remember the first node of even list so
        # that we can connect the even list at the
        # end of odd list.
        evenFirst = even

        while (1 == 1):

            # If there are no more nodes,
            # then connect first node of even
            # list to the last node of odd list
            if (odd == None or even == None or
                              (even.next) == None):
                odd.next = evenFirst
                break

            # Connecting odd nodes
            odd.next = even.next
            odd = even.next

            # If there are NO more even nodes
            # after current odd.
            if (odd.next == None):
                even.next = None
                odd.next = evenFirst
                break

            # Connecting even nodes
            even.next = odd.next
            even = odd.next
        return head

    # A utility function to print a linked list
    def printlist(self, node):
        while (node != None):
            print(node.data, end = "")
            print("->", end = "")
            node = node.next
        print ("NULL")

    # Function to insert a new node
    # at the beginning
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

# Driver code
ll = LinkedList()
ll.push(5)
ll.push(4)
ll.push(3)
ll.push(2)
ll.push(1)
print ("Given Linked List")
ll.printlist(ll.head)

start = ll.rearrangeEvenOdd(ll.head)

print ("\nModified Linked List")
ll.printlist(start)

# This code is contributed by Prerna Saini

C#

// C# program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes
using System;

class GfG
{

    // Linked List Node
    class Node
    {
        public int data;
        public Node next;
    }

    // A utility function to create a new node
    static Node newNode(int key)
    {
        Node temp = new Node();
        temp.data = key;
        temp.next = null;
        return temp;
    }

    // Rearranges given linked list
    // such that all even positioned
    // nodes are before odd positioned.
    // Returns new head of linked List.
    static Node rearrangeEvenOdd(Node head)
    {
        // Corner case
        if (head == null)
            return null;

        // Initialize first nodes of even and
        // odd lists
        Node odd = head;
        Node even = head.next;

        // Remember the first node of even list so
        // that we can connect the even list at the
        // end of odd list.
        Node evenFirst = even;

        while (1 == 1)
        {
            // If there are no more nodes,
            // then connect first node of even
            // list to the last node of odd list
            if (odd == null || even == null ||
                            (even.next) == null)
            {
                odd.next = evenFirst;
                break;
            }

            // Connecting odd nodes
            odd.next = even.next;
            odd = even.next;

            // If there are NO more even nodes
            // after current odd.
            if (odd.next == null)
            {
                even.next = null;
                odd.next = evenFirst;
                break;
            }

            // Connecting even nodes
            even.next = odd.next;
            even = odd.next;
        }
        return head;
    }

    // A utility function to print a linked list
    static void printlist(Node node)
    {
        while (node != null)
        {
            Console.Write(node.data + "->");
            node = node.next;
        }
        Console.WriteLine("NULL") ;
    }

    // Driver code
    public static void Main()
    {
        Node head = newNode(1);
        head.next = newNode(2);
        head.next.next = newNode(3);
        head.next.next.next = newNode(4);
        head.next.next.next.next = newNode(5);

        Console.WriteLine("Given Linked List");
        printlist(head);

        head = rearrangeEvenOdd(head);

        Console.WriteLine("Modified Linked List");
        printlist(head);
    }
}

/* This code is contributed PrinciRaj1992 */

Javascript

<script>

// Javascript program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes

    // Linked List Node
     class Node {
            constructor() {
                this.data = 0;
                this.next = null;
            }
        }
    // A utility function to create a new node
    function newNode(key) {
var temp = new Node();
        temp.data = key;
        temp.next = null;
        return temp;
    }

    // Rearranges given linked list
    // such that all even positioned
    // nodes are before odd positioned.
    // Returns new head of linked List.
    function rearrangeEvenOdd(head) {
        // Corner case
        if (head == null)
            return null;

        // Initialize first nodes of even and
        // odd lists
var odd = head;
var even = head.next;

        // Remember the first node of even list so
        // that we can connect the even list at the
        // end of odd list.
var evenFirst = even;

        while (1 == 1) {
            // If there are no more nodes,
            // then connect first node of even
            // list to the last node of odd list
            if (odd == null || even == null ||
            (even.next) == null)
            {
                odd.next = evenFirst;
                break;
            }

            // Connecting odd nodes
            odd.next = even.next;
            odd = even.next;

            // If there are NO more even nodes
            // after current odd.
            if (odd.next == null) {
                even.next = null;
                odd.next = evenFirst;
                break;
            }

            // Connecting even nodes
            even.next = odd.next;
            even = odd.next;
        }
        return head;
    }

    // A utility function to print a linked list
    function printlist(node) {
        while (node != null) {
            document.write(node.data + "->");
            node = node.next;
        }
        document.write("NULL<br/>");
    }

    // Driver code

var head = newNode(1);
        head.next = newNode(2);
        head.next.next = newNode(3);
        head.next.next.next = newNode(4);
        head.next.next.next.next = newNode(5);

        document.write("Given Linked List<br/>");
        printlist(head);

        head = rearrangeEvenOdd(head);

        document.write("Modified Linked List<br/>");
        printlist(head);

// This code contributed by gauravrajput1

</script>

Output

Given Linked List
1->2->3->4->5->NULL
Modified Linked List
1->3->5->2->4->NULL

Time complexity: O(n) since using a loop to traverse the list, where n is the size of the linked list
Auxiliary Space: O(1)

This article is contributed by Harsh Parikh.Please see here another code contributed by Gautam Singh.If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 

A More Clean Concise Code:

Approach:

1. Have 4 Pointers
2. OddStart, OddEnd, EvenStart, EvenEnd.
3. As the names are made, the pointers also point in such a way.
4. Atlast simply connect the end of Odd List to Start of Even List. 
5. Mark the Even List End as NULL.

C++

// C++ Code in Odd -> Even Index Position
#include<bits/stdc++.h>
using namespace std;

// Linked List Node
struct Node
{
    int data;
    struct Node* next;
};

// A utility function to create a new node
Node* newNode(int key)
{
    Node *temp = new Node;
    temp->data = key;
    temp->next = NULL;
    return temp;
}


void rearrangeEvenOdd(Node *head)
{
  if(head==NULL || head->next == NULL){
    // 0 or 1 node
    return;
  }
  Node* temp = head;
  Node* oddStart = NULL; //ODD INDEX
  Node* oddEnd = NULL;
  Node* evenStart = NULL; //EVEN INDEX
  Node* evenEnd = NULL;

  int i = 1;
  while(temp != NULL){

    if(i%2 ==0){
      //even
      if(evenStart == NULL){
        evenStart = temp;

      }
      else{
        evenEnd->next = temp;

      }
      evenEnd = temp;
    }
    else{
      //odd
      if(oddStart == NULL){
        oddStart = temp;
      }
      else{
        oddEnd->next = temp;
      }
      oddEnd = temp;
    }
    temp = temp->next;
    i++;
  }

  //now join the odd end with even start
  oddEnd->next = evenStart;
  //even end is new end so put NULL
  evenEnd->next = NULL;

  head = oddStart; //new head
}

void printlist(Node * node)
{
    while (node != NULL)
    {
        cout << node->data << "->";
        node = node->next;
    }
    cout << "NULL" << endl;
}

// Driver code
int main(void)
{
    Node *head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);
    head->next->next->next->next->next = newNode(6);

    cout << "Given Linked List\n";
    printlist(head);

    rearrangeEvenOdd(head);

    cout << "\nModified Linked List\n";
    printlist(head);

    return 0;
}

Java

// Java program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes
import java.util.*;

// Linked List Node
class Node {
  int data;
  Node next;
  Node(int data)
  {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  Node head;
  LinkedList() { this.head = null; }
  // A utility function to create
  // a new node
  Node newNode(int key)
  {
    Node temp = new Node(key);
    temp.next = null;
    return temp;
  }
  // Function to rearrane the Linked List
  Node rearrangeEvenOdd(Node head)
  {
    // Corner case
    if (head == null || head.next == null) {
      return null;
    }
    Node temp = head;
    Node oddStart = null;
    Node oddEnd = null;
    Node evenStart = null;
    Node evenEnd = null;
    int i = 1;
    while (temp != null) {
      if (i % 2 == 0) {
        // even
        if (evenStart == null) {
          evenStart = temp;
        }
        else {
          evenEnd.next = temp;
        }
        evenEnd = temp;
      }
      else {
        // odd
        if (oddStart == null) {
          oddStart = temp;
        }
        else {
          oddEnd.next = temp;
        }
        oddEnd = temp;
      }
      temp = temp.next;
      i = i + 1;
    }
    oddEnd.next = evenStart;
    evenEnd.next = null;
    return oddStart;
  }
  // A utility function to print a linked list
  void printlist(Node node)
  {
    while (node != null) {
      System.out.print(node.data + "->");
      node = node.next;
    }
    System.out.println("NULL");
  }
  // Function to insert a new node
  // at the beginning
  void push(int new_data)
  {
    Node new_node = new Node(new_data);
    new_node.next = head;
    head = new_node;
  }
}

class Main {
  // Driver code
  public static void main(String[] args)
  {
    LinkedList ll = new LinkedList();
    ll.push(6);
    ll.push(5);
    ll.push(4);
    ll.push(3);
    ll.push(2);
    ll.push(1);
    System.out.println("Given Linked List");
    ll.printlist(ll.head);
    Node start = ll.rearrangeEvenOdd(ll.head);
    System.out.println("\nModified Linked List");
    ll.printlist(start);
  }
}

// This code is contributed by Tapesh(tapeshdua420)

Python3

# Python3 program to rearrange a linked list
# in such a way that all odd positioned
# node are stored before all even positioned nodes

# Linked List Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    # A utility function to create
    # a new node
    def newNode(self, key):
        temp = Node(key)
        self.next = None
        return temp

    # Function to rearrane the Linked List
    def rearrangeEvenOdd(self, head):
        # Corner case
        if (self.head == None or self.head.next == None):
            return None

        temp = self.head
        oddStart = None
        oddEnd = None
        evenStart = None
        evenEnd = None

        i = 1

        while (temp is not None):
            if(i % 2 == 0):
              # even
              if evenStart is None :
                  evenStart = temp
              else:
                  evenEnd.next = temp
              evenEnd = temp
            else:
              #odd
              if oddStart is None :
                  oddStart = temp
              else:
                  oddEnd.next = temp
              oddEnd = temp
            temp = temp.next
            i = i+1

        oddEnd.next = evenStart
        evenEnd.next = None
        return oddStart

    # A utility function to print a linked list
    def printlist(self, node):
        while (node != None):
            print(node.data, end="")
            print("->", end="")
            node = node.next
        print("NULL")

    # Function to insert a new node
    # at the beginning
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

# Driver code
ll = LinkedList()
ll.push(6)
ll.push(5)
ll.push(4)
ll.push(3)
ll.push(2)
ll.push(1)
print("Given Linked List")
ll.printlist(ll.head)

start = ll.rearrangeEvenOdd(ll.head)

print("\nModified Linked List")
ll.printlist(start)

# This code is contributed by Yash Agarwal(yashagarwal2852002)

C#

// C# Program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes

using System;

class GfG{

  // Linked List Node
  class Node{
    public int data;
    public Node next;
  }

  // A utility function of create a new Node
  static Node newNode(int key){
    Node temp = new Node();
    temp.data = key;
    temp.next = null;
    return temp;
  }

  // Function to rearrange Linked list
  static Node rearrangeEvenOdd(Node head){
    // Corner Case
    if(head == null || head.next == null) return null;

    Node temp = head;
    Node oddStart = null;
    Node oddEnd = null;
    Node evenStart = null;
    Node evenEnd = null;

    int i = 1;
    while(temp != null){
      if(i%2 == 0){
        //even
        if(evenStart == null) evenStart = temp;
        else evenEnd.next = temp;

        evenEnd = temp;
      }else{
        //odd
        if(oddStart == null) oddStart = temp;
        else oddEnd.next = temp;

        oddEnd = temp;
      }
      temp = temp.next;
      i++;
    }

    // now join the odd ned with even start
    oddEnd.next = evenStart;
    evenEnd.next = null;
    return oddStart;
  }
  static void printlist(Node node)
  {
    while (node != null)
    {
      Console.Write(node.data + "->");
      node = node.next;
    }
    Console.WriteLine("NULL") ;
  }

  // Driver code
  public static void Main()
  {
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);
    head.next.next.next.next.next = newNode(6);

    Console.WriteLine("Given Linked List");
    printlist(head);

    head = rearrangeEvenOdd(head);

    Console.WriteLine("\nModified Linked List");
    printlist(head);
  }
}

/* This code is contributed Yash Agarwal(yashagarwal2852002) */

Javascript

// JavaScript program to rearrange a linked list
// in such a way that all odd positioned
// node are stored before all even positioned nodes

// Linked List Node
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

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

    // A utility function to create
    // a new node
    newNode(key) {
        temp = new Node(key);
        this.next = null;
        return temp;
    }

    // Function to rearrane the Linked List
    rearrangeEvenOdd(head) {
        // Corner case
        if (this.head == null || this.head.next == null) {
            return null;
        }

        var temp = this.head;
        var oddStart = null;
        var oddEnd = null;
        var evenStart = null;
        var evenEnd = null;

        var i = 1;

        while (temp != null) {
            if (i % 2 == 0) {
                // even
                if (evenStart == null) {
                    evenStart = temp;
                } else {
                    evenEnd.next = temp;
                }
                evenEnd = temp;
            } else {
                //odd
                if (oddStart == null) {
                    oddStart = temp;
                } else {
                    oddEnd.next = temp;
                }
                oddEnd = temp;
            }
            temp = temp.next;
            i = i + 1;
        }

        oddEnd.next = evenStart;
        evenEnd.next = null;
        return oddStart;
    }

    // A utility function to print a linked list
    printlist(node) {
        while (node != null) {
            process.stdout.write(node.data+"->");
            node = node.next;
        }
        console.log("NULL");
    }

    // Function to insert a new node
    // at the beginning
    push(new_data) {
        var new_node = new Node(new_data);
        new_node.next = this.head;
        this.head = new_node;
    }
}

// Driver code
ll = new LinkedList();
ll.push(6);
ll.push(5);
ll.push(4);
ll.push(3);
ll.push(2);
ll.push(1);
console.log("Given Linked List");
ll.printlist(ll.head);

start = ll.rearrangeEvenOdd(ll.head);

console.log("\nModified Linked List");
ll.printlist(start);

// This code is contributed by Tapesh(tapeshdua420)

Output

Given Linked List
1->2->3->4->5->6->NULL

Modified Linked List
1->3->5->2->4->6->NULL

Time complexity: O(n) since using a loop to traverse the list, where n is the size of the linked list
Auxiliary Space: O(1) As only few pointers.