Reverse a Linked List in Groups of Given Size

Create a function that would reverse every t nodes in a linked list (where t is an input to the function).

Example:

   • Input: 11->12->13->14->15->16->17->18->NULL, t = 3 
Output: 13->12->11->16->15->14->18->17->NULL 

   • Input: 11->12->13->14->15->16->17->18->NULL, t = 5 
Output: 15->14->13->12->11->18->17->16->NULL

Algorithm: reverse(head, t)

Reverse the first t-th sub-list. Maintain track of the next and previous nodes when reversing. Let next be the pointer to the next node and prev be the pointer to the previous node.
Head -> next = reverse (next, t) (Recursively obtain the rest of the list and connect the two sub-lists)
Return prev(prev becomes the new list's head).

The illustration below displays how the reverse process is functioning:

Reverse a Linked List in Groups of Given Size

The given technique is implemented as follows:

C Program:

#include<stdio.h>
#include<stdlib.h>
struct Node
{
	int val;
	struct Node* next;
};

struct Node *reversed (struct Node *head1, int t)
{
	if (!head1)
		return NULL;
	
	struct Node* current = head1;
	struct Node* next = NULL;
	struct Node* previous = NULL;
	int count = 0;
	
	while (current != NULL && count < t)
	{
		next = current -> next;
		current -> next = previous;
		previous = current;
		current = next;
		count++;
	}
	
	if (next != NULL)
	head1 -> next = reversed(next, t);

	return previous;
}

void push(struct Node** headreference, int newval)
{
	struct Node* newNode =
			(struct Node*) malloc(sizeof(struct Node));

	newNode -> val = newval;

	newNode -> next = (*headreference);	

	(*headreference) = newNode;
}

void printingLst(struct Node *node)
{
	while (node != NULL)
	{
		printf("%d ", node -> val);
		node = node -> next;
	}
}	

int main(void)
{
	struct Node* head1 = NULL;

	push(&head1, 19);
	push(&head1, 18);
	push(&head1, 17);
	push(&head1, 16);
	push(&head1, 15);
	push(&head1, 14);
	push(&head1, 13);
	push(&head1, 12);
	push(&head1, 11);		

	printf("\nGiven linked list \n");
	printingLst(head1);
	head1 = reversed(head1, 3);

	printf("\nReversed Linked list \n");
	printingLst(head1);

	return(0);
}
C++ Program:
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
	int val;
	Node* next;
};
Node* reversed(Node* head1, int t)
{
	if (!head1)
		return NULL;
	Node* current = head1;
	Node* next = NULL;
	Node* previous = NULL;
	int count = 0;

	while (current != NULL && count < t) {
		next = current -> next;
		current -> next = previous;
		previous = current;
		current = next;
		count++;
	}

	if (next != NULL)
		head1 -> next = reversed(next, t);

	return previous;
}

void push(Node** headreference, int newval)
{
	Node* newNode = new Node();

	newNode -> val = newval;

	newNode -> next = (*headreference);

	(*headreference) = newNode;
}
void printingLst(Node* node)
{
	while (node != NULL) {
		cout << node ->val << " ";
		node = node -> next;
	}
}
int main()
{
	Node* head1 = NULL;

	push(&head1, 19);
	push(&head1, 18);
	push(&head1, 17);
	push(&head1, 16);
	push(&head1, 15);
	push(&head1, 14);
	push(&head1, 13);
	push(&head1, 12);
	push(&head1, 11);

	cout << "Given linked list \n";
	printingLst(head1);
	head1 = reversed(head1, 3);

	cout << "\nReversed Linked list \n";
	printingLst(head1);

	return (0);
}

Output:

Given linked list 
11 12 13 14 15 16 17 18 19 
Reversed Linked list 
13 12 11 16 15 14 19 18 17

Analysis of Complexity:

Time Complexity will be O (n).

The list is traversed just once, and it contains 'n' elements.

Auxiliary Space will be O(n/t).

During the recursion, calls will be performed for each Linked List of size n, n/t, or (n/t)+1.

This problem can be solved in O(1) Space Complexity.

Approach - 2 (Space Optimization - Iterative)

This Algorithm necessitates the following steps:

Make a duplicate node and point it to the input's head, as in duplicate -> next = head.
Determine the size of the linked list in O(N) time, where N is the linked list's size.
For each group, initialise three-pointers prior, curr, and next to reverse t elements.
Iterate through the linked lists until next!=NULL is reached.
curr points to the previous->next and next to the curr next.
Then, using the inner for loop, reverse the specific group using the following four steps:
- curr->next = next->next
- next->next = prev->next
- prev->next = next
- next = curr->next
For all groups except the final remaining member, this for loop runs for t-1 times; for the last remaining element, it runs for the length of the linked list minus one.
To estimate the size of the remaining linked list, increment count after the for loop by t cnt -= t.
Set the prev position to curr, so that prev = curr.

The code for the aforementioned algorithm is provided below.

C Program:

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
	int val;
	struct Node* next;
} Node;

Node* reversed(Node* head1, int t)
{
	if (!head1 || t == 1)
		return head1;
	Node* dplicate = (Node*)malloc(sizeof(Node));
	dplicate -> val = -1;
	dplicate -> next = head1;

	Node *previous = dplicate, *current = dplicate, *next = dplicate;

	int count = 0;
	while (current) {
		current = current -> next;
		count++;
	}
	while (next) {
		current = previous -> next;
		next = current -> next;

		int toLoop = count > t ? t : count - 1;
		for (int i = 1; i < toLoop; i++) {
			current -> next = next -> next;
			next -> next = previous -> next;
			previous -> next = next;
			next = current -> next;
		}
		previous = current;
		count -= t;
	}
	return dplicate -> next;
}
void push(Node** headreference, int newval)
{
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode -> val = newval;
	newNode -> next = (*headreference);
	(*headreference) = newNode;
}
void printingLst(Node* node)
{
	while (node != NULL) {
		printf("%d ", node -> val);
		node = node -> next;
	}
}
int main()
{
	Node* head1 = NULL;
	push(&head1, 19);
	push(&head1, 18);
	push(&head1, 17);
	push(&head1, 16);
	push(&head1, 15);
	push(&head1, 14);
	push(&head1, 13);
	push(&head1, 12);
	push(&head1, 11);

	printf("Given linked list \n");
	printingLst(head1);
	head1 = reversed(head1, 3);

	printf("\nReversed Linked list \n");
	printingLst(head1);

	return (0);
}

C++ Program:

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
	int val;
	Node* next;
};

Node* reversed(Node* head1, int t)
{
	if (!head1 || t == 1)
		return head1;

	Node* dplicate = new Node();
	dplicate -> val = -1;
	dplicate -> next = head1;

	Node *previous = dplicate, *current = dplicate, *next = dplicate;
	int count = 0;
	while (current) {
		current = current -> next;
		count++;
	}
	while (next) {
		current = previous -> next;
		next = current -> next;
		int toLoop = count > t ? t : count - 1;
		for (int i = 1; i < toLoop; i++) {
			// 4 steps as discussed above
			current -> next = next -> next;
			next -> next = previous -> next;
			previous -> next = next;
			next = current -> next;
		}
		previous = current;
		count -= t;
	}
	return dplicate -> next;
}
void push(Node** headRef, int newData)
{
	Node* newNode = new Node();

	newNode -> val = newData;
	newNode -> next = (*headRef);
	(*headRef) = newNode;
}
void printingLst(Node* node)
{
	while (node != NULL) {
		cout << node -> val << " ";
		node = node -> next;
	}
}
int main()
{
	Node* head1 = NULL;
	push(&head1, 19);
	push(&head1, 18);
	push(&head1, 17);
	push(&head1, 16);
	push(&head1, 15);
	push(&head1, 14);
	push(&head1, 13);
	push(&head1, 12);
	push(&head1, 11);

	cout << "Given linked list \n";
	printingLst(head1);
	head1 = reversed(head1, 3);

	cout << "\nReversed Linked list \n";
	printingLst(head1);

	return (0);
}

Output:

Given linked list 
11 12 13 14 15 16 17 18 19 
Reversed Linked list 
13 12 11 16 15 14 19 18 17

Analysis of Complexity:

Time Complexity will be O(N).

The while loop consumes O(N/t) time, whereas the inner for loop consumes O(t) time.

Auxiliary Space will be O(1).

There is no extra space used.

Next TopicReverse Alternate K nodes in a Singly Linked List

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

DS Tutorial

DS Array

DS Linked List

DS Stack

DS Queue

DS Tree

DS Graph

DS Searching

DS Sorting

Differences

Misc

DS MCQ