Given a linked list and a value x, partition it such that all nodes less than x come first, then all nodes with value equal to x and finally nodes with 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 smaller list. If the value is equal to x, then at the end of equal list. And if value is greater, then at the end of greater list.
- Now concatenate three lists.
Below is the implementation of above idea.
C++
// C++ program to partition a linked list around a // given value. #include<bits/stdc++.h> using namespace std; /* Link list Node */struct Node { int data; struct Node* next; }; // A utility function to create a new node Node *newNode(int data) { struct Node* new_node = new Node; new_node->data = data; new_node->next = NULL; return new_node; } // Function to make two separate lists and return // head after concatinating struct Node *partition(struct Node *head, int x) { /* Let us initialize first and last nodes of three linked lists 1) Linked list of values smaller than x. 2) Linked list of values equal to x. 3) Linked list of values greater than x.*/ struct Node *smallerHead = NULL, *smallerLast = NULL; struct Node *greaterLast = NULL, *greaterHead = NULL; struct Node *equalHead = NULL, *equalLast = NULL; // Now iterate original list and connect nodes // of appropriate linked lists. while (head != NULL) { // If current node is equal to x, append it // to the list of x values if (head->data == x) { if (equalHead == NULL) equalHead = equalLast = head; else { equalLast->next = head; equalLast = equalLast->next; } } // If current node is less than X, append // it to the list of smaller values else if (head->data < x) { if (smallerHead == NULL) smallerLast = smallerHead = head; else { smallerLast->next = head; smallerLast = head; } } else // Append to the list of greater values { if (greaterHead == NULL) greaterLast = greaterHead = head; else { greaterLast->next = head; greaterLast = head; } } head = head->next; } // Fix end of greater linked list to NULL if this // list has some nodes if (greaterLast != NULL) greaterLast->next = NULL; // Connect three lists // If smaller list is empty if (smallerHead == NULL) { if (equalHead == NULL) return greaterHead; equalLast->next = greaterHead; return equalHead; } // If smaller list is not empty // and equal list is empty if (equalHead == NULL) { smallerLast->next = greaterHead; return smallerHead; } // If both smaller and equal list // are non-empty smallerLast->next = equalHead; equalLast->next = greaterHead; return smallerHead; } /* Function to print linked list */void printList(struct Node *head) { struct Node *temp = head; while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } } // Driver program to run the case int main() { /* Start with the empty list */ struct Node* 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); int x = 3; head = partition(head, x); printList(head); return 0; } |
chevron_right
filter_none
Java
// Java program to partition a // linked list around a given value. class GfG { /* Link list Node */static class Node { int data; Node next; } // A utility function to create a new node static Node newNode(int data) { Node new_node = new Node(); new_node.data = data; new_node.next = null; return new_node; } // Function to make two separate lists and return // head after concatinating static Node partition(Node head, int x) { /* Let us initialize first and last nodes of three linked lists 1) Linked list of values smaller than x. 2) Linked list of values equal to x. 3) Linked list of values greater than x.*/ Node smallerHead = null, smallerLast = null; Node greaterLast = null, greaterHead = null; Node equalHead = null, equalLast =null; // Now iterate original list and connect nodes // of appropriate linked lists. while (head != null) { // If current node is equal to x, append it // to the list of x values if (head.data == x) { if (equalHead == null) equalHead = equalLast = head; else { equalLast.next = head; equalLast = equalLast.next; } } // If current node is less than X, append // it to the list of smaller values else if (head.data < x) { if (smallerHead == null) smallerLast = smallerHead = head; else { smallerLast.next = head; smallerLast = head; } } else // Append to the list of greater values { if (greaterHead == null) greaterLast = greaterHead = head; else { greaterLast.next = head; greaterLast = head; } } head = head.next; } // Fix end of greater linked list to NULL if this // list has some nodes if (greaterLast != null) greaterLast.next = null; // Connect three lists // If smaller list is empty if (smallerHead == null) { if (equalHead == null) return greaterHead; equalLast.next = greaterHead; return equalHead; } // If smaller list is not empty // and equal list is empty if (equalHead == null) { smallerLast.next = greaterHead; return smallerHead; } // If both smaller and equal list // are non-empty smallerLast.next = equalHead; equalLast.next = greaterHead; return smallerHead; } /* Function to print linked list */static void printList(Node head) { Node temp = head; while (temp != null) { System.out.print(temp.data + " "); temp = temp.next; } } // Driver code public static void main(String[] args) { /* Start with the empty list */ Node 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); int x = 3; head = partition(head, x); printList(head); } } // This code is contributed by Prerna saini. |
chevron_right
filter_none
Python3
# Python3 program to partition a # linked list around a given value. # Link list Node class Node: def __init__(self): self.data = 0 self.next = None # A utility function to create a new node def newNode( data): new_node = Node() new_node.data = data new_node.next = None return new_node # Function to make two separate lists and return # head after concatinating def partition( head, x) : # Let us initialize first and last nodes of # three linked lists # 1) Linked list of values smaller than x. # 2) Linked list of values equal to x. # 3) Linked list of values greater than x. smallerHead = None smallerLast = None greaterLast = None greaterHead = None equalHead = None equalLast = None # Now iterate original list and connect nodes # of appropriate linked lists. while (head != None) : # If current node is equal to x, append it # to the list of x values if (head.data == x): if (equalHead == None): equalHead = equalLast = head else: equalLast.next = head equalLast = equalLast.next # If current node is less than X, append # it to the list of smaller values elif (head.data < x): if (smallerHead == None): smallerLast = smallerHead = head else: smallerLast.next = head smallerLast = head else : # Append to the list of greater values if (greaterHead == None) : greaterLast = greaterHead = head else: greaterLast.next = head greaterLast = head head = head.next # Fix end of greater linked list to None if this # list has some nodes if (greaterLast != None) : greaterLast.next = None # Connect three lists # If smaller list is empty if (smallerHead == None) : if (equalHead == None) : return greaterHead equalLast.next = greaterHead return equalHead # If smaller list is not empty # and equal list is empty if (equalHead == None) : smallerLast.next = greaterHead return smallerHead # If both smaller and equal list # are non-empty smallerLast.next = equalHead equalLast.next = greaterHead return smallerHead # Function to print linked list def printList(head) : temp = head while (temp != None): print(temp.data ,end= " ") temp = temp.next # Driver code # Start with the empty list 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 = 3head = partition(head, x) printList(head) # This code is contributed by Arnab Kundu. |
chevron_right
filter_none
C#
// C# program to partition a // linked list around a given value. using System; public class GfG { /* Link list Node */public class Node { public int data; public Node next; } // A utility function to create a new node static Node newNode(int data) { Node new_node = new Node(); new_node.data = data; new_node.next = null; return new_node; } // Function to make two separate lists and return // head after concatinating static Node partition(Node head, int x) { /* Let us initialize first and last nodes of three linked lists 1) Linked list of values smaller than x. 2) Linked list of values equal to x. 3) Linked list of values greater than x.*/ Node smallerHead = null, smallerLast = null; Node greaterLast = null, greaterHead = null; Node equalHead = null, equalLast =null; // Now iterate original list and connect nodes // of appropriate linked lists. while (head != null) { // If current node is equal to x, append it // to the list of x values if (head.data == x) { if (equalHead == null) equalHead = equalLast = head; else { equalLast.next = head; equalLast = equalLast.next; } } // If current node is less than X, append // it to the list of smaller values else if (head.data < x) { if (smallerHead == null) smallerLast = smallerHead = head; else { smallerLast.next = head; smallerLast = head; } } else // Append to the list of greater values { if (greaterHead == null) greaterLast = greaterHead = head; else { greaterLast.next = head; greaterLast = head; } } head = head.next; } // Fix end of greater linked list to NULL if this // list has some nodes if (greaterLast != null) greaterLast.next = null; // Connect three lists // If smaller list is empty if (smallerHead == null) { if (equalHead == null) return greaterHead; equalLast.next = greaterHead; return equalHead; } // If smaller list is not empty // and equal list is empty if (equalHead == null) { smallerLast.next = greaterHead; return smallerHead; } // If both smaller and equal list // are non-empty smallerLast.next = equalHead; equalLast.next = greaterHead; return smallerHead; } /* Function to print linked list */static void printList(Node head) { Node temp = head; while (temp != null) { Console.Write(temp.data + " "); temp = temp.next; } } // Driver code public static void Main() { /* Start with the empty list */ Node 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); int x = 3; head = partition(head, x); printList(head); } } /* This code contributed by PrinciRaj1992 */ |
chevron_right
filter_none
Output:
2 10 4 5 30 50
This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
Recommended Posts:
- Partitioning a linked list around a given value and If we don't care about making the elements of the list "stable"
- Print Doubly Linked list in Reverse Order
- Traverse Linked List from middle to left-right order using recursion
- Sort the linked list in the order of elements appearing in the array
- Print the last k nodes of the linked list in reverse order | Iterative Approaches
- Print the last k nodes of the linked list in reverse order | Recursive approach
- Merge two sorted linked lists such that merged list is in reverse order
- Merge K sorted Doubly Linked List in Sorted Order
- Create new linked list from two given linked list with greater element at each node
- XOR Linked List - A Memory Efficient Doubly Linked List | Set 1
- XOR Linked List – A Memory Efficient Doubly Linked List | Set 2
- Difference between Singly linked list and Doubly linked list
- Merge a linked list into another linked list at alternate positions
- Convert singly linked list into circular linked list
- Check if a linked list is Circular Linked List
- Convert Singly Linked List to XOR Linked List
- Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
- Create a linked list from two linked lists by choosing max element at each position
- Construct a Doubly linked linked list from 2D Matrix
- Length of longest palindrome list in a linked list using O(1) extra space
