Python3 Program for Clockwise rotation of Linked List
Last Updated :
12 Oct, 2023
Write a Python3 program for a given 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:
Steps:
- 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:
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)
|
Output
4 -> 5 -> 1 -> 2 -> 3 -> NULL
Time Complexity: O(N), as we are using a loop to traverse N times. Where N is the number of nodes in the linked list.
Auxiliary Space: O(1), as we are not using any extra space.
Deque based approach :
This problem can also be solved using the deque data structure.
Approach:
Initialise a deque 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.
Below is the implementation of the above approach:
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)
|
Output
4->5->1->2->3->NULL
Time Complexity: O(N)
Auxiliary Space: O(N)
Please refer complete article on Clockwise rotation of Linked List for more details!
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...