# C++ Program For Reversing Alternate K Nodes In A Singly Linked List

• Last Updated : 17 Dec, 2021

Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm.

Example:

```Inputs:   1->2->3->4->5->6->7->8->9->NULL and k = 3
Output:   3->2->1->4->5->6->9->8->7->NULL. ```

Method 1 (Process 2k nodes and recursively call for rest of the list):
This method is basically an extension of the method discussed in this post.

```kAltReverse(struct node *head, int k)
1)  Reverse first k nodes.
2)  In the modified list head points to the kth node.  So change next
3)  Move the current pointer to skip next k nodes.
4)  Call the kAltReverse() recursively for rest of the n - 2k nodes.
5)  Return new head of the list.```

## C++

 `// C++ program to reverse alternate ` `// k nodes in a linked list ` `#include ` `using` `namespace` `std; ` ` `  `// Link list node  ` `class` `Node  ` `{  ` `    ``public``: ` `    ``int` `data;  ` `    ``Node* next;  ` `};  ` ` `  `/* Reverses alternate k nodes and  ` `   ``returns the pointer to the new  ` `   ``head node */` `Node *kAltReverse(Node *head, ``int` `k)  ` `{  ` `    ``Node* current = head;  ` `    ``Node* next;  ` `    ``Node* prev = NULL;  ` `    ``int` `count = 0;  ` ` `  `    ``/* 1) reverse first k nodes of the  ` `       ``linked list */` `    ``while` `(current != NULL && count < k)  ` `    ``{  ` `    ``next = current->next;  ` `    ``current->next = prev;  ` `    ``prev = current;  ` `    ``current = next;  ` `    ``count++;  ` `    ``}  ` `     `  `    ``/* 2) Now head points to the kth node.  ` `       ``So change next  of head to (k+1)th node*/` `    ``if``(head != NULL)  ` `    ``head->next = current;  ` ` `  `    ``/* 3) We do not want to reverse next k  ` `       ``nodes. So move the current  ` `       ``pointer to skip next k nodes */` `    ``count = 0;  ` `    ``while``(count < k-1 &&  ` `          ``current != NULL )  ` `    ``{  ` `    ``current = current->next;  ` `    ``count++;  ` `    ``}  ` ` `  `    ``/* 4) Recursively call for the list  ` `       ``starting from current->next. And make ` `       ``rest of the list as next of first node */` `    ``if``(current != NULL)  ` `    ``current->next = kAltReverse(current->next, k);  ` ` `  `    ``/* 5) 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 off 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)  ` `{  ` `    ``int` `count = 0;  ` `    ``while``(node != NULL)  ` `    ``{  ` `        ``cout<data<<``" "``;  ` `        ``node = node->next;  ` `        ``count++;  ` `    ``}  ` `}  ` ` `  `// Driver code ` `int` `main(``void``)  ` `{  ` `    ``// Start with the empty list  ` `    ``Node* head = NULL;  ` `    ``int` `i;  ` `     `  `    ``// Create a list ` `    ``// 1->2->3->4->5...... ->20  ` `    ``for``(i = 20; i > 0; i--)  ` `    ``push(&head, i);  ` ` `  `    ``cout << ``"Given linked list "``;  ` `    ``printList(head);  ` `    ``head = kAltReverse(head, 3);  ` ` `  `    ``cout << ``"Modified Linked list "``;  ` `    ``printList(head);  ` `    ``return``(0);  ` `}  ` `// This code is contributed by rathbhupendra `

Output:

```Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
3 2 1 4 5 6 9 8 7 10 11 12 15 14 13 16 17 18 20 19```

Time Complexity: O(n)

Method 2 (Process k nodes and recursively call for rest of the list):
The method 1 reverses the first k node and then moves the pointer to k nodes ahead. So method 1 uses two while loops and processes 2k nodes in one recursive call.

This method processes only k nodes in a recursive call. It uses a third bool parameter b which decides whether to reverse the k elements or simply move the pointer.

```_kAltReverse(struct node *head, int k, bool b)
1)  If b is true, then reverse first k nodes.
2)  If b is false, then move the pointer k nodes ahead.
3)  Call the kAltReverse() recursively for rest of the n - k nodes and link
rest of the modified list with end of first k nodes.
4)  Return new head of the list.```

## C++

 `// C++ program to implement  ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Link list node  ` `class` `node  ` `{  ` `    ``public``: ` `    ``int` `data;  ` `    ``node* next;  ` `};  ` ` `  `// Helper function for kAltReverse()  ` `node * _kAltReverse(node *node,  ` `                    ``int` `k, ``bool` `b);  ` ` `  `// Alternatively reverses the given  ` `// linked list in groups of given size k. ` `node *kAltReverse(node *head, ``int` `k)  ` `{  ` `    ``return` `_kAltReverse(head, k, ``true``);  ` `}  ` ` `  `/* Helper function for kAltReverse().   ` `   ``It reverses k nodes of the list only if  ` `   ``the third parameter b is passed as true,  ` `   ``otherwise moves the pointer k nodes ahead ` `   ``and recursively calls itself */` `node * _kAltReverse(node *Node, ``int` `k, ``bool` `b)  ` `{  ` `    ``if``(Node == NULL)  ` `        ``return` `NULL;  ` `     `  `    ``int` `count = 1;  ` `    ``node *prev = NULL;  ` `    ``node *current = Node;  ` `    ``node *next;  ` `     `  `    ``/* The loop serves two purposes  ` `        ``1) If b is true,  ` `           ``then it reverses the k nodes  ` `        ``2) If b is false,  ` `           ``then it moves the current pointer */` `    ``while``(current != NULL && count <= k)  ` `    ``{  ` `        ``next = current->next;  ` `     `  `        ``// Reverse the nodes only if b is true ` `        ``if``(b == ``true``)  ` `            ``current->next = prev;  ` `                 `  `        ``prev = current;  ` `        ``current = next;  ` `        ``count++;  ` `    ``}  ` `         `  `    ``/* 3) If b is true, then the node is the kth node.  ` `        ``So attach the rest of the list after the node.  ` `        ``4) After attaching, return the new head */` `    ``if``(b == ``true``)  ` `    ``{  ` `        ``Node->next = _kAltReverse(current, k, !b);  ` `        ``return` `prev;          ` `    ``}  ` `         `  `    ``/* If b is not true, then attach  ` `       ``rest of the list after prev. ` `       ``So attach the rest of the list  ` `       ``after prev */` `    ``else` `    ``{  ` `        ``prev->next =  ` `            ``_kAltReverse(current, k, !b);  ` `        ``return` `Node;      ` `    ``}  ` `}  ` ` `  `// 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 off 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)  ` `{  ` `    ``int` `count = 0;  ` `    ``while``(node != NULL)  ` `    ``{  ` `        ``cout << node->data << ``" "``;  ` `        ``node = node->next;  ` `        ``count++;  ` `    ``}  ` `}  ` ` `  `// Driver Code ` `int` `main(``void``)  ` `{  ` `    ``// Start with the empty list  ` `    ``node* head = NULL;  ` `    ``int` `i;  ` ` `  `    ``// Create a list  ` `    ``// 1->2->3->4->5...... ->20  ` `    ``for``(i = 20; i > 0; i--)  ` `    ``push(&head, i);  ` ` `  `    ``cout << ``"Given linked list "``;  ` `    ``printList(head);  ` `    ``head = kAltReverse(head, 3);  ` ` `  `    ``cout << ``"Modified Linked list "``;  ` `    ``printList(head);  ` `    ``return``(0);  ` `}  ` `// This code is contributed by rathbhupendra `

Output:

```Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20