Clone the Linked List with Random and Next Pointer in Python

A linked list is created using a random pointer. Given an N-by-N linked list, where each node has two connections, one pointing to the node after it and the other to any node in the list. We have to duplicate this linked list in O(N) time.

Recall that the "next" pointer points to the next node in the linked list, but the "random" pointer might point to any node in the linked list at random.

Approach - 1

The new nodes are then mapped to their corresponding nodes in the existing linked list by first creating a singly linked list with just the 'next' pointer. You may now use any node in the freshly formed list to point to the arbitrary node using this mapping.

Here is the algorithmic approach to the above idea:

For each node (say N1), replicate it (say N2), then map it to its associated old node (say map), such that map[N1] equals N2.
Make a single linked list of duplicate nodes with only the 'next' pointer for each node.
Repeat these steps for the previous linked list iterations:
- Find the duplicate node that is mapped to the existing one. (For example, map[N1] is the duplicate if the current node is N1.)
- Make the current -> random node's duplicate's random pointer point to the duplicate of that node (such that map[N1] -> random points to map[N1 -> random]).
This method produces the required clone of the linked list.

Code

# Python program to clone the linked list

# Creating the node class, which will construct the node object
class Node:
    # The node class will initialize three variables
    # One variable will store the value of the node
    # Second variable, i.e., next, will link the current node to the next node
    # The third variable is the arbitrary pointer to point the duplicate node
    def __init__(self, value):
        self.value = value
        self.next = None
        self.random = None

# Defining the function which will take the head of the linked list and return the clone of the given linked list
def cloneList(head):
    # Creating a map that will store the mapping of the old node to the new node
    map = {}
    dummy = head
    head_ = Node(dummy.value)
    map[dummy] = head_

    # Loopping through the linked list to create the duplicates of the nodes of the linked list using only the next pointer
    while dummy.next:
        # Creating a singly linked list of duplicates
        head_.next = Node(dummy.next.value)
        dummy = dummy.next
        head_ = head_.next
        # Creating the mapping 
        map[dummy] = head_

    dummy = head

    # Loopping through the linked list to create a clone of the list using the random pointer
    while dummy:
        map[dummy].random = map[dummy.random]
        dummy = dummy.next

    # Printing the mapping created
    print("\n")
    for key, val in map.items():
      print(f"{key.value} : {val.value}", end = ", ")
    print("\n")

    # Returning the head of the cloned linked list
    return map[head]

# Defining a function to print the linked list
def printList(head):
    res = []
    while head:
        res.append(f"{head.value}({head.random.value})")
        head = head.next
    print(" -> ".join(res))

# Initializing the node object, creating the head of the linked list, and adding nodes to the head node. Using a random pointer to link the linked list
head = Node(2)
head.next = Node(6)
head.next.next = Node(9)
head.next.next.next = Node(13)
head.next.next.next.next = Node(15)
head.random = head.next.next
head.next.random = head
head.next.next.random = head.next.next.next.next
head.next.next.next.random = head.next.next
head.next.next.next.next.random = head.next

# Printing the actual list
print("The initial linked list is as follows:")
printList(head)

# Calling the function
clone = cloneList(head)

print("The clone of the linked list is:")
printList(clone)

Output:

The initial linked list is as follows:
2(9) -> 6(2) -> 9(15) -> 13(9) -> 15(6)

2 : 2, 6 : 6, 9 : 9, 13 : 13, 15 : 15

The clone of the linked list is:
2(9) -> 6(2) -> 9(15) -> 13(9) -> 15(6)

Time Complexity: The time complexity of this program is O(N), where N is the number of nodes in the linked list. We have not used any nested loop and hence traversed the linked list linearly; therefore, the time complexity is also linear.

Auxiliary Space: The space complexity of the program is also O(N). The space complexity is linear because we are creating a new linked list.

Approach - 2 (Optimizing the Space Complexity)

Below is the method to optimize the space complexity of the program:

We will create a duplicate node and store it in between the actual node and the node next to it.

This implies that for a node N, we will create a node having the same value as N and store it as N -> next. This node will serve as the duplicate node. The random pointer of the duplicate node will point to the N -> random -> next, as it is the duplicate of N -> random.

Below is the algorithmic approach to the above idea:

We will create a copy of node N1 and store it in between the nodes N1 and N2 in the initial linked list. Likewise, we will create a copy of the node N2 and store it in between the nodes N2 and N3 and so on. In simple words, we will create and duplicate the node of node N and insert it after the Nth node.
Now we will copy the random link this way:
- node -> next -> random = node -> random -> next
Then we will separate the original and clone of the linked list in a single linear loop.
- node -> next = node -> next -> next
- clone -> next = clone -> next -> next

Code

# Optimized approach to clone the linked list

# Creating the node class
# This will store three variables, value, next pointer, and the random pointer
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
        self.random = None

# Defining the function to create the clone of the given linked list
def cloneList(head):
    if head == None:
        return None
    # Creating duplicate nodes and inserting them in between the original node and the node next to it
    current = head
    while current != None:
        new_Node = Node(current.value)
        new_Node.next = current.next
        current.next = new_Node
        current = new_Node.next
    # Setting the random pointer of the duplicate nodes
    current = head
    while current != None:
        if current.random != None:
            current.next.random = current.random.next
        current = current.next.next
    # Separating the duplicate nodes and creating a separate linked list
    current = head
    clone_head = head.next
    clone_curr = clone_head
    while clone_curr.next != None:
        current.next = current.next.next
        clone_curr.next = clone_curr.next.next
        current = current.next
        clone_curr = clone_curr.next
    current.next = None
    clone_curr.next = None
    return clone_head

# Defining a function that will print the given linked list
def printList(head):
    print(head.value, "(", head.random.value, ")", end = "")
    head = head.next
    while head != None:
        print(f" -> {head.value} ({head.random.value})", end = "")
        head = head.next
    print()

# Initializing the node object, creating the head of the linked list, and adding nodes to the head node. Using a random pointer to link the linked list
head = Node(2)
head.next = Node(6)
head.next.next = Node(9)
head.next.next.next = Node(13)
head.next.next.next.next = Node(15)
head.random = head.next.next
head.next.random = head
head.next.next.random = head.next.next.next.next
head.next.next.next.random = head.next.next
head.next.next.next.next.random = head.next

# Printing the actual list
print("The initial linked list is as follows:")
printList(head)

# Calling the function
clone = cloneList(head)

print("The clone of the linked list is:")
printList(clone)

Output:

The initial linked list is as follows:
2 ( 9 ) -> 6 (2) -> 9 (15) -> 13 (9) -> 15 (6)
The clone of the linked list is:
2 ( 9 ) -> 6 (2) -> 9 (15) -> 13 (9) -> 15 (6)

Time Complexity: The time complexity of this program is also O(N). We are linearly traversing through the linked list, and hence the time complexity is also linear.

Auxiliary Space: Since we have not created any mapping in this approach and only stored the node objects in the original linked list therefore, the space complexity of this approach is constant. The space complexity is O(1).

Next TopicMaximum Product Subarray

← prev next →