 Open in App
Not now

# Reverse a Linked List in groups of given size

• Difficulty Level : Medium
• Last Updated : 10 Jan, 2023

Given a linked list, write a function to reverse every k nodes (where k is an input to the function).

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->7->6->NULL

• Reverse the first sub-list of size k. While reversing keep track of the next node and previous node. Let the pointer to the next node be next and pointer to the previous node be prev. See this post for reversing a linked list.
• head->next = reverse(next, k) ( Recursively call for rest of the list and link the two sub-lists )
• Return prev ( prev becomes the new head of the list (see the diagrams of an iterative method of this post )

Below is image shows how the reverse function works: Below is the implementation of the above approach:

## C++

 `// CPP program to reverse a linked list ` `// in groups of given size ` `#include ` `using` `namespace` `std; ` ` `  `/* Link list node */` `class` `Node { ` `public``: ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `/* Reverses the linked list in groups ` `of size k and returns the pointer ` `to the new head node. */` `Node* reverse(Node* head, ``int` `k) ` `{ ` `    ``// base case ` `    ``if` `(!head) ` `        ``return` `NULL; ` `    ``Node* current = head; ` `    ``Node* next = NULL; ` `    ``Node* prev = NULL; ` `    ``int` `count = 0; ` ` `  `    ``/*reverse first k nodes of the linked list */` `    ``while` `(current != NULL && count < k) { ` `        ``next = current->next; ` `        ``current->next = prev; ` `        ``prev = current; ` `        ``current = next; ` `        ``count++; ` `    ``} ` ` `  `    ``/* next is now a pointer to (k+1)th node ` `    ``Recursively call for the list starting from current. ` `    ``And make rest of the list as next of first node */` `    ``if` `(next != NULL) ` `        ``head->next = reverse(next, k); ` ` `  `    ``/* prev is new head of the input list */` `    ``return` `prev; ` `} ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to push a node */` `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; ` `} ` ` `  `/* Function to print linked list */` `void` `printList(Node* node) ` `{ ` `    ``while` `(node != NULL) { ` `        ``cout << node->data << ``" "``; ` `        ``node = node->next; ` `    ``} ` `} ` ` `  `/* Driver code*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``Node* head = NULL; ` ` `  `    ``/* Created Linked list  ` `       ``is 1->2->3->4->5->6->7->8->9 */` `    ``push(&head, 9); ` `    ``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 << ``"Given linked list \n"``; ` `    ``printList(head); ` `    ``head = reverse(head, 3); ` ` `  `    ``cout << ``"\nReversed Linked list \n"``; ` `    ``printList(head); ` ` `  `    ``return` `(0); ` `} ` ` `  `// This code is contributed by rathbhupendra`

## C

 `// C program to reverse a linked list in groups of given size ` `#include ` `#include ` ` `  `/* Link list node */` `struct` `Node ` `{ ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Reverses the linked list in groups of size k and returns the  ` `   ``pointer to the new head node. */` `struct` `Node *reverse (``struct` `Node *head, ``int` `k) ` `{ ` `    ``if` `(!head) ` `        ``return` `NULL; ` `   `  `    ``struct` `Node* current = head; ` `    ``struct` `Node* next = NULL; ` `    ``struct` `Node* prev = NULL; ` `    ``int` `count = 0;  ` `   `  `     `  `     `  `    ``/*reverse first k nodes of the linked list */`  `    ``while` `(current != NULL && count < k) ` `    ``{ ` `        ``next  = current->next; ` `        ``current->next = prev; ` `        ``prev = current; ` `        ``current = next; ` `        ``count++; ` `    ``} ` `     `  `    ``/* next is now a pointer to (k+1)th node  ` `       ``Recursively call for the list starting from current. ` `       ``And make rest of the list as next of first node */` `    ``if` `(next !=  NULL) ` `       ``head->next = reverse(next, k);  ` ` `  `    ``/* prev is new head of the input list */` `    ``return` `prev; ` `} ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to push a node */` `void` `push(``struct` `Node** head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``struct` `Node* new_node = ` `            ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `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 linked list */` `void` `printList(``struct` `Node *node) ` `{ ` `    ``while` `(node != NULL) ` `    ``{ ` `        ``printf``(``"%d  "``, node->data); ` `        ``node = node->next; ` `    ``} ` `}     ` ` `  `/* Driver code*/` `int` `main(``void``) ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` `  `  `     ``/* Created Linked list is 1->2->3->4->5->6->7->8->9 */` `     ``push(&head, 9); ` `     ``push(&head, 8); ` `     ``push(&head, 7); ` `     ``push(&head, 6); ` `     ``push(&head, 5); ` `     ``push(&head, 4); ` `     ``push(&head, 3); ` `     ``push(&head, 2); ` `     ``push(&head, 1);            ` ` `  `     ``printf``(``"\nGiven linked list \n"``); ` `     ``printList(head); ` `     ``head = reverse(head, 3); ` ` `  `     ``printf``(``"\nReversed Linked list \n"``); ` `     ``printList(head); ` ` `  `     ``return``(0); ` `} `

## Java

 `// Java program to reverse a linked list in groups of ` `// given size ` `class` `LinkedList { ` `    ``Node head; ``// head of list ` ` `  `    ``/* Linked list Node*/` `    ``class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `        ``Node(``int` `d) ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``Node reverse(Node head, ``int` `k) ` `    ``{ ` `        ``if``(head == ``null``) ` `          ``return` `null``; ` `        ``Node current = head; ` `        ``Node next = ``null``; ` `        ``Node prev = ``null``; ` ` `  `        ``int` `count = ``0``; ` ` `  `        ``/* Reverse first k nodes of linked list */` `        ``while` `(count < k && current != ``null``) { ` `            ``next = current.next; ` `            ``current.next = prev; ` `            ``prev = current; ` `            ``current = next; ` `            ``count++; ` `        ``} ` ` `  `        ``/* next is now a pointer to (k+1)th node ` `           ``Recursively call for the list starting from ` `           ``current. And make rest of the list as next of ` `           ``first node */` `        ``if` `(next != ``null``) ` `            ``head.next = reverse(next, k); ` ` `  `        ``// prev is now head of input list ` `        ``return` `prev; ` `    ``} ` ` `  `    ``/* Utility functions */` ` `  `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data) ` `    ``{ ` `        ``/* 1 & 2: Allocate the Node & ` `                  ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data); ` ` `  `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head; ` ` `  `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node; ` `    ``} ` ` `  `    ``/* Function to print linked list */` `    ``void` `printList() ` `    ``{ ` `        ``Node temp = head; ` `        ``while` `(temp != ``null``) { ` `            ``System.out.print(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `        ``System.out.println(); ` `    ``} ` ` `  `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` ` `  `        ``/* Constructed Linked List is 1->2->3->4->5->6-> ` `           ``7->8->8->9->null */` `        ``llist.push(``9``); ` `        ``llist.push(``8``); ` `        ``llist.push(``7``); ` `        ``llist.push(``6``); ` `        ``llist.push(``5``); ` `        ``llist.push(``4``); ` `        ``llist.push(``3``); ` `        ``llist.push(``2``); ` `        ``llist.push(``1``); ` ` `  `        ``System.out.println(``"Given Linked List"``); ` `        ``llist.printList(); ` ` `  `        ``llist.head = llist.reverse(llist.head, ``3``); ` ` `  `        ``System.out.println(``"Reversed list"``); ` `        ``llist.printList(); ` `    ``} ` `} ` `/* This code is contributed by Rajat Mishra */`

## Python3

 `# Python program to reverse a  ` `# linked list in group of given size ` ` `  `# Node class ` ` `  ` `  `class` `Node: ` ` `  `    ``# Constructor to initialize the node object ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  ` `  `class` `LinkedList: ` ` `  `    ``# Function to initialize head ` `    ``def` `__init__(``self``): ` `        ``self``.head ``=` `None` ` `  `    ``def` `reverse(``self``, head, k): ` `       `  `        ``if` `head ``=``=` `None``: ` `          ``return` `None` `        ``current ``=` `head ` `        ``next` `=` `None` `        ``prev ``=` `None` `        ``count ``=` `0` ` `  `        ``# Reverse first k nodes of the linked list ` `        ``while``(current ``is` `not` `None` `and` `count < k): ` `            ``next` `=` `current.``next` `            ``current.``next` `=` `prev ` `            ``prev ``=` `current ` `            ``current ``=` `next` `            ``count ``+``=` `1` ` `  `        ``# next is now a pointer to (k+1)th node ` `        ``# recursively call for the list starting ` `        ``# from current. And make rest of the list as ` `        ``# next of first node ` `        ``if` `next` `is` `not` `None``: ` `            ``head.``next` `=` `self``.reverse(``next``, k) ` ` `  `        ``# prev is new head of the input list ` `        ``return` `prev ` ` `  `    ``# Function to insert a new node at the beginning ` `    ``def` `push(``self``, new_data): ` `        ``new_node ``=` `Node(new_data) ` `        ``new_node.``next` `=` `self``.head ` `        ``self``.head ``=` `new_node ` ` `  `    ``# Utility function to print the linked LinkedList ` `    ``def` `printList(``self``): ` `        ``temp ``=` `self``.head ` `        ``while``(temp): ` `            ``print``(temp.data,end``=``' '``) ` `            ``temp ``=` `temp.``next` ` `  ` `  `# Driver program ` `llist ``=` `LinkedList() ` `llist.push(``9``) ` `llist.push(``8``) ` `llist.push(``7``) ` `llist.push(``6``) ` `llist.push(``5``) ` `llist.push(``4``) ` `llist.push(``3``) ` `llist.push(``2``) ` `llist.push(``1``) ` ` `  `print``(``"Given linked list"``) ` `llist.printList() ` `llist.head ``=` `llist.reverse(llist.head, ``3``) ` ` `  `print` `(``"\nReversed Linked list"``) ` `llist.printList() ` ` `  `# This code is contributed by Nikhil Kumar Singh(nickzuck_007) `

## C#

 `// C# program to reverse a linked list ` `// in groups of given size ` `using` `System; ` ` `  `public` `class` `LinkedList { ` `    ``Node head; ``// head of list ` ` `  `    ``/* Linked list Node*/` `    ``class` `Node { ` `        ``public` `int` `data; ` `        ``public` `Node next; ` `        ``public` `Node(``int` `d) ` `        ``{ ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``Node reverse(Node head, ``int` `k) ` `    ``{ ` `        ``if``(head == ``null``) ` `          ``return` `null``; ` `        ``Node current = head; ` `        ``Node next = ``null``; ` `        ``Node prev = ``null``; ` ` `  `        ``int` `count = 0; ` ` `  `        ``/* Reverse first k nodes of linked list */` `        ``while` `(count < k && current != ``null``) { ` `            ``next = current.next; ` `            ``current.next = prev; ` `            ``prev = current; ` `            ``current = next; ` `            ``count++; ` `        ``} ` ` `  `        ``/* next is now a pointer to (k+1)th node ` `            ``Recursively call for the list starting from ` `           ``current. And make rest of the list as next of ` `           ``first node */` `        ``if` `(next != ``null``) ` `            ``head.next = reverse(next, k); ` ` `  `        ``// prev is now head of input list ` `        ``return` `prev; ` `    ``} ` ` `  `    ``/* Utility functions */` ` `  `    ``/* Inserts a new Node at front of the list. */` `    ``public` `void` `push(``int` `new_data) ` `    ``{ ` `        ``/* 1 & 2: Allocate the Node & ` `                ``Put in the data*/` `        ``Node new_node = ``new` `Node(new_data); ` ` `  `        ``/* 3. Make next of new Node as head */` `        ``new_node.next = head; ` ` `  `        ``/* 4. Move the head to point to new Node */` `        ``head = new_node; ` `    ``} ` ` `  `    ``/* Function to print linked list */` `    ``void` `printList() ` `    ``{ ` `        ``Node temp = head; ` `        ``while` `(temp != ``null``) { ` `            ``Console.Write(temp.data + ``" "``); ` `            ``temp = temp.next; ` `        ``} ` `        ``Console.WriteLine(); ` `    ``} ` ` `  `    ``/* Driver code*/` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` ` `  `        ``/* Constructed Linked List is 1->2->3->4->5->6-> ` `        ``7->8->8->9->null */` `        ``llist.push(9); ` `        ``llist.push(8); ` `        ``llist.push(7); ` `        ``llist.push(6); ` `        ``llist.push(5); ` `        ``llist.push(4); ` `        ``llist.push(3); ` `        ``llist.push(2); ` `        ``llist.push(1); ` ` `  `        ``Console.WriteLine(``"Given Linked List"``); ` `        ``llist.printList(); ` ` `  `        ``llist.head = llist.reverse(llist.head, 3); ` ` `  `        ``Console.WriteLine(``"Reversed list"``); ` `        ``llist.printList(); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar`

## Javascript

 ` `

Output

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

Complexity Analysis:

• Time Complexity: O(n).
Traversal of list is done only once and it has ‘n’ elements.
• Auxiliary Space: O(n/k).
For each Linked List of size n, n/k or (n/k)+1 calls will be made during the recursion.

We can solve this question in O(1) Space Complexity.

### Approach – 2 Space Optimized – Iterative

The following steps are required for this Algorithm:

1. Create a dummy node and point it to the head of input i.e dummy->next = head.
2.  Calculate the length of the linked list which takes O(N) time, where N is the length of the linked list.
3.  Initialize three-pointers prev, curr, next to reverse k elements for every group.
4. Iterate over the linked lists till next!=NULL.
5. Points curr to the prev->next and next to the curr next.
6. Then, Using the inner for loop reverse the particular group using these four steps:
• curr->next = next->next
• next->next = prev->next
• prev->next = next
• next = curr->next

7. This for loop runs for k-1 times for all groups except the last remaining element, for the last remaining element it runs              for the remaining length of the linked list – 1.

8. Decrement count after for loop by k count -= k, to determine the length of the remaining linked list.

9. Change prev position to curr, prev = curr.

Here is the code for the above algorithm.

## C++

 `// CPP program to reverse a linked list ` `// in groups of given size ` `#include ` `using` `namespace` `std; ` ` `  `/* Link list node */` `class` `Node { ` `public``: ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `/* Reverses the linked list in groups ` `of size k and returns the pointer ` `to the new head node. */` `Node* reverse(Node* head, ``int` `k) ` `{ ` `    ``// If head is NULL or K is 1 then return head ` `    ``if` `(!head || k == 1) ` `        ``return` `head; ` ` `  `    ``Node* dummy = ``new` `Node(); ``// creating dummy node ` `    ``dummy->data = -1; ` `    ``dummy->next = head; ` ` `  `    ``// Initializing three points prev, curr, next ` `    ``Node *prev = dummy, *curr = dummy, *next = dummy; ` ` `  `    ``// Calculating the length of linked list ` `    ``int` `count = 0; ` `    ``while` `(curr) { ` `        ``curr = curr->next; ` `        ``count++; ` `    ``} ` ` `  `    ``// Iterating till next is not NULL ` `    ``while` `(next) { ` `        ``// Curr position after every reverse group ` `        ``curr = prev->next; ` `        ``// Next will always next to curr ` `        ``next = curr->next; ` `        ``// toLoop will set to count - 1 in case of remaining ` `        ``// element ` `        ``int` `toLoop = count > k ? k : count - 1; ` `        ``for` `(``int` `i = 1; i < toLoop; i++) { ` `            ``// 4 steps as discussed above ` `            ``curr->next = next->next; ` `            ``next->next = prev->next; ` `            ``prev->next = next; ` `            ``next = curr->next; ` `        ``} ` `        ``// Setting prev to curr ` `        ``prev = curr; ` `        ``// Update count ` `        ``count -= k; ` `    ``} ` `    ``// dummy -> next will be our new head for output linked ` `    ``// list ` `    ``return` `dummy->next; ` `} ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to push a node */` `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; ` `} ` ` `  `/* Function to print linked list */` `void` `printList(Node* node) ` `{ ` `    ``while` `(node != NULL) { ` `        ``cout << node->data << ``" "``; ` `        ``node = node->next; ` `    ``} ` `} ` ` `  `/* Driver code*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``Node* head = NULL; ` ` `  `    ``/* Created Linked list ` `    ``is 1->2->3->4->5->6->7->8->9 */` `    ``push(&head, 9); ` `    ``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 << ``"Given linked list \n"``; ` `    ``printList(head); ` `    ``head = reverse(head, 3); ` ` `  `    ``cout << ``"\nReversed Linked list \n"``; ` `    ``printList(head); ` ` `  `    ``return` `(0); ` `} ` ` `  `// This code is contributed by Sania Kumari Gupta ` `// (kriSania804)`

## C

 `// C program to reverse a linked list ` `// in groups of given size ` `#include ` `#include ` ` `  `/* Link list node */` `typedef` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `} Node; ` ` `  `// Reverses the linked list in groups of size k and returns ` `// the pointer to the new head node. ` `Node* reverse(Node* head, ``int` `k) ` `{ ` `    ``// If head is NULL or K is 1 then return head ` `    ``if` `(!head || k == 1) ` `        ``return` `head; ` `    ``// creating dummy node ` `    ``Node* dummy = (Node*)``malloc``(``sizeof``(Node)); ` `    ``dummy->data = -1; ` `    ``dummy->next = head; ` ` `  `    ``// Initializing three points prev, curr, next ` `    ``Node *prev = dummy, *curr = dummy, *next = dummy; ` ` `  `    ``// Calculating the length of linked list ` `    ``int` `count = 0; ` `    ``while` `(curr) { ` `        ``curr = curr->next; ` `        ``count++; ` `    ``} ` ` `  `    ``// Iterating till next is not NULL ` `    ``while` `(next) { ` `        ``// Curr position after every reverse group ` `        ``curr = prev->next; ` `        ``// Next will always next to curr ` `        ``next = curr->next; ` `        ``// toLoop will set to count - 1 in case of remaining ` `        ``// element ` `        ``int` `toLoop = count > k ? k : count - 1; ` `        ``for` `(``int` `i = 1; i < toLoop; i++) { ` `            ``// 4 steps as discussed above ` `            ``curr->next = next->next; ` `            ``next->next = prev->next; ` `            ``prev->next = next; ` `            ``next = curr->next; ` `        ``} ` `        ``// Setting prev to curr ` `        ``prev = curr; ` `        ``// Update count ` `        ``count -= k; ` `    ``} ` `    ``// dummy -> next will be our new head for output linked ` `    ``// list ` `    ``return` `dummy->next; ` `} ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to push a node */` `void` `push(Node** head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(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 linked list */` `void` `printList(Node* node) ` `{ ` `    ``while` `(node != NULL) { ` `        ``printf``(``"%d "``, node->data); ` `        ``node = node->next; ` `    ``} ` `} ` ` `  `/* Driver code*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``Node* head = NULL; ` ` `  `    ``/* Created Linked list ` `    ``is 1->2->3->4->5->6->7->8->9 */` `    ``push(&head, 9); ` `    ``push(&head, 8); ` `    ``push(&head, 7); ` `    ``push(&head, 6); ` `    ``push(&head, 5); ` `    ``push(&head, 4); ` `    ``push(&head, 3); ` `    ``push(&head, 2); ` `    ``push(&head, 1); ` ` `  `    ``printf``(``"Given linked list \n"``); ` `    ``printList(head); ` `    ``head = reverse(head, 3); ` ` `  `    ``printf``(``"\nReversed Linked list \n"``); ` `    ``printList(head); ` ` `  `    ``return` `(0); ` `} ` ` `  `// This code is contributed by Sania Kumari Gupta ` `// (kriSania804)`

## Java

 `import` `java.util.*; ` ` `  `// Linked List Node ` `class` `Node { ` `    ``int` `data; ` `    ``Node next; ` `    ``Node(``int` `a) ` `    ``{ ` `        ``data = a; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `class` `GFG { ` `    ``// utility function to insert node in the list ` `    ``static` `Node push(Node head, ``int` `val) ` `    ``{ ` `        ``Node newNode = ``new` `Node(val); ` `        ``if` `(head == ``null``) { ` `            ``head = newNode; ` `            ``return` `head; ` `        ``} ` ` `  `        ``Node temp = head; ` `        ``while` `(temp.next != ``null``) ` `            ``temp = temp.next; ` ` `  `        ``temp.next = newNode; ` `        ``return` `head; ` `    ``} ` ` `  `    ``// utility function to reverse k nodes in the list ` `    ``static` `Node reverse(Node head, ``int` `k) ` `    ``{ ` `        ``// If head is NULL or K is 1 then return head ` `        ``if` `(head == ``null` `|| head.next == ``null``) ` `            ``return` `head; ` ` `  `        ``// creating dummy node ` `        ``Node dummy = ``new` `Node(-``1``); ` `        ``dummy.next = head; ` ` `  `        ``// Initializing three points prev, curr, next ` `        ``Node prev = dummy; ` `        ``Node curr = dummy; ` `        ``Node next = dummy; ` ` `  `        ``// Calculating the length of linked list ` `        ``int` `count = ``0``; ` `        ``while` `(curr != ``null``) { ` `            ``count++; ` `            ``curr = curr.next; ` `        ``} ` ` `  `        ``// Iterating till next is not NULL ` `        ``while` `(next != ``null``) { ` `            ``curr = prev.next; ``// Curr position after every ` `                              ``// reverse group ` `            ``next = curr.next; ``// Next will always next to ` `                              ``// curr ` `            ``int` `toLoop ` `                ``= count > k ` `                      ``? k ` `                      ``: count - ``1``; ``// toLoop will set to ` `                                   ``// count - 1 in case of ` `                                   ``// remaining element ` ` `  `            ``for` `(``int` `i = ``1``; i < toLoop; i++) { ` `                ``// 4 steps as discussed above ` `                ``curr.next = next.next; ` `                ``next.next = prev.next; ` `                ``prev.next = next; ` `                ``next = curr.next; ` `            ``} ` `            ``prev = curr; ``// Setting prev to curr ` `            ``count -= k; ``// Update count ` `        ``} ` `        ``return` `dummy.next; ``// dummy -> next will be our new ` `                           ``// head for output linked ` `        ``// list ` `    ``} ` `    ``// utility function to print the list ` `    ``static` `void` `print(Node head) ` `    ``{ ` `        ``while` `(head.next != ``null``) { ` `            ``System.out.print(head.data + ``" "``); ` `            ``head = head.next; ` `        ``} ` `        ``System.out.println(head.data); ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``Node head = ``null``; ` `        ``int` `k = ``3``; ` `        ``head = push(head, ``1``); ` `        ``head = push(head, ``2``); ` `        ``head = push(head, ``3``); ` `        ``head = push(head, ``4``); ` `        ``head = push(head, ``5``); ` `        ``head = push(head, ``6``); ` `        ``head = push(head, ``7``); ` `        ``head = push(head, ``8``); ` `        ``head = push(head, ``9``); ` ` `  `        ``System.out.println(``"Given Linked List"``); ` `        ``print(head); ` `        ``System.out.println(``"Reversed list"``); ` `        ``Node newHead = reverse(head, k); ` `        ``print(newHead); ` `    ``} ` `}`

## Python3

 `# Python program to reverse a linked list in groups of given size ` `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` ` `  `# Reverses the linked list in groups ` `# of size k and returns the pointer ` `# to the new head node. ` ` `  ` `  `def` `reverse(head, k): ` `  ``# If head is NULL or K is 1 then return head ` `    ``if` `not` `head ``or` `k ``=``=` `1``: ` `        ``return` `head ` `    ``dummy ``=` `Node(``-``1``)  ``# creating dummy node ` `    ``dummy.``next` `=` `head ` `    ``# Initializing three points prev, curr, next ` `    ``prev ``=` `dummy ` `    ``curr ``=` `dummy ` `    ``next` `=` `dummy ` `    ``count ``=` `0` `    ``toLoop ``=` `0` `    ``i ``=` `0` ` `  `    ``# Calculating the length of linked list ` `    ``while` `curr: ` `        ``curr ``=` `curr.``next` `        ``count ``+``=` `1` ` `  `    ``# Iterating till next is not none ` `    ``while` `next``: ` `        ``curr ``=` `prev.``next`  `# Curr position after every reversed group ` `        ``next` `=` `curr.``next`  `# Next will always next to curr ` `        ``# toLoop will set to count - 1 in case of remaining element ` `        ``toLoop ``=` `count > k ``and` `k ``or` `count ``-` `1` `        ``for` `i ``in` `range``(``1``, toLoop): ` `                ``# 4 steps as discussed above ` `            ``curr.``next` `=` `next``.``next` `            ``next``.``next` `=` `prev.``next` `            ``prev.``next` `=` `next` `            ``next` `=` `curr.``next` `        ``# Setting prev to curr ` `        ``prev ``=` `curr ` `        ``# Update count ` `        ``count ``-``=` `k ` ` `  `     ``# dummy -> next will be our new head for output linked list ` `    ``return` `dummy.``next` ` `  `# Function to print linked list ` ` `  ` `  `def` `printList(node): ` `    ``while` `node ``is` `not` `None``: ` `        ``print``(node.data, end``=``" "``) ` `        ``node ``=` `node.``next` ` `  ` `  `# Created Linked list is 1->2->3->4->5->6->7->8->9 ` `head ``=` `Node(``1``) ` `head.``next` `=` `Node(``2``) ` `head.``next``.``next` `=` `Node(``3``) ` `head.``next``.``next``.``next` `=` `Node(``4``) ` `head.``next``.``next``.``next``.``next` `=` `Node(``5``) ` `head.``next``.``next``.``next``.``next``.``next` `=` `Node(``6``) ` `head.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``7``) ` `head.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``8``) ` `head.``next``.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``9``) ` ` `  `print``(``"Given linked list"``) ` `printList(head) ` `head ``=` `reverse(head, ``3``) ` ` `  `print``(``"\nReversed Linked list"``) ` `printList(head) ` ` `  `# This code is contributed by Tapesh(tapeshdua420) `

## C#

 `// C# program to reverse a linked list ` `// in groups of given size ` ` `  `using` `System; ` ` `  `/* Link list node */` `class` `Node { ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `    ``public` `Node(``int` `a) ` `    ``{ ` `        ``data = a; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `class` `GFG { ` `    ``/* UTILITY FUNCTIONS */` `    ``/* Function to push a node */` `    ``static` `Node push(Node head, ``int` `val) ` `    ``{ ` ` `  `        ``Node newNode = ``new` `Node(val); ` `        ``if` `(head == ``null``) { ` `            ``head = newNode; ` `            ``return` `head; ` `        ``} ` ` `  `        ``Node temp = head; ` `        ``while` `(temp.next != ``null``) ` `            ``temp = temp.next; ` ` `  `        ``temp.next = newNode; ` `        ``return` `head; ` `    ``} ` ` `  `    ``// utility function to reverse k nodes in the list ` `    ``static` `Node reverse(Node head, ``int` `k) ` `    ``{ ` `        ``// If head is NULL or K is 1 then return head ` `        ``if` `(head == ``null` `|| head.next == ``null``) ` `            ``return` `head; ` ` `  `        ``// creating dummy node ` `        ``Node dummy = ``new` `Node(-1); ` `        ``dummy.next = head; ` ` `  `        ``// Initializing three points prev, curr, next ` `        ``Node prev = dummy; ` `        ``Node curr = dummy; ` `        ``Node next = dummy; ` ` `  `        ``// Calculating the length of linked list ` `        ``int` `count = 0; ` `        ``while` `(curr != ``null``) { ` `            ``count++; ` `            ``curr = curr.next; ` `        ``} ` ` `  `        ``// Iterating till next is not NULL ` `        ``while` `(next != ``null``) { ` `            ``curr = prev.next; ``// Curr position after every ` `                              ``// reverse group ` `            ``next = curr.next; ``// Next will always next to ` `                              ``// curr ` ` `  `            ``int` `toLoop ` `                ``= count > k ` `                      ``? k ` `                      ``: count - 1; ``// toLoop will set to ` `                                   ``// count - 1 in case of ` `                                   ``// remaining element ` ` `  `            ``for` `(``int` `i = 1; i < toLoop; i++) { ` `                ``// 4 steps as discussed above ` `                ``curr.next = next.next; ` `                ``next.next = prev.next; ` `                ``prev.next = next; ` `                ``next = curr.next; ` `            ``} ` ` `  `            ``prev = curr; ``// Setting prev to curr ` `            ``count -= k; ``// Update count ` `        ``} ` ` `  `        ``return` `dummy.next; ``// dummy -> next will be our new ` `                           ``// head for output linked list ` `    ``} ` ` `  `    ``// utility function to print the list ` `    ``static` `void` `print(Node head) ` `    ``{ ` `        ``while` `(head.next != ``null``) { ` `            ``Console.Write(head.data + ``" "``); ` `            ``head = head.next; ` `        ``} ` `        ``Console.WriteLine(head.data); ` `    ``} ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``Node head = ``null``; ` `        ``int` `K = 3; ` `        ``head = push(head, 1); ` `        ``head = push(head, 2); ` `        ``head = push(head, 3); ` `        ``head = push(head, 4); ` `        ``head = push(head, 5); ` `        ``head = push(head, 6); ` `        ``head = push(head, 7); ` `        ``head = push(head, 8); ` `        ``head = push(head, 9); ` `        ``Console.WriteLine(``"Given linked list"``); ` `        ``print(head); ` `        ``Console.WriteLine(``"Reversed Linked list"``); ` `        ``Node newHead = reverse(head, K); ` `        ``print(newHead); ` `    ``} ` `} ` ` `  `// This code is contributed by Tapesh (tapeshdua420)`

## Javascript

 `// JavaScript program to reverse a linked list ` `// in groups of given size `   `// Linked List Node ` `class Node{ ` `    ``constructor(a){ ` `        ``this``.data = a; ` `        ``this``.next = ``null``; ` `    ``} ` `} ` ` `  `function` `push(head, val){ ` `    ``newNode = ``new` `Node(val); ` `    ``if``(head==``null``){ ` `        ``head = newNode; ` `        ``return` `head; ` `    ``} ` `     `  `    ``temp = head; ` `    ``while``(temp.next!=``null``){ ` `        ``temp = temp.next; ` `    ``} ` `    ``temp.next = newNode; ` `    ``return` `head; ` `} ` ` `  `// utility function to reverse k nodes in the list ` `function` `reverse(head, k){ ` `    ``// If head is NULL or K is 1 then return head ` `    ``if``(head==``null` `|| head.next==``null``){ ` `        ``return` `head; ` `    ``} ` `     `  `    ``// creating dummy node ` `    ``var` `dummy = ``new` `Node(-1); ` `    ``dummy.next = head; ` `     `  `    ``// Initializing three points prev, curr, next ` `    ``var` `prev = dummy; ` `    ``var` `curr = dummy; ` `    ``var` `next = dummy; ` `     `  `    ``// Calculating the length of linked list ` `    ``let count = 0; ` `    ``while``(curr!=``null``){ ` `        ``count++; ` `        ``curr = curr.next; ` `    ``} ` `     `  `    ``// Iterating till next is not NULL ` `    ``while``(next!=``null``){ ` `        ``curr = prev.next; ``// Curr position after every ` `                          ``// reverse group ` `        ``next = curr.next; ``// Next will always next to ` `                          ``// curr ` `         `  `        ``// toLoop will set to count - 1 in case of ` `        ``// remaining element ` `        ``let toLoop = count > k ? k : count - 1; ` `         `  `        ``for``(let i=1;i"``); ` `} ` ` `  ` `  `var` `head = ``null``; ` `let k = 3; ` `head = push(head, 1); ` `head = push(head, 2); ` `head = push(head, 3); ` `head = push(head, 4); ` `head = push(head, 5); ` `head = push(head, 6); ` `head = push(head, 7); ` `head = push(head, 8); ` `head = push(head, 9); ` ` `  `console.log(``"Given linked list
"``); ` `print(head); ` `console.log(``"Reversed linked list
"``); ` `var` `newHead = reverse(head, k); ` `print(newHead); ` ` `  `// This code is contributed by lokesh. `

Output

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

#### Complexity Analysis

Time Complexity: O(N) : While loop takes O(N/K) time and inner for loop takes O(K) time. So N/K * K = N. Therefore TC O(N)

Space Complexity: O(1) : No extra space is used.

Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up
Related Articles