Python Program For Partitioning A Linked List Around A Given Value And Keeping The Original Order
Last Updated :
22 Jun, 2022
Given a linked list and a value x, partition it such that all nodes less than x come first, then all nodes with a value equal to x, and finally nodes with a value greater than or equal to x. The original relative order of the nodes in each of the three partitions should be preserved. The partition must work in place.
Examples:
Input: 1->4->3->2->5->2->3,
x = 3
Output: 1->2->2->3->3->4->5
Input: 1->4->2->10
x = 3
Output: 1->2->4->10
Input: 10->4->20->10->3
x = 3
Output: 3->10->4->20->10
To solve this problem we can use partition method of Quick Sort but this would not preserve the original relative order of the nodes in each of the two partitions.
Below is the algorithm to solve this problem :
- Initialize first and last nodes of below three linked lists as NULL.
- Linked list of values smaller than x.
- Linked list of values equal to x.
- Linked list of values greater than x.
- Now iterate through the original linked list. If a node’s value is less than x then append it at the end of the smaller list. If the value is equal to x, then at the end of the equal list. And if a value is greater, then at the end of the greater list.
- Now concatenate three lists.
Below is the implementation of the above idea.
Python3
class Node:
def __init__( self ):
self .data = 0
self . next = None
def newNode(data):
new_node = Node()
new_node.data = data
new_node. next = None
return new_node
def partition( head, x) :
smallerHead = None
smallerLast = None
greaterLast = None
greaterHead = None
equalHead = None
equalLast = None
while (head ! = None ) :
if (head.data = = x):
if (equalHead = = None ):
equalHead = equalLast = head
else :
equalLast. next = head
equalLast = equalLast. next
elif (head.data < x):
if (smallerHead = = None ):
smallerLast = smallerHead = head
else :
smallerLast. next = head
smallerLast = head
else :
if (greaterHead = = None ) :
greaterLast = greaterHead = head
else :
greaterLast. next = head
greaterLast = head
head = head. next
if (greaterLast ! = None ) :
greaterLast. next = None
if (smallerHead = = None ) :
if (equalHead = = None ) :
return greaterHead
equalLast. next = greaterHead
return equalHead
if (equalHead = = None ) :
smallerLast. next = greaterHead
return smallerHead
smallerLast. next = equalHead
equalLast. next = greaterHead
return smallerHead
def printList(head) :
temp = head
while (temp ! = None ):
print (temp.data ,end = " " )
temp = temp. next
head = newNode( 10 )
head. next = newNode( 4 )
head. next . next = newNode( 5 )
head. next . next . next = newNode( 30 )
head. next . next . next . next = newNode( 2 )
head. next . next . next . next . next = newNode( 50 )
x = 3
head = partition(head, x)
printList(head)
|
Output:
2 10 4 5 30 50
Time Complexity: O(n) where n is the size of the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.
Please refer complete article on Partitioning a linked list around a given value and keeping the original order for more details!
Share your thoughts in the comments
Please Login to comment...