Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Reverse a Linked List in groups of a Given Size using C++
In this article, we deal with a singly linked list, and the task is to reverse the list in groups of k. For example −
Input: 1->2->3->4->5->6->7->8->NULL, K = 3 Output: 3->2->1->6->5->4->8->7->NULL Input: 1->2->3->4->5->6->7->8->NULL, K = 5 Output: 5->4->3->2->1->8
For this problem, one approach that comes to mind is trailing the list and reversing the list when our sublist’s size reaches k and continues.
Approach to find The Solution
In this approach, we will generally traverse through the list and keep a counter to count the number of elements in our sub-list. When the counter reaches the count of k, we reverse that part.
Example
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* next;
};
Node* reverse(Node* head, int k) {
if (!head)
return NULL;
Node* curr = head;
Node* next = NULL;
Node* prev = NULL;
int count = 0;
while (curr != NULL && count < k) { // we reverse the list till our count is less than k
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
count++;
}
if (next != NULL) // if our link list has not ended we call reverse function again
head->next = reverse(next, k);
return prev;
}
void push(Node** head_ref, int new_data) { // function for pushing data in the list
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(Node* node) { // function to print linked list
while (node != NULL) {
cout << node->data << " ";
node = node->next;
}
cout << "\n";
}
int main() {
Node* head = NULL;
int k = 3; // the given k
push(&head, 8);
push(&head, 7);
push(&head, 6);
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
cout << "Original list \n";
printList(head);
head = reverse(head, k); // this function will return us our new head
cout << "New list \n";
printList(head);
return (0);
}Output
Original list 1 2 3 4 5 6 7 8 New list 3 2 1 6 5 4 8 7
The above approach has a time complexity of O(N), where N is the size of our given list, and this approach works on recursion. This approach can work for higher constraints as well.
Explanation of the above code
We will traverse through the array in this approach and keep reversing it till our counter variable is less than k. When our counter reaches the value of k, we call another reversing function to connect the last node of this sub-list to the first node of the next reversed sub-list. This is being done by recursion.
Conclusion
In this article, we solve a problem to Reverse a Linked List in groups of a given size using recursion. We also learned the C++ program for this problem and the complete approach ( Normal) by which we solved this problem. We can write the same program in other languages such as C, java, python, and other languages. We hope you find this article helpful.
164 Views
