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 <bits/stdc++.h>using namespace std;// Link list nodeclass 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 listvoid 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 of 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 listvoid printList(Node* node){ int count = 0; while (node != NULL) { cout << node->data << " "; node = node->next; count++; }}// Driver codeint 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 approachclass GFG {// Link list nodestatic 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 liststatic 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 of 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 liststatic void printList(Node node){ int count = 0; while (node != null) { System.out.print(node.data + " "); node = node.next; count++; }}// Driver codepublic 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 listdef 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 of 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 listdef printList(node): count = 0 while (node != None): print(node.data ,end= " ") node = node.next count = count + 1 # Driver code# Start with the empty listhead = Nonei = 10# Create a list 1->2->3->4->...->10while ( i > 0 ): push(head, i) i = i - 1k = 3print("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 approachusing System;class GFG {// Link list nodepublic 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 liststatic 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 of 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 liststatic void printList(Node node){ int count = 0; while (node != null) { Console.Write(node.data + " "); node = node.next; count++; }}// Driver codepublic 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
<script>// javascript implementation of the approach // Link list nodeclass Node { constructor(val) { this.data = val; this.next = null; }} var head; /* * Function to reverse alternate k nodes and return the pointer to the new head * node */ 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; // 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 function push(head_ref , new_data) { /* allocate node */var new_node = new Node(); /* put in the data */ new_node.data = new_data; /* link the old list of 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 function printList(node) { var count = 0; while (node != null) { document.write(node.data + " "); node = node.next; count++; } } // Driver code // Start with the empty list head = null; var i; // Create a list 1->2->3->4->...->10 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);// This code contributed by gauravrajput1 </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)
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
