Append odd position nodes in reverse at the end of even positioned nodes in a Linked List

Last Updated : 13 Sep, 2022

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

Input : 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++

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

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

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

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

Javascript

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

Output

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.

Segregate even and odd nodes in a Linked List

Striver

Improve

Article Tags :

Practice Tags :

Append odd position nodes in reverse at the end of even positioned nodes in a Linked List

C++

Java

Python3

C#

Javascript

Similar Reads