# 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