# Reverse alternate K nodes in a Singly Linked List

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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

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

/* Link list node */
struct Node
{
int data;
struct Node* next;
};

/* Reverses alternate k nodes and
returns the pointer to the new head node */
struct Node *kAltReverse(struct Node *head, int k)
{
struct Node* current = head;
struct Node* next;
struct 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*/

/* 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(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 */

/* move the head to point to the 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++;
}
}

/* Drier 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--)

printf("\n Given linked list \n");

printf("\n Modified Linked list \n");

getchar();
return(0);
}
```

## Java

```// Java program to reverse alternate k nodes in a linked list

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);
}

public static void main(String[] args) {

// Creating the linkedlist
for (int i = 20; i > 0; i--) {
list.push(i);
}
System.out.println("Given Linked List :");
System.out.println("");
System.out.println("Modified Linked List :");

}
}

// This code has been contributed by Mayank Jaiswal

```

Output:
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)

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

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.3 Average Difficulty : 3.3/5.0
Based on 121 vote(s)

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.