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

• Difficulty Level : Medium
• Last Updated : 11 Nov, 2021

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

 `// C++ implementation of the approach``#include ``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);``}`

## Java

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

## Python

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

## C#

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

## Javascript

 ``

Output:

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