Open in App
Not now

Java Program For Reversing Alternate K Nodes In A Singly Linked List

• Last Updated : 30 Aug, 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
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.```

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 is contributed by Mayank Jaiswal`

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

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 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 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;` `    ``}` `  `  `    ``// 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);` `        ``}` `        ``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 is contributed by Mayank Jaiswal`

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)

Auxiliary Space: O(n) For call stack because it is using recursion

Please refer complete article on Reverse alternate K nodes in a Singly Linked List for more details!

My Personal Notes arrow_drop_up
Related Articles