Given a linked list. The task is to segregate its even and odd position nodes in such a way that odd position nodes appear before even positioned nodes all the even positioned nodes must be in reverse order.
Examples:
Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL
Output : 1 -> 3 -> 5 -> 6 -> 4 -> 2 -> NULLInput : 1 -> 2 -> 3 -> 4 -> 5 -> NULL
Output : 1 -> 3 -> 5 -> 4 -> 2 -> NULL
Source: Microsoft Interview
Approach:
A similar problem has been discussed in the given link, but there the even part was not reversed. Maintains two-pointers odd and even for current nodes at odd and even positions respectively. Also, store the first node of the even linked list so that we can attach the even list at the end of the odd list after all odd and even nodes are connected together in two different lists. Once the even list has been separated, we just need to reverse it. Reversing a linked list can be found here. Once the even list is reversed, attach it to the odd linked list.
Below is the implementation of the above approach:
// C++ program to Append odd position nodes // in reverse at the end of even // positioned nodes in a Linked List #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 // in a reverse 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)) {
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;
break ;
}
// Connecting evenevenFirs nodes
even->next = odd->next;
even = odd->next;
}
// Reversal of even linked list
Node* current = evenFirst;
Node* prev = NULL;
Node* front = NULL;
// Iterate in the complete linked list
while (current != NULL) {
front = current->next;
current->next = prev;
prev = current;
current = front;
}
evenFirst = prev;
// Attach the reversed even linked
// list to odd linked list
odd->next = evenFirst;
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);
head->next->next->next->next->next = newNode(6);
head = rearrangeEvenOdd(head);
printlist(head);
return 0;
} |
// Java program to Append odd position nodes // in reverse at the end of even // positioned nodes in a Linked List class sol
{ // 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 // in a reverse 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 ( true )
{
// 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 )
{
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 ;
break ;
}
// Connecting evenevenFirs nodes
even.next = odd.next;
even = odd.next;
}
// Reversal of even linked list
Node current = evenFirst;
Node prev = null ;
Node front = null ;
// Iterate in the complete linked list
while (current != null )
{
front = current.next;
current.next = prev;
prev = current;
current = front;
}
evenFirst = prev;
// Attach the reversed even linked
// list to odd linked list
odd.next = evenFirst;
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 );
head.next.next.next.next.next = newNode( 6 );
head = rearrangeEvenOdd(head);
printlist(head);
} } // This code is contributed by Arnab Kundu |
# Python3 program to Append odd position nodes # in reverse at the end of even # positioned nodes in a Linked List import math
# Linked List Node class Node:
def __init__( self , data):
self .data = data
self . next = None
# A utility function to create a new node def newNode(key):
temp = Node(key)
temp.data = key
temp. next = None
return temp
# Rearranges given linked list such that # all even positioned nodes are before # odd positioned in a reverse def rearrangeEvenOdd(head):
# Corner case
if (head = = None ):
return None
# Initialize first nodes of even and
# odd lists
odd = head
even = 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 True :
# 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 ):
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
break
# Connecting evenevenFirs nodes
even. next = odd. next
even = odd. next
# Reversal of even linked list
current = evenFirst
prev = None
front = None
# Iterate in the complete linked list
while (current ! = None ):
front = current. next
current. next = prev
prev = current
current = front
evenFirst = prev
# Attach the reversed even linked
# list to odd linked list
odd. next = evenFirst
return head
# A utility function to print a linked list def printlist(node):
while (node ! = None ) :
print (node.data, end = "->" )
node = node. next
print ( "NULL" )
# Driver code if __name__ = = '__main__' :
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 )
head = rearrangeEvenOdd(head)
printlist(head)
# This code is contributed by Srathore |
// C# program to Append odd position nodes // in reverse at the end of even // positioned nodes in a Linked List using System;
class GFG
{ // Linked List Node public 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 in a reverse 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 ( true )
{
// 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 )
{
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 ;
break ;
}
// Connecting evenevenFirs nodes
even.next = odd.next;
even = odd.next;
}
// Reversal of even linked list
Node current = evenFirst;
Node prev = null ;
Node front = null ;
// Iterate in the complete linked list
while (current != null )
{
front = current.next;
current.next = prev;
prev = current;
current = front;
}
evenFirst = prev;
// Attach the reversed even linked
// list to odd linked list
odd.next = evenFirst;
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(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);
head.next.next.next.next.next = newNode(6);
head = rearrangeEvenOdd(head);
printlist(head);
} } // This code is contributed by PrinciRaj1992 |
<script> // JavaScript program to Append odd position nodes // in reverse at the end of even // positioned nodes in a Linked List // 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
// in a reverse
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 ( true ) {
// 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 )
{
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 ;
break ;
}
// Connecting evenevenFirs nodes
even.next = odd.next;
even = odd.next;
}
// Reversal of even linked list
var current = evenFirst;
var prev = null ;
var front = null ;
// Iterate in the complete linked list
while (current != null ) {
front = current.next;
current.next = prev;
prev = current;
current = front;
}
evenFirst = prev;
// Attach the reversed even linked
// list to odd linked list
odd.next = evenFirst;
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" );
}
// 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);
head.next.next.next.next.next = newNode(6);
head = rearrangeEvenOdd(head);
printlist(head);
// This code is contributed by todaysgaurav </script> |
1 -> 3 -> 5 -> 6 -> 4 -> 2 -> NULL
Complexity Analysis:
- Time Complexity: O(N), as we are using a loop to traverse N times. Where N is the number of nodes in the linked list.
- Auxiliary Space: O(1), as we are not using any extra space for the string.