Given a Linked List of length n and block length k rotate in a circular manner towards right/left each block by a number d. If d is positive rotate towards right else rotate towards left.
Examples:
Input: 1->2->3->4->5->6->7->8->9->NULL, k = 3 d = 1 Output: 3->1->2->6->4->5->9->7->8->NULL Explanation: Here blocks of size 3 are rotated towards right(as d is positive) by 1. Input: 1->2->3->4->5->6->7->8->9->10-> 11->12->13->14->15->NULL, k = 4 d = -1 Output: 2->3->4->1->6->7->8->5->10->11 ->12->9->14->15->13->NULL Explanation: Here, at the end of linked list, remaining nodes are less than k, i.e. only three nodes are left while k is 4. Rotate those 3 nodes also by d.
Prerequisite: Rotate a linked list
The idea is if the absolute value of d is greater than the value of k, then rotate the link list by d % k times. If d is 0, no need to rotate the linked list at all.
Java
// Java program to rotate a linked list // block wise import java.util.*;
class GFG{
// Link list node static class Node
{ int data;
Node next;
}; static Node tail;
// Recursive function to rotate one block static Node rotateHelper(Node blockHead,
Node blockTail,
int d, int k)
{ if (d == 0 )
return blockHead;
// Rotate Clockwise
if (d > 0 )
{
Node temp = blockHead;
for ( int i = 1 ; temp.next.next!= null &&
i < k - 1 ; i++)
temp = temp.next;
blockTail.next = blockHead;
tail = temp;
return rotateHelper(blockTail, temp,
d - 1 , k);
}
// Rotate anti-Clockwise
if (d < 0 )
{
blockTail.next = blockHead;
tail = blockHead;
return rotateHelper(blockHead.next,
blockHead, d + 1 , k);
}
return blockHead;
} // Function to rotate the linked list // block-wise static Node rotateByBlocks(Node head,
int k, int d)
{ // If length is 0 or 1 return head
if (head == null || head.next == null )
return head;
// if degree of rotation is 0,
// return head
if (d == 0 )
return head;
Node temp = head;
tail = null ;
// Traverse upto last element of
// this block
int i;
for (i = 1 ; temp.next != null &&
i < k; i++)
temp = temp.next;
// Storing the first node of next block
Node nextBlock = temp.next;
// If nodes of this block are less than k.
// Rotate this block also
if (i < k)
head = rotateHelper(head, temp,
d % k, i);
else
head = rotateHelper(head, temp,
d % k, k);
// Append the new head of next block to
// the tail of this block
tail.next = rotateByBlocks(nextBlock,
k, d % k);
// return head of updated Linked List
return head;
} // UTILITY FUNCTIONS // Function to push a node static Node push(Node head_ref,
int new_data)
{ Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
return head_ref;
} // Function to print linked list static void printList(Node node)
{ while (node != null )
{
System.out.print(node.data + " " );
node = node.next;
}
} // Driver code public static void main(String[] args)
{ /* Start with the empty list */
Node head = null ;
// Create a list 1.2.3.4.5.
// 6.7.8.9.null
for ( int i = 9 ; i > 0 ; i -= 1 )
head = push(head, i);
System.out.print( "Given linked list " );
printList(head);
// k is block size and d is number of
// rotations in every block.
int k = 3 , d = 2 ;
head = rotateByBlocks(head, k, d);
System.out.print(
"Rotated by blocks Linked list " );
printList(head);
} } // This code is contributed by aashish1995 |
Output:
Given linked list 1 2 3 4 5 6 7 8 9 Rotated by blocks Linked list 2 3 1 5 6 4 8 9 7
Please refer complete article on Rotate Linked List block wise for more details!