Reverse a Linked List in groups of given size (Iterative Approach)

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

Examples:

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



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

Approach: We have already discussed a recursive solution in the posts Set 1 and Set 2. In this post, we will discuss an iterative solution to the above problem. Unlike the above solutions, we do not use any form of the stack to implement our solution. We reverse the first k nodes of the linked list. While reversing, we keep track of the first and last node of the k-reversed linked list using the join and tail pointer. After reversing the k nodes of the linked list, we join the nodes pointed by the tail pointer and join pointer and update them. We repeat this process until all groups of nodes are reversed.

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
struct Node {
    int data;
    struct Node* next;
};
  
/* Function to reverse the linked list in groups of 
size k and return the pointer to the new head node. */
Node* reverse(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 group of k nodes of the 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. We join the 
        tail pointer with the head of the next 
        k-reversed linked list's head */
        if (tail)
            tail->next = prev;
  
        /* The tail is then updated to the last node 
        of the next k-reverse linked list */
        tail = join;
    }
  
    /* newHead is new head of the input 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)
{
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
    }
}
  
// Driver code
int main()
{
  
    // Start with the empty list
    Node* head = NULL;
  
    // Created Linked list is
    // 1->2->3->4->5->6->7->8->9
    push(&head, 9);
    push(&head, 8);
    push(&head, 7);
    push(&head, 6);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, 2);
    push(&head, 1);
  
    int k = 3;
  
    cout << "Given linked list \n";
    printList(head);
    head = reverse(head, k);
  
    cout << "\nReversed 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; 
}; 
  
// Function to reverse the linked list in groups of 
//size k and return the pointer to the new head node. /
static Node reverse( 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 group of k nodes of the 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. We join the 
        tail pointer with the head of the next 
        k-reversed linked list's head */
        if (tail != null
            tail.next = prev; 
  
        /* The tail is then updated to the last node 
        of the next k-reverse linked list */
        tail = join; 
    
  
    // newHead is new head of the input list /
    return newHead; 
  
// Function to insert a node at 
// the head of the linked list 
static Node 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;
    return head_ref;
  
// Function to print the linked list 
static void printList(Node node) 
    while (node != null
    
        System.out.print( node.data + " "); 
        node = node.next; 
    
  
// Driver code 
public static void main(String args[])
  
    // Start with the empty list 
    Node head = null
  
    // Created Linked list is 
    // 1.2.3.4.5.6.7.8.9 
    head = push(head, 9); 
    head = push(head, 8); 
    head = push(head, 7); 
    head = push(head, 6); 
    head = push(head, 5); 
    head = push(head, 4); 
    head = push(head, 3); 
    head = push(head, 2); 
    head = push(head, 1); 
  
    int k = 3
  
    System.out.print( "Given linked list \n"); 
    printList(head); 
    head = reverse(head, k); 
  
    System.out.print( "\nReversed Linked list \n"); 
    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; 
}; 
  
// Function to reverse the linked list in groups of 
//size k and return the pointer to the new head node. /
static Node reverse( 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 group of k nodes of the 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. We join the 
        tail pointer with the head of the next 
        k-reversed linked list's head */
        if (tail != null
            tail.next = prev; 
  
        /* The tail is then updated to the last node 
        of the next k-reverse linked list */
        tail = join
    
  
    // newHead is new head of the input list /
    return newHead; 
  
// Function to insert a node at 
// the head of the linked list 
static Node 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;
    return head_ref;
  
// Function to print the linked list 
static void printList(Node node) 
    while (node != null
    
        Console.Write( node.data + " "); 
        node = node.next; 
    
  
// Driver code 
public static void Main(String []args)
  
    // Start with the empty list 
    Node head = null
  
    // Created Linked list is 
    // 1.2.3.4.5.6.7.8.9 
    head = push(head, 9); 
    head = push(head, 8); 
    head = push(head, 7); 
    head = push(head, 6); 
    head = push(head, 5); 
    head = push(head, 4); 
    head = push(head, 3); 
    head = push(head, 2); 
    head = push(head, 1); 
  
    int k = 3; 
  
    Console.Write( "Given linked list \n"); 
    printList(head); 
    head = reverse(head, k); 
  
    Console.Write( "\nReversed Linked list \n"); 
    printList(head); 
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

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

Time Complexity: O(n) where n is the number of nodes in the given list.
Space Complexity: O(1)



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 : andrew1234, 29AjayKumar