Python Program For Rearranging A Given Linked List In-Place
Given a singly linked list L0 -> L1 -> … -> Ln-1 -> Ln. Rearrange the nodes in the list so that the new formed list is : L0 -> Ln -> L1 -> Ln-1 -> L2 -> Ln-2 …
You are required to do this in place without altering the nodes’ values.
Examples:
Input: 1 -> 2 -> 3 -> 4
Output: 1 -> 4 -> 2 -> 3
Input: 1 -> 2 -> 3 -> 4 -> 5
Output: 1 -> 5 -> 2 -> 4 -> 3
Simple Solution:
1) Initialize current node as head.
2) While next of current node is not null, do following
a) Find the last node, remove it from the end and insert it as next
of the current node.
b) Move current to next to next of current
The time complexity of the above simple solution is O(n2) where n is the number of nodes in the linked list.
Better Solution:
1) Copy contents of the given linked list to a vector.
2) Rearrange the given vector by swapping nodes from both ends.
3) Copy the modified vector back to the linked list.
Implementation of this approach: https://ide.geeksforgeeks.org/1eGSEy
Thanks to Arushi Dhamija for suggesting this approach.
Efficient Solution:
1) Find the middle point using tortoise and hare method.
2) Split the linked list into two halves using found middle point in step 1.
3) Reverse the second half.
4) Do alternate merge of first and second halves.
The Time Complexity of this solution is O(n).
Below is the implementation of this method.
Python3
class Node:
def __init__( self , d):
self .data = d
self . next = None
def printlist(node):
if (node = = None ):
return
while (node ! = None ):
print (node.data, " -> " ,
end = "")
node = node. next
def reverselist(node):
prev = None
curr = node
next = None
while (curr ! = None ):
next = curr. next
curr. next = prev
prev = curr
curr = next
node = prev
return node
def rearrange(node):
slow = node
fast = slow. next
while (fast ! = None and
fast. next ! = None ):
slow = slow. next
fast = fast. next . next
node1 = node
node2 = slow. next
slow. next = None
node2 = reverselist(node2)
node = Node( 0 )
curr = node
while (node1 ! = None or
node2 ! = None ):
if (node1 ! = None ):
curr. next = node1
curr = curr. next
node1 = node1. next
if (node2 ! = None ):
curr. next = node2
curr = curr. next
node2 = node2. next
node = node. next
head = None
head = Node( 1 )
head. next = Node( 2 )
head. next . next = Node( 3 )
head. next . next . next = Node( 4 )
head. next . next . next . next = Node( 5 )
printlist(head)
rearrange(head)
print ()
printlist(head)
|
Output:
1 -> 2 -> 3 -> 4 -> 5
1 -> 5 -> 2 -> 4 -> 3
Time Complexity: O(n)
Auxiliary Space: O(1)
Thanks to Gaurav Ahirwar for suggesting the above approach.
Another approach:
1. Take two pointers prev and curr, which hold the addresses of head and head-> next.
2. Compare their data and swap.
After that, a new linked list is formed.
Below is the implementation:
Python3
class Node:
def __init__( self , x):
self .data = x
self . next = None
def rearrange(head):
if (head = = None ):
return head
prev, curr = head, head. next
while (curr):
if (prev.data > curr.data):
prev.data, curr.data = curr.data, prev.data
if (curr. next and curr. next .data > curr.data):
curr. next .data, curr.data = curr.data, curr. next .data
prev = curr. next
if ( not curr. next ):
break
curr = curr. next . next
return head
def push(head, k):
tem = Node(k)
tem.data = k
tem. next = head
head = tem
return head
def display(head):
curr = head
while (curr ! = None ):
print (curr.data, end = " " )
curr = curr. next
if __name__ = = '__main__' :
head = None
head = push(head, 7 )
head = push(head, 3 )
head = push(head, 8 )
head = push(head, 6 )
head = push(head, 9 )
head = rearrange(head)
display(head)
|
Output:
6 9 3 8 7
Time Complexity : O(n)
Auxiliary Space : O(1)
Thanks to Aditya for suggesting this approach.
Another Approach: (Using recursion)
- Hold a pointer to the head node and go till the last node using recursion
- Once the last node is reached, start swapping the last node to the next of head node
- Move the head pointer to the next node
- Repeat this until the head and the last node meet or come adjacent to each other
- Once the Stop condition met, we need to discard the left nodes to fix the loop created in the list while swapping nodes.
Python3
class Node:
def __init__( self , key):
self .data = key
self . next = None
left = None
def printlist(head):
while (head ! = None ):
print (head.data, end = " " )
if (head. next ! = None ):
print ( "->" , end = "")
head = head. next
print ()
def rearrange(head):
global left
if (head ! = None ):
left = head
reorderListUtil(left)
def reorderListUtil(right):
global left
if (right = = None ):
return
reorderListUtil(right. next )
if (left = = None ):
return
if (left ! = right and
left. next ! = right):
temp = left. next
left. next = right
right. next = temp
left = temp
else :
if (left. next = = right):
left. next . next = None
left = None
else :
left. next = None
left = None
head = Node( 1 )
head. next = Node( 2 )
head. next . next = Node( 3 )
head. next . next . next = Node( 4 )
head. next . next . next . next = Node( 5 )
printlist(head)
rearrange(head)
printlist(head)
|
Output:
1 ->2 ->3 ->4 ->5
1 ->5 ->2 ->4 ->3
Time Complexity: O(n), where n represents the length of the given linked list.
Auxiliary Space: O(n), for recursive stack where n represents the length of the given linked list.
Please refer complete article on Rearrange a given linked list in-place. for more details!
Last Updated :
28 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...