# Partitioning a linked list around a given value and keeping the original order

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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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.
1. Linked list of values smaller than x.
2. Linked list of values equal to x.
3. 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 ` `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; ` `} `

## 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. `

## 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 */`

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.