Rotate a Linked List in Python

If given the head of a singly linked list and a number K, develop a program that rotates the linked list clockwise by K places starting from the last node.

Example

Input-1

Head: 10 -> 20 -> 30 -> 40 -> 50
K: 2

Output 1:

40 -> 50 -> 10 -> 20 -> 30

Explanation

We rotated the given linked list exactly twice in this case. During the initial rotation, 5 will be the head node, and 4 will be the tail node, whereas on rotating the list a second time, 4 will be the head node, and 3 will be the tail node.

Input-2

Head: 10 -> 20 -> 30
K: 4

Output 2:

30 -> 10 -> 20

Explanation

Here, we have performed 4 rotations of the linked list.

Algorithm 1 - Rotating by Changing the Next Pointer for the k^th Node

Intuition:

For this strategy, we must keep three-pointers to the (k + 1)^th node, the kth node, and the node that is previous to the kth node. The goal is to traverse the given linked list till the kth node and set the node present at (k + 1)^th pointer to NULL, and the next of the last node of the linked list should store the current head node, after which the (k + 1)^th node will become the new head of our linked list.

Algorithm

Check if the given head is null or if k == 0. If yes, then we will return the linked If yes, then we will return the linked list.
Initialize the variable c to 1 and initialize another variable containing the total number of nodes present in the linked list (for head).
Traverse the given linked list until you reach the kth node.
Check if the current node is NULL or kth is more than or equal to the total number of nodes present in the linked list. In this instance, don't update the list; therefore, return.
Now go through all the nodes until you reach the end and update the next of the last node to store the previous head.
Lastly, shift the head to the (k + 1)^th node, followed by setting the (k + 1)^th node to None.

Code Implementation

Code

# Python program to rotate the given linked list

# Creating a Node class
class Node:

  # Defining a function to Construct and initialize the node instance
  def __init__(self, val):
    self.val = val
    self.next = None

# Creating the linked list class which will contain the method to store the head and the method to rotate the linked list
class LinkedList:

  # Defining the function to initialize the head object
  def __init__(self):
    self.head = None

  # Defining the function to print the linked list
  def printLL(self):
    t = self.head
    while(t):
      print(t.val, end = " ")
      t = t.next
      
  
    # Defining a function to insert the node to the beginning of the list
  def insert(self, new_val):
    # Creating a node with the given value
    new_node = Node(new_val)

    # Making the next of the newly created node as the head node
    new_node.next = self.head
    
    # moving the head to point towards the newly added Node
    self.head = new_node

  # Defining the function to rotate the linked list
  def rotateLL(self, k):
   
    # If the number of rotations is zero, return head
    if k == 0:
      return self.head
    
    curr = self.head
    
    # After execution of this loop, the curr node will either point towards the kth or None
    # curr will point towards node 9. In example, we will take
    c = 1
    while c < k and curr is not None:
      curr = curr.next
      c += 1
  
    # If the curr node is None, then the number of elements is less than k and hence returns head
    if curr is None:
      return

    # Now, the curr node points towards the kth node. We will store this node in a variable
    kth = curr
  
    # The curr node will point towards the last node after the execution of this loop
    while curr.next is not None:
      curr = curr.next

    # We will change the last node's next pointer to the previous head
    curr.next = self.head
    
    # Making the (k + 1)th node as the head of the linked list
    self.head = kth.next

    # changing the next pointer of kth node to None
    kth.next = None

 
# Constructing a linked list object using the linked list class
llist = LinkedList()

# Using the insert method add nodes to the linked list
llist.insert(9)
llist.insert(3)
llist.insert(5)
llist.insert(1)
llist.insert(2)
llist.insert(7)
llist.insert(5)
llist.insert(5)
llist.insert(4)
llist.insert(1)

  
print("The original linked list is: ")
llist.printLL()
llist.rotateLL(2)

print("\n\nThe rotated Linked list is:")
llist.printLL()

Output:

The original linked list is:
1 4 5 5 7 2 1 5 3 9

The rotated Linked list is:
5 5 7 2 1 5 3 9 1 4

Time Complexity: The time complexity of this approach is O(n). This is because we have traversed the given linked list one time to rotate the linked list, where n is the number of nodes in the linked list.

Space Complexity: The space complexity of this approach is O(1). It is constant because no extra space is acquired in the program.

Algorithm 2 - By Rotating the K Number of Nodes

Intuition:

The approach here is analogous to the last one. In this, the single linked list is converted to something like a circular linked list and afterward moved k-1 steps ahead from the head node, but before shifting, make the (k - 1)^th node next to null and the following node as head.

Algorithm

Determine if the head node is null or if k == 0. If so, the return head.
Point the next of the last node toward the head, transforming the single linked list into a circular linked list.
Navigate this linked list to the (k - 1)^th place, which will be the last entry.
Iterate through the last node of the circular linked list and break the loop by referring the next of the last node to None.

Code Implementation

Code

# Python program to rotate a singly linked list

# Creating a Node class
class Node:
    # Creating the constructor to store the node value and memory of the next node
    def __init__(self, val):
        self.val = val
        self.next = None

  
# Defining the function to rotate the linked list by k number of times
def rotateLL(head, k):

    # If the number of rotations is zero, then return the linked list as it is
    if (k == 0):
        return head
   
    curr = head
   
    # Traversing the linked list till the end
    while (curr.next != None):
        curr = curr.next

    curr.next = head
    curr = head
      
    # Traversing the given linked list to the (k - 1)th position.
    # This will be the last node of the rotated linked list.
    for i in range(k - 1):
        curr = curr.next
   
    # Updating the head and pointing the last element towards None
    head = curr.next
    curr.next = None
    return head
   

# Function to insert a node 
def insert(head, new_val):

  # Creating a node with the given value
  new_node = Node(new_val)

  # Making the next of the newly created node as the head node
  new_node.next = head
  
  # Moving the head to point toward the newly added Node
  head = new_node

  return head
      
# Defining the function to print the linked list
def printLL(node):
  t = node
  while(t):
    print(t.val, end = " ")
    t = t.next

  
# Calling the functions to create the linked list and rotate it
      
head = None

# Creating the linked list
for i in range(8, 0, -1):
    head = insert(head, i)
print("The original List is: ")
printLL(head)

# Rotating the linked list
head = rotateLL(head, 5)

print("\nThe rotated linked list is:")
printLL(head)

Output:

The original List is:
1 2 3 4 5 6 7 8
The rotated linked list is:
6 7 8 1 2 3 4 5

Space Complexity: The space complexity of this approach is O(1). It is constant because no extra space is acquired in the program.

Conclusion

We will give a single linked list's head and K. We had to develop a program that rotated the given Linked List by the Kth node clockwise.
For example, if a linked list's head is specified as Head: 1 -> 2 -> 3 -> 4 -> 5 and the integer K = 3, the result should be 5 -> 1 -> 2 -> 3 -> 4 after three rotations.
We learned two methods for rotating any given linked list: the first is changing the next for each kth node, and the second is rotating the K nodes.
Since we only traversed our linked list once, both the methods have a time complexity of O(n) and an O(1) space complexity.

Next TopicHow to Re-size Choropleth maps - Python

← prev next →