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
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.
Java
class LinkedList
{
static Node head;
class Node
{
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
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++;
}
if (node != null )
{
node.next = current;
}
count = 0 ;
while (count < k - 1 &&
current != null )
{
current = current.next;
count++;
}
if (current != null )
{
current.next =
kAltReverse(current.next, k);
}
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();
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);
}
}
|
Output:
Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
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
class LinkedList
{
static Node head;
class Node
{
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}
Node kAltReverse(Node head, int k)
{
return _kAltReverse(head, k, true );
}
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 ;
while (current != null && count <= k)
{
next = current.next;
if (b == true )
{
current.next = prev;
}
prev = current;
current = next;
count++;
}
if (b == true )
{
node.next =
_kAltReverse(current, k, !b);
return 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();
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);
}
}
|
Output:
Given linked list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Modified Linked list
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!
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...