Clockwise rotation of Linked List
Last Updated :
27 Feb, 2023
Given a singly linked list and an integer K, the task is to rotate the linked list clockwise to the right by K places.
Examples:
Input: 1 -> 2 -> 3 -> 4 -> 5 -> NULL, K = 2
Output: 4 -> 5 -> 1 -> 2 -> 3 -> NULL
Input: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL, K = 12
Output: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL
Approach: To rotate the linked list first check whether the given k is greater than the count of nodes in the linked list or not. Traverse the list and find the length of the linked list then compare it with k, if less then continue otherwise deduce it in the range of linked list size by taking modulo with the length of the list.
After that subtract the value of k from the length of the list. Now, the question has been changed to the left rotation of the linked list so follow that procedure:
- Change the next of the kth node to NULL.
- Change the next of the last node to the previous head node.
- Change the head to (k+1)th node.
In order to do that, the pointers to the kth node, (k+1)th node, and last node are required.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node* next;
};
void 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;
}
void printList(Node* node)
{
while (node != NULL) {
cout << node->data << " -> " ;
node = node->next;
}
cout << "NULL" ;
}
Node* rightRotate(Node* head, int k)
{
if (!head)
return head;
Node* tmp = head;
int len = 1;
while (tmp->next != NULL) {
tmp = tmp->next;
len++;
}
if (k > len)
k = k % len;
k = len - k;
if (k == 0 || k == len)
return head;
Node* current = head;
int cnt = 1;
while (cnt < k && current != NULL) {
current = current->next;
cnt++;
}
if (current == NULL)
return head;
Node* kthnode = current;
tmp->next = head;
head = kthnode->next;
kthnode->next = NULL;
return head;
}
int main()
{
Node* head = NULL;
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
int k = 2;
Node* updated_head = rightRotate(head, k);
printList(updated_head);
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node next;
}
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;
}
static void printList(Node node)
{
while (node != null )
{
System.out.print(node.data + " -> " );
node = node.next;
}
System.out.print( "null" );
}
static Node rightRotate(Node head, int k)
{
if (head == null )
return head;
Node tmp = head;
int len = 1 ;
while (tmp.next != null )
{
tmp = tmp.next;
len++;
}
if (k > len)
k = k % len;
k = len - k;
if (k == 0 || k == len)
return head;
Node current = head;
int cnt = 1 ;
while (cnt < k && current != null )
{
current = current.next;
cnt++;
}
if (current == null )
return head;
Node kthnode = current;
tmp.next = head;
head = kthnode.next;
kthnode.next = null ;
return head;
}
public static void main(String args[])
{
Node head = null ;
head = push(head, 5 );
head = push(head, 4 );
head = push(head, 3 );
head = push(head, 2 );
head = push(head, 1 );
int k = 2 ;
Node updated_head = rightRotate(head, k);
printList(updated_head);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
def push(head_ref, new_data):
new_node = Node(new_data)
new_node.data = new_data
new_node. next = (head_ref)
(head_ref) = new_node
return head_ref
def printList(node):
while (node ! = None ):
print (node.data, end = ' -> ' )
node = node. next
print ( "NULL" )
def rightRotate(head, k):
if ( not head):
return head
tmp = head
len = 1
while (tmp. next ! = None ):
tmp = tmp. next
len + = 1
if (k > len ):
k = k % len
k = len - k
if (k = = 0 or k = = len ):
return head
current = head
cnt = 1
while (cnt < k and current ! = None ):
current = current. next
cnt + = 1
if (current = = None ):
return head
kthnode = current
tmp. next = head
head = kthnode. next
kthnode. next = None
return head
if __name__ = = '__main__' :
head = None
head = push(head, 5 )
head = push(head, 4 )
head = push(head, 3 )
head = push(head, 2 )
head = push(head, 1 )
k = 2
updated_head = rightRotate(head, k)
printList(updated_head)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
}
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;
}
static void printList(Node node)
{
while (node != null )
{
Console.Write(node.data + " -> " );
node = node.next;
}
Console.Write( "null" );
}
static Node rightRotate(Node head, int k)
{
if (head == null )
return head;
Node tmp = head;
int len = 1;
while (tmp.next != null )
{
tmp = tmp.next;
len++;
}
if (k > len)
k = k % len;
k = len - k;
if (k == 0 || k == len)
return head;
Node current = head;
int cnt = 1;
while (cnt < k && current != null )
{
current = current.next;
cnt++;
}
if (current == null )
return head;
Node kthnode = current;
tmp.next = head;
head = kthnode.next;
kthnode.next = null ;
return head;
}
public static void Main(String []args)
{
Node head = null ;
head = push(head, 5);
head = push(head, 4);
head = push(head, 3);
head = push(head, 2);
head = push(head, 1);
int k = 2;
Node updated_head = rightRotate(head, k);
printList(updated_head);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .data = 0;
this .next = null ;
}
}
function push(head_ref , new_data) {
var new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
function printList(node) {
while (node != null ) {
document.write(node.data + " -> " );
node = node.next;
}
document.write( "null" );
}
function rightRotate(head , k) {
if (head == null )
return head;
var tmp = head;
var len = 1;
while (tmp.next != null ) {
tmp = tmp.next;
len++;
}
if (k > len)
k = k % len;
k = len - k;
if (k == 0 || k == len)
return head;
var current = head;
var cnt = 1;
while (cnt < k && current != null ) {
current = current.next;
cnt++;
}
if (current == null )
return head;
var kthnode = current;
tmp.next = head;
head = kthnode.next;
kthnode.next = null ;
return head;
}
var head = null ;
head = push(head, 5);
head = push(head, 4);
head = push(head, 3);
head = push(head, 2);
head = push(head, 1);
var k = 2;
var updated_head = rightRotate(head, k);
printList(updated_head);
</script>
|
Output:
4 -> 5 -> 1 -> 2 -> 3 -> NULL
Time Complexity: O(n) where n is the number of nodes in Linked List.
Auxiliary Space: O(1)
STL based approach :
This problem can also be solved using the deque data structure provided in the C++ STL
Approach :
Initialise a deque with the type Node* and push the linked list into it.Then keep popping from it’s back and adding that node to it’s front until the number of operations are not equal to k.
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int val;
Node* next;
Node( int d)
{
val = d;
next = NULL;
}
};
void build(Node*& head, int val)
{
if (head == NULL) {
head = new Node(val);
}
else {
Node* temp = head;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = new Node(val);
}
}
Node* rotate_clockwise(Node* head, int k)
{
if (head == NULL) {
return NULL;
}
deque<Node*> q;
Node* temp = head;
while (temp != NULL) {
q.push_back(temp);
temp = temp->next;
}
k %= q.size();
while (
k--)
{
q.back()->next = q.front();
q.push_front(q.back());
q.pop_back();
q.back()->next = NULL;
}
return q.front();
}
void print(Node* head)
{
while (head != NULL) {
cout << head->val << " -> " ;
head = head->next;
}
cout << "NULL" ;
cout << endl;
}
int main()
{
Node* head = NULL;
build(head, 1);
build(head, 2);
build(head, 3);
build(head, 4);
build(head, 5);
int k = 2;
Node* r = rotate_clockwise(head, k);
print(r);
return 0;
}
|
Python3
from collections import deque
class Node:
def __init__( self , data):
self .data = data
self . next = None
def build(head, val):
if (head = = None ):
head = Node(val)
else :
temp = head
while (temp. next ! = None ):
temp = temp. next
temp. next = Node(val)
return head
def printList(node):
while (node ! = None ):
print (node.data, end = "->" )
node = node. next
print ( "NULL" )
def rotate_clockwise(head, k):
if (head = = None ):
return None
q = deque([])
temp = head
while (temp ! = None ):
q.append(temp)
temp = temp. next
k % = len (q)
while (k ! = 0 ):
q[ - 1 ]. next = q[ 0 ]
q.appendleft(q[ - 1 ])
q.pop()
q[ - 1 ]. next = None
k = k - 1
return q[ 0 ]
head = None
head = build(head, 1 )
head = build(head, 2 )
head = build(head, 3 )
head = build(head, 4 )
head = build(head, 5 )
k = 2
r = rotate_clockwise(head, k)
printList(r)
|
C#
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
public class Node{
public int val;
public Node next;
public Node( int d){
val = d;
next = null ;
}
}
public class llist{
Node head;
public void build( int val){
if (head == null ){
head = new Node(val);
}
else {
Node temp = head;
while (temp.next != null ){
temp = temp.next;
}
temp.next = new Node(val);
}
}
public Node rotate_clockwise( int k){
if (head == null ) return null ;
LinkedList<Node> q = new LinkedList<Node>();
Node temp = head;
while (temp != null ){
q.AddLast(temp);
temp = temp.next;
}
k %= q.Count;
while (k > 0)
{
k--;
q.Last.Value.next = q.First.Value;
q.AddFirst(q.Last.Value);
q.RemoveLast();
q.Last.Value.next = null ;
}
return q.First.Value;
}
public void print(Node head){
while (head != null ){
Console.Write(head.val + " -> " );
head = head.next;
}
Console.Write( "NULL" );
Console.Write( "\n" );
}
public static void Main(String[] args){
llist list = new llist();
list.build(1);
list.build(2);
list.build(3);
list.build(4);
list.build(5);
int k = 2;
Node r = list.rotate_clockwise(k);
list.print(r);
}
}
|
Javascript
class Node{
constructor(d){
this .val = d;
this .next = null ;
}
}
function build(head, val){
if (head == null ){
head = new Node(val);
}
else {
let temp = head;
while (temp.next != null ){
temp = temp.next;
}
temp.next = new Node(val);
}
return head;
}
function rotate_clockwise(head, k){
if (head == null ) return null ;
let q = [];
let temp = head;
while (temp != null ){
q.push(temp);
temp = temp.next;
}
k %= q.length;
while (k--)
{
q[q.length-1].next = q[0];
q.unshift(q[q.length-1]);
q.pop();
q[q.length-1].next = null ;
}
return q[0];
}
function print(head){
while (head != null ){
console.log(head.val + " -> " );
head = head.next;
}
console.log( "NULL" );
}
let head = null ;
head = build(head, 1);
head = build(head, 2);
head = build(head, 3);
head = build(head, 4);
head = build(head, 5);
let k = 2;
let r = rotate_clockwise(head, k);
print(r);
|
Java
import java.util.*;
class Node {
public int val;
public Node next;
public Node( int d) {
val = d;
next = null ;
}
}
class GFG {
public static Node build(Node head, int data) {
Node new_node = new Node(data);
if (head == null ) {
head = new_node;
} else {
Node last = head;
while (last.next != null ) {
last = last.next;
}
last.next = new_node;
}
return head;
}
public static Node rotate_clockwise(Node head, int k) {
if (head == null ) {
return null ;
}
Deque < Node > q = new LinkedList < > ();
Node temp = head;
while (temp != null ) {
q.add(temp);
temp = temp.next;
}
k %= q.size();
while (k-- > 0 ) {
q.peekLast().next = q.peekFirst();
q.offerFirst(q.pollLast());
q.peekLast().next = null ;
}
return q.peekFirst();
}
public static void print(Node head) {
while (head != null ) {
System.out.print(head.val + " -> " );
head = head.next;
}
System.out.print( "NULL" );
System.out.println();
}
public static void main(String[] args) {
Node head = null ;
head = build(head, 1 );
head = build(head, 2 );
head = build(head, 3 );
head = build(head, 4 );
head = build(head, 5 );
int k = 2 ;
Node r = rotate_clockwise(head, k);
print(r);
}
}
|
Output
4 -> 5 -> 1 -> 2 -> 3 -> NULL
Time Complexity: O(N)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...