# 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
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The important thing in this question is to make sure that all below cases are handled
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++

 `// C++ program to rearrange a linked list in such a  ` `// way that all odd positioned node are stored before  ` `// all even positioned nodes  ` `#include  ` `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 ` `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 */`

Output:

```Given Linked List
1->2->3->4->5->NULL
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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

10

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