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 odd number of nodes
5) A linked list with even number of nodes



The below program maintains two pointers ‘odd’ and ‘even’ for current nodes at odd an even positions respectively. We also store 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.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 */

chevron_right



Output:

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

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 contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.