# Reverse alternate K nodes in a Singly Linked List

• Difficulty Level : Medium
• Last Updated : 03 Jul, 2022

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
of head to (k+1)th node
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 \n"``;  ` `    ``printList(head);  ` `    ``head = kAltReverse(head, 3);  ` ` `  `    ``cout<<``"\n Modified Linked list \n"``;  ` `    ``printList(head);  ` `    ``return``(0);  ` `}  ` ` `  ` `  `// This code is contributed by rathbhupendra `

## Java

 `// Java program to reverse alternate k nodes in a linked list ` ` `  `class` `LinkedList { ` ` `  `    ``static` `Node head; ` ` `  `    ``class` `Node { ` ` `  `        ``int` `data; ` `        ``Node next; ` ` `  `        ``Node(``int` `d) { ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* Reverses alternate k nodes and ` `     ``returns the pointer to the new head node */` `    ``Node kAltReverse(Node node, ``int` `k) { ` `        ``Node current = node; ` `        ``Node next = ``null``, 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` `(node != ``null``) { ` `            ``node.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; ` `    ``} ` ` `  `    ``void` `printList(Node node) { ` `        ``while` `(node != ``null``) { ` `            ``System.out.print(node.data + ``" "``); ` `            ``node = node.next; ` `        ``} ` `    ``} ` ` `  `    ``void` `push(``int` `newdata) { ` `        ``Node mynode = ``new` `Node(newdata); ` `        ``mynode.next = head; ` `        ``head = mynode; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String[] args) { ` `        ``LinkedList list = ``new` `LinkedList(); ` ` `  `        ``// Creating the linkedlist ` `        ``for` `(``int` `i = ``20``; i > ``0``; i--) { ` `            ``list.push(i); ` `        ``} ` `        ``System.out.println(``"Given Linked List :"``); ` `        ``list.printList(head); ` `        ``head = list.kAltReverse(head, ``3``); ` `        ``System.out.println(``""``); ` `        ``System.out.println(``"Modified Linked List :"``); ` `        ``list.printList(head); ` ` `  `    ``} ` `} ` ` `  `// This code has been contributed by Mayank Jaiswal `

## Python3

 `# Python3 program to reverse alternate ` `# k nodes in a linked list ` `import` `math ` ` `  `# Link list node  ` `class` `Node:  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.``next` `=` `None` ` `  `# Reverses alternate k nodes and  ` `#returns the pointer to the new head node  ` `def` `kAltReverse(head, k) :  ` `    ``current ``=` `head  ` `    ``next` `=` `None` `    ``prev ``=` `None` `    ``count ``=` `0` ` `  `    ``#1) reverse first k nodes of the linked list  ` `    ``while` `(current !``=` `None` `and` `count < k) :  ` `        ``next` `=` `current.``next` `        ``current.``next` `=` `prev  ` `        ``prev ``=` `current  ` `        ``current ``=` `next` `        ``count ``=` `count ``+` `1``; ` `     `  `    ``# 2) Now head pos to the kth node.  ` `    ``# So change next of head to (k+1)th node ` `    ``if``(head !``=` `None``):  ` `        ``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` `and` `current !``=` `None` `):  ` `        ``current ``=` `current.``next` `        ``count ``=` `count ``+` `1` `     `  `    ``# 4) Recursively call for the list  ` `    ``# starting from current.next. And make ` `    ``# rest of the list as next of first node  ` `    ``if``(current !``=` `None``):  ` `        ``current.``next` `=` `kAltReverse(current.``next``, k)  ` ` `  `    ``# 5) prev is new head of the input list  ` `    ``return` `prev  ` ` `  `# UTILITY FUNCTIONS  ` `# Function to push a node  ` `def` `push(head_ref, new_data):  ` `     `  `    ``# allocate node  ` `    ``new_node ``=` `Node(new_data) ` ` `  `    ``# 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 po to the new node  ` `    ``head_ref ``=` `new_node ` `     `  `    ``return` `head_ref ` ` `  `# Function to print linked list  ` `def` `printList(node):  ` `    ``count ``=` `0` `    ``while``(node !``=` `None``):  ` `        ``print``(node.data, end ``=` `" "``)  ` `        ``node ``=` `node.``next` `        ``count ``=` `count ``+` `1` `     `  `# Driver code ` `if` `__name__``=``=``'__main__'``: ` `     `  `    ``# Start with the empty list  ` `    ``head ``=` `None` ` `  `    ``# create a list 1.2.3.4.5...... .20  ` `    ``for` `i ``in` `range``(``20``, ``0``, ``-``1``): ` `        ``head ``=` `push(head, i)  ` `         `  `    ``print``(``"Given linked list "``)  ` `    ``printList(head)  ` `    ``head ``=` `kAltReverse(head, ``3``)  ` ` `  `    ``print``(``"\nModified Linked list"``)  ` `    ``printList(head)  ` `     `  `# This code is contributed by Srathore `

## C#

 `// C# program to reverse alternate ` `// k nodes in a linked list  ` `using` `System; ` `class` `LinkedList  ` `{  ` ` `  `    ``static` `Node head;  ` ` `  `    ``public` `class` `Node  ` `    ``{  ` ` `  `        ``public` `int` `data;  ` `        ``public` `Node next;  ` ` `  `        ``public` `Node(``int` `d) ` `        ``{  ` `            ``data = d;  ` `            ``next = ``null``;  ` `        ``}  ` `    ``}  ` ` `  `    ``/* Reverses alternate k nodes and  ` `    ``returns the pointer to the new head node */` `    ``Node kAltReverse(Node node, ``int` `k)  ` `    ``{  ` `        ``Node current = node;  ` `        ``Node next = ``null``, 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` `(node != ``null``)  ` `        ``{  ` `            ``node.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;  ` `    ``}  ` ` `  `    ``void` `printList(Node node)  ` `    ``{  ` `        ``while` `(node != ``null``)  ` `        ``{  ` `            ``Console.Write(node.data + ``" "``);  ` `            ``node = node.next;  ` `        ``}  ` `    ``}  ` ` `  `    ``void` `push(``int` `newdata) ` `    ``{  ` `        ``Node mynode = ``new` `Node(newdata);  ` `        ``mynode.next = head;  ` `        ``head = mynode;  ` `    ``}  ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{  ` `        ``LinkedList list = ``new` `LinkedList();  ` ` `  `        ``// Creating the linkedlist  ` `        ``for` `(``int` `i = 20; i > 0; i--)  ` `        ``{  ` `            ``list.push(i);  ` `        ``}  ` `        ``Console.WriteLine(``"Given Linked List :"``);  ` `        ``list.printList(head);  ` `        ``head = list.kAltReverse(head, 3);  ` `        ``Console.WriteLine(``""``);  ` `        ``Console.WriteLine(``"Modified Linked List :"``);  ` `        ``list.printList(head);  ` `    ``}  ` `}  ` ` `  `// This code has been contributed by Arnab Kundu `

## Javascript

 ` `

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)

Space 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++

 `#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 node is the kth node.  ` `        ``So attach rest of the list after 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 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 \n"``;  ` `    ``printList(head);  ` `    ``head = kAltReverse(head, 3);  ` ` `  `    ``cout << ``"\nModified Linked list \n"``;  ` `    ``printList(head);  ` `    ``return``(0);  ` `}  ` ` `  `// This code is contributed by rathbhupendra `

## C

 `#include ` `#include ` ` `  `/* Link list node */` `struct` `node ` `{ ` `    ``int` `data; ` `    ``struct` `node* next; ` `}; ` ` `  `/* Helper function for kAltReverse() */` `struct` `node * _kAltReverse(``struct` `node *node, ``int` `k, ``bool` `b); ` ` `  `/* Alternatively reverses the given linked list in groups of  ` `   ``given size k. */` `struct` `node *kAltReverse(``struct` `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  */`  `struct` `node * _kAltReverse(``struct` `node *node, ``int` `k, ``bool` `b) ` `{ ` `   ``if``(node == NULL) ` `       ``return` `NULL; ` ` `  `   ``int` `count = 1; ` `   ``struct` `node *prev = NULL; ` `   ``struct` `node  *current = node; ` `   ``struct` `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 node is the kth node.  ` `       ``So attach rest of the list after 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 rest of the list after prev */`     `   ``else` `   ``{ ` `        ``prev->next = _kAltReverse(current, k, !b); ` `        ``return` `node;        ` `   ``} ` `} ` `  `  ` `  `/* 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 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(``struct` `node *node) ` `{ ` `    ``int` `count = 0; ` `    ``while``(node != NULL) ` `    ``{ ` `        ``printf``(``"%d  "``, node->data); ` `        ``node = node->next; ` `        ``count++; ` `    ``} ` `} ` `  `  `/* Driver program to test above function*/` `int` `main(``void``) ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `node* head = NULL; ` `    ``int` `i; ` `  `  `    ``// create a list 1->2->3->4->5...... ->20 ` `    ``for``(i = 20; i > 0; i--) ` `      ``push(&head, i); ` `  `  `    ``printf``(``"\n Given linked list \n"``); ` `    ``printList(head); ` `    ``head = kAltReverse(head, 3); ` `  `  `    ``printf``(``"\n Modified Linked list \n"``); ` `    ``printList(head); ` `  `  `    ``getchar``(); ` `    ``return``(0); ` `} `

## Java

 `// Java program to reverse alternate k nodes in a linked list ` ` `  `class` `LinkedList { ` ` `  `    ``static` `Node head; ` ` `  `    ``class` `Node { ` ` `  `        ``int` `data; ` `        ``Node next; ` ` `  `        ``Node(``int` `d) { ` `            ``data = d; ` `            ``next = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``/* 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, ``boolean` `b) { ` `        ``if` `(node == ``null``) { ` `            ``return` `null``; ` `        ``} ` ` `  `        ``int` `count = ``1``; ` `        ``Node prev = ``null``; ` `        ``Node current = node; ` `        ``Node next = ``null``; ` ` `  `        ``/* 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 node is the kth node.  ` `         ``So attach rest of the list after 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 rest of the list after prev */` `else` `{ ` `            ``prev.next = _kAltReverse(current, k, !b); ` `            ``return` `node; ` `        ``} ` `    ``} ` ` `  `    ``void` `printList(Node node) { ` `        ``while` `(node != ``null``) { ` `            ``System.out.print(node.data + ``" "``); ` `            ``node = node.next; ` `        ``} ` `    ``} ` ` `  `    ``void` `push(``int` `newdata) { ` `        ``Node mynode = ``new` `Node(newdata); ` `        ``mynode.next = head; ` `        ``head = mynode; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String[] args) { ` `        ``LinkedList list = ``new` `LinkedList(); ` ` `  `        ``// Creating the linkedlist ` `        ``for` `(``int` `i = ``20``; i > ``0``; i--) { ` `            ``list.push(i); ` `        ``} ` `        ``System.out.println(``"Given Linked List :"``); ` `        ``list.printList(head); ` `        ``head = list.kAltReverse(head, ``3``); ` `        ``System.out.println(``""``); ` `        ``System.out.println(``"Modified Linked List :"``); ` `        ``list.printList(head); ` ` `  `    ``} ` `} ` ` `  `// This code has been contributed by Mayank Jaiswal `

## Python3

 `# Python code for above algorithm ` ` `  `# Link list node  ` `class` `node:  ` `     `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.``next` `=` `next` `         `  `# function to insert a node at the ` `# beginning of the linked list ` `def` `push(head_ref, new_data): ` ` `  `    ``# allocate node  ` `    ``new_node ``=` `node(``0``) ` ` `  `    ``# put in the data  ` `    ``new_node.data ``=` `new_data ` ` `  `    ``# link the old list to the new node  ` `    ``new_node.``next` `=` `(head_ref) ` ` `  `    ``# move the head to point to the new node  ` `    ``(head_ref) ``=` `new_node ` `     `  `    ``return` `head_ref ` `     `  `""" Alternatively reverses the given linked list  ` `in groups of given size k. """` `def` `kAltReverse(head, 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 """` `def` `_kAltReverse(Node, k, b) : ` ` `  `    ``if``(Node ``=``=` `None``) : ` `        ``return` `None` `     `  `    ``count ``=` `1` `    ``prev ``=` `None` `    ``current ``=` `Node  ` `    ``next` `=` `None` `     `  `    ``""" 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 !``=` `None` `and` `count <``=` `k) : ` `     `  `        ``next` `=` `current.``next` `     `  `        ``""" Reverse the nodes only if b is True"""` `        ``if``(b ``=``=` `True``) : ` `            ``current.``next` `=` `prev  ` `                 `  `        ``prev ``=` `current  ` `        ``current ``=` `next` `        ``count ``=` `count ``+` `1` `     `  `         `  `    ``""" 3) If b is True, then node is the kth node.  ` `        ``So attach rest of the list after node.  ` `        ``4) After attaching, return the new head """` `    ``if``(b ``=``=` `True``) : ` `     `  `        ``Node.``next` `=` `_kAltReverse(current, k, ``not` `b)  ` `        ``return` `prev          ` `     `  `    ``else` `: ` `        ``""" If b is not True, then attach  ` `        ``rest of the list after prev.  ` `        ``So attach rest of the list after prev """` `        ``prev.``next` `=` `_kAltReverse(current, k, ``not` `b)  ` `        ``return` `Node      ` `     `  `""" Function to print linked list """` `def` `printList(node) : ` ` `  `    ``count ``=` `0` `    ``while``(node !``=` `None``) : ` `     `  `        ``print``( node.data, end ``=` `" "``)  ` `        ``node ``=` `node.``next` `        ``count ``=` `count ``+` `1` ` `  `# Driver Code ` ` `  `""" Start with the empty list """` `head ``=` `None` `i ``=` `20` ` `  `# create a list 1->2->3->4->5...... ->20  ` `while``(i > ``0` `):  ` `    ``head ``=` `push(head, i)  ` `    ``i ``=` `i ``-` `1` ` `  `print``( ``"Given linked list "``)  ` `printList(head)  ` `head ``=` `kAltReverse(head, ``3``)  ` ` `  `print``( ``"\nModified Linked list "``)  ` `printList(head)  ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# Program for converting  ` `// singly linked list into  ` `// circular linked list.  ` `using` `System; ` ` `  `public` `class` `LinkedList ` `{  ` ` `  `    ``static` `Node head;  ` ` `  `    ``public` `class` `Node  ` `    ``{  ` ` `  `        ``public` `int` `data;  ` `        ``public` `Node next;  ` ` `  `        ``public` `Node(``int` `d)  ` `        ``{  ` `            ``data = d;  ` `            ``next = ``null``;  ` `        ``}  ` `    ``}  ` ` `  `    ``/* Reverses alternate k nodes and  ` `    ``returns the pointer to the new head node */` `    ``Node kAltReverse(Node node, ``int` `k)  ` `    ``{  ` `        ``Node current = node;  ` `        ``Node next = ``null``, 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` `(node != ``null``) ` `        ``{  ` `            ``node.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;  ` `    ``}  ` ` `  `    ``void` `printList(Node node)  ` `    ``{  ` `        ``while` `(node != ``null``)  ` `        ``{  ` `            ``Console.Write(node.data + ``" "``);  ` `            ``node = node.next;  ` `        ``}  ` `    ``}  ` ` `  `    ``void` `push(``int` `newdata) ` `    ``{  ` `        ``Node mynode = ``new` `Node(newdata);  ` `        ``mynode.next = head;  ` `        ``head = mynode;  ` `    ``}  ` ` `  `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``LinkedList list = ``new` `LinkedList();  ` ` `  `        ``// Creating the linkedlist  ` `        ``for` `(``int` `i = 20; i > 0; i--) ` `        ``{  ` `            ``list.push(i);  ` `        ``}  ` `        ``Console.WriteLine(``"Given Linked List :"``);  ` `        ``list.printList(head);  ` `        ``head = list.kAltReverse(head, 3);  ` `        ``Console.WriteLine(``""``);  ` `        ``Console.WriteLine(``"Modified Linked List :"``);  ` `        ``list.printList(head);  ` `    ``}  ` `}  ` ` `  `// This code is contributed 29AjayKumar `

## Javascript

 ` `

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)

Space Complexity: O(n)

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
Recommended Articles
Page :