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++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
};
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;
while (curr) {
t = k;
join = curr;
prev = NULL;
while (curr && t--) {
temp = curr->next;
curr->next = prev;
prev = curr;
curr = temp;
}
if (!newHead)
newHead = prev;
if (tail)
tail->next = prev;
tail = join;
tail->next = curr;
t = k;
while (curr && t--) {
prev = curr;
curr = curr->next;
}
tail = prev;
}
return newHead;
}
void push(Node** head_ref, int new_data)
{
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(Node* node)
{
int count = 0;
while (node != NULL) {
cout << node->data << " " ;
node = node->next;
count++;
}
}
int main( void )
{
Node* head = NULL;
int i;
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
class GFG
{
static class Node
{
int data;
Node next;
};
static Node head;
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 ;
while (curr != null )
{
t = k;
join = curr;
prev = null ;
while (curr != null && t-- > 0 )
{
temp = curr.next;
curr.next = prev;
prev = curr;
curr = temp;
}
if (newHead == null )
newHead = prev;
if (tail != null )
tail.next = prev;
tail = join;
tail.next = curr;
t = k;
while (curr != null && t-- > 0 )
{
prev = curr;
curr = curr.next;
}
tail = prev;
}
return newHead;
}
static void push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head = head_ref;
}
static void printList(Node node)
{
int count = 0 ;
while (node != null )
{
System.out.print(node.data + " " );
node = node.next;
count++;
}
}
public static void main(String[] args)
{
head = null ;
int i;
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);
}
}
|
Python
class Node:
def __init__( self , data):
self .data = data
self . next = None
head = None
def kAltReverse(head, k):
prev = None
curr = head
temp = None
tail = None
newHead = None
join = None
t = 0
while (curr ! = None ) :
t = k
join = curr
prev = None
while (curr ! = None and t > 0 ):
t = t - 1
temp = curr. next
curr. next = prev
prev = curr
curr = temp
if (newHead = = None ):
newHead = prev
if (tail ! = None ):
tail. next = prev
tail = join
tail. next = curr
t = k
while (curr ! = None and t > 0 ):
t = t - 1
prev = curr
curr = curr. next
tail = prev
return newHead
def push(head_ref, new_data):
global head
new_node = Node( 0 )
new_node.data = new_data
new_node. next = head_ref
head_ref = new_node
head = head_ref
def printList(node):
count = 0
while (node ! = None ):
print (node.data ,end = " " )
node = node. next
count = count + 1
head = None
i = 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)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static Node head;
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;
while (curr != null )
{
t = k;
join = curr;
prev = null ;
while (curr != null && t-- >0)
{
temp = curr.next;
curr.next = prev;
prev = curr;
curr = temp;
}
if (newHead == null )
newHead = prev;
if (tail != null )
tail.next = prev;
tail = join ;
tail.next = curr;
t = k;
while (curr != null && t-- >0)
{
prev = curr;
curr = curr.next;
}
tail = prev;
}
return newHead;
}
static void push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head = head_ref;
}
static void printList(Node node)
{
int count = 0;
while (node != null )
{
Console.Write(node.data + " " );
node = node.next;
count++;
}
}
public static void Main(String[] args)
{
head = null ;
int i;
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);
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
var head;
function kAltReverse(head , k) {
var prev = null ;
var curr = head;
var temp = null ;
var tail = null ;
var newHead = null ;
var join = null ;
var t = 0;
while (curr != null ) {
t = k;
join = curr;
prev = null ;
while (curr != null && t-- > 0) {
temp = curr.next;
curr.next = prev;
prev = curr;
curr = temp;
}
if (newHead == null )
newHead = prev;
if (tail != null )
tail.next = prev;
tail = join;
tail.next = curr;
t = k;
while (curr != null && t-- > 0) {
prev = curr;
curr = curr.next;
}
tail = prev;
}
return newHead;
}
function push(head_ref , new_data) {
var new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
head = head_ref;
}
function printList(node) {
var count = 0;
while (node != null ) {
document.write(node.data + " " );
node = node.next;
count++;
}
}
head = null ;
var i;
for (i = 10; i > 0; i--)
push(head, i);
var k = 3;
document.write( "Given linked list <br/>" );
printList(head);
head = kAltReverse(head, k);
document.write( "<br/>Modified Linked list <br/>" );
printList(head);
</script>
|
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)
Last Updated :
14 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...