Reverse alternate K nodes in a Singly Linked List – Iterative Solution

Given a linked list and an integer K, the task is to reverse every alternate K nodes.

Examples:

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> NULL, K = 3
Output: 3 2 1 4 5 6 9 8 7

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> NULL, K = 5
Output: 5 4 3 2 1 6 7 8 9

Approach: We have already discussed a recursive solution here. In this post, we will discuss an iterative solution to the above problem. While traversing we process 2k nodes in one iteration and keep track of the first and last node of the group of k-nodes in the given linked list using the join and tail pointer. After reversing the k nodes of the linked list, we join the last node of the reversed list, pointed by the tail pointer, with the first node of the original list, pointed by the join pointer. We then move the current pointer until we skip the next k nodes.
The tail now becomes the last node of the normal list (which is pointed by the updated tail pointer) and join points to the first of the reversed list and they are then joined. We repeat this process until all the nodes are processed in the same way.



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Link list node
class Node {
public:
    int data;
    Node* next;
};
  
/* Function to reverse alternate k nodes and 
return the pointer to the new head node */
Node* kAltReverse(struct Node* head, int k)
{
    Node* prev = NULL;
    Node* curr = head;
    Node* temp = NULL;
    Node* tail = NULL;
    Node* newHead = NULL;
    Node* join = NULL;
    int t = 0;
  
    // Traverse till the end of the linked list
    while (curr) {
        t = k;
        join = curr;
        prev = NULL;
  
        /* Reverse alternative group of k nodes 
        // of the given linked list */
        while (curr && t--) {
            temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
  
        // Sets the new head of the input list
        if (!newHead)
            newHead = prev;
  
        /* Tail pointer keeps track of the last node 
        of the k-reversed linked list. The tail pointer 
        is then joined with the first node of the 
        next k-nodes of the linked list */
        if (tail)
            tail->next = prev;
  
        tail = join;
        tail->next = curr;
  
        t = k;
  
        /* Traverse through the next k nodes 
        which will not be reversed */
        while (curr && t--) {
            prev = curr;
            curr = curr->next;
        }
  
        /* Tail pointer keeps track of the last 
        node of the k nodes traversed above */
        tail = prev;
    }
  
    // newHead is new head of the modified list
    return newHead;
}
  
// Function to insert a node at
// the head of the linked list
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();
  
    /* put in the data */
    new_node->data = new_data;
  
    /* link the old list off the new node */
    new_node->next = (*head_ref);
  
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
  
// Function to print the linked list
void printList(Node* node)
{
    int count = 0;
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
        count++;
    }
}
  
// Driver code
int main(void)
{
  
    // Start with the empty list
    Node* head = NULL;
    int i;
  
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(&head, i);
  
    int k = 3;
  
    cout << "Given linked list \n";
    printList(head);
    head = kAltReverse(head, k);
  
    cout << "\n Modified Linked list \n";
    printList(head);
  
    return (0);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG 
{
  
// Link list node
static class Node
{
    int data;
    Node next;
};
static Node head;
  
/* Function to reverse alternate k nodes and 
return the pointer to the new head node */
static Node kAltReverse(Node head, int k)
{
    Node prev = null;
    Node curr = head;
    Node temp = null;
    Node tail = null;
    Node newHead = null;
    Node join = null;
    int t = 0;
  
    // Traverse till the end of the linked list
    while (curr != null
    {
        t = k;
        join = curr;
        prev = null;
  
        /* Reverse alternative group of k nodes 
        // of the given linked list */
        while (curr != null && t-- >0
        {
            temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
  
        // Sets the new head of the input list
        if (newHead == null)
            newHead = prev;
  
        /* Tail pointer keeps track of the last node 
        of the k-reversed linked list. The tail pointer 
        is then joined with the first node of the 
        next k-nodes of the linked list */
        if (tail != null)
            tail.next = prev;
  
        tail = join;
        tail.next = curr;
  
        t = k;
  
        /* Traverse through the next k nodes 
        which will not be reversed */
        while (curr != null && t-- >0)
        {
            prev = curr;
            curr = curr.next;
        }
  
        /* Tail pointer keeps track of the last 
        node of the k nodes traversed above */
        tail = prev;
    }
  
    // newHead is new head of the modified list
    return newHead;
}
  
// Function to insert a node at
// the head of the linked list
static void push(Node head_ref, int new_data)
{
    /* allocate node */
    Node new_node = new Node();
  
    /* put in the data */
    new_node.data = new_data;
  
    /* link the old list off the new node */
    new_node.next = head_ref;
  
    /* move the head to point to the new node */
    head_ref = new_node;
    head = head_ref;
}
  
// Function to print the linked list
static void printList(Node node)
{
    int count = 0;
    while (node != null)
    {
        System.out.print(node.data + " ");
        node = node.next;
        count++;
    }
}
  
// Driver code
public static void main(String[] args) 
{
    // Start with the empty list
    head = null;
    int i;
  
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(head, i);
  
    int k = 3;
  
    System.out.print("Given linked list \n");
    printList(head);
    head = kAltReverse(head, k);
  
    System.out.print("\n Modified Linked list \n");
    printList(head);
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of the approach
  
# Node class 
class Node: 
      
    # Function to initialise the node object 
    def __init__(self, data): 
        self.data = data # Assign data 
        self.next = None
          
head = None
  
# Function to reverse alternate k nodes and 
# return the pointer to the new head node 
def kAltReverse(head, k):
      
    prev = None
    curr = head
    temp = None
    tail = None
    newHead = None
    join = None
    t = 0
  
    # Traverse till the end of the linked list
    while (curr != None) :
      
        t = k
        join = curr
        prev = None
  
        # Reverse alternative group of k nodes 
        # of the given linked list 
        while (curr != None and t > 0): 
              
            t = t - 1
            temp = curr.next
            curr.next = prev
            prev = curr
            curr = temp
          
        # Sets the new head of the input list
        if (newHead == None):
            newHead = prev
  
        # Tail pointer keeps track of the last node 
        # of the k-reversed linked list. The tail pointer 
        # is then joined with the first node of the 
        # next k-nodes of the linked list 
        if (tail != None):
            tail.next = prev
  
        tail = join
        tail.next = curr
  
        t = k
  
        # Traverse through the next k nodes 
        # which will not be reversed 
        while (curr != None and t > 0):
            t = t - 1
            prev = curr
            curr = curr.next
          
        # Tail pointer keeps track of the last 
        # node of the k nodes traversed above 
        tail = prev
      
    # newHead is new head of the modified list
    return newHead
  
# Function to insert a node at
# the head of the linked list
def push(head_ref, new_data):
      
    global head
      
    # allocate node 
    new_node = Node(0)
  
    # put in the data 
    new_node.data = new_data
  
    # link the old list off the new node 
    new_node.next = head_ref
  
    # move the head to point to the new node 
    head_ref = new_node
    head = head_ref
  
# Function to print the linked list
def printList(node):
  
    count = 0
    while (node != None):
      
        print(node.data ,end= " ")
        node = node.next
        count = count + 1
      
# Driver code
  
# Start with the empty list
head = None
i = 10
  
# Create a list 1->2->3->4->...->10
while ( i > 0 ):
    push(head, i)
    i = i - 1
  
k = 3
  
print("Given linked list ")
printList(head)
head = kAltReverse(head, k)
  
print("\n Modified Linked list ")
printList(head)
  
# This code is contributed by Arnab Kundu

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG 
{
  
// Link list node
public class Node
{
    public int data;
    public Node next;
};
static Node head;
  
/* Function to reverse alternate k nodes and 
return the pointer to the new head node */
static Node kAltReverse(Node head, int k)
{
    Node prev = null;
    Node curr = head;
    Node temp = null;
    Node tail = null;
    Node newHead = null;
    Node join = null;
    int t = 0;
  
    // Traverse till the end of the linked list
    while (curr != null
    {
        t = k;
        join = curr;
        prev = null;
  
        /* Reverse alternative group of k nodes 
        // of the given linked list */
        while (curr != null && t-- >0) 
        {
            temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
  
        // Sets the new head of the input list
        if (newHead == null)
            newHead = prev;
  
        /* Tail pointer keeps track of the last node 
        of the k-reversed linked list. The tail pointer 
        is then joined with the first node of the 
        next k-nodes of the linked list */
        if (tail != null)
            tail.next = prev;
  
        tail = join;
        tail.next = curr;
  
        t = k;
  
        /* Traverse through the next k nodes 
        which will not be reversed */
        while (curr != null && t-- >0)
        {
            prev = curr;
            curr = curr.next;
        }
  
        /* Tail pointer keeps track of the last 
        node of the k nodes traversed above */
        tail = prev;
    }
  
    // newHead is new head of the modified list
    return newHead;
}
  
// Function to insert a node at
// the head of the linked list
static void push(Node head_ref, int new_data)
{
    /* allocate node */
    Node new_node = new Node();
  
    /* put in the data */
    new_node.data = new_data;
  
    /* link the old list off the new node */
    new_node.next = head_ref;
  
    /* move the head to point to the new node */
    head_ref = new_node;
    head = head_ref;
}
  
// Function to print the linked list
static void printList(Node node)
{
    int count = 0;
    while (node != null)
    {
        Console.Write(node.data + " ");
        node = node.next;
        count++;
    }
}
  
// Driver code
public static void Main(String[] args) 
{
    // Start with the empty list
    head = null;
    int i;
  
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(head, i);
  
    int k = 3;
  
    Console.Write("Given linked list \n");
    printList(head);
    head = kAltReverse(head, k);
  
    Console.Write("\nModified Linked list \n");
    printList(head);
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

Given linked list 
1 2 3 4 5 6 7 8 9 10 
 Modified Linked list 
3 2 1 4 5 6 9 8 7 10

Time Complexity: O(n)
Space Complexity: O(1)

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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Rajput-Ji, andrew1234