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

06 Jul, 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.
Linked list of values smaller than x.Linked list of values equal to x.Linked list of values greater than x.
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. 
C++
C
Java
Python3
C#
Javascript
// 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 nodeNode* 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 concatenatingstruct 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 caseint 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;} // This code is contributed by Aditya Kumar (adityakumar129)
// C++ program to partition a linked list around a// given value.#include <stdio.h>#include <stdlib.h> /* Link list Node */typedef struct Node {    int data;    struct Node* next;} Node; // A utility function to create a new nodeNode* newNode(int data){    Node* new_node = (Node*)malloc(sizeof(Node));    new_node->data = data;    new_node->next = NULL;    return new_node;} // Function to make two separate lists and return// head after concatenatingNode* 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 */void printList(Node* head){    Node* temp = head;    while (temp != NULL) {        printf("%d  ", temp->data);        temp = temp->next;    }} // Driver program to run the caseint 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);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// 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 concatenating    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 Aditya Kumar (adityakumar129)
# Python3 program to partition a# linked list around a given value. # Link list Nodeclass Node:    def __init__(self):        self.data = 0        self.next = None # A utility function to create a new nodedef 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 concatenatingdef 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        else if (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 listdef printList(head) :     temp = head    while (temp != None):             print(temp.data ,end= " ")        temp = temp.next     # Driver code # Start with the empty listhead = 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.
// 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 nodestatic 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 concatenatingstatic 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 codepublic 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 */
<script> // Javascript program to partition a// linked list around a given value.      /* Link list Node */     class Node {            constructor() {                this.data = 0;                this.next = null;            }        }          // A utility function to create a new node    function newNode(data) {var 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 concatenating    function 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.         */          var smallerHead = null, smallerLast = null;var greaterLast = null, greaterHead = null;var 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 */    function printList(head) {var temp = head;        while (temp != null) {            document.write(temp.data + " ");            temp = temp.next;        }    }     // Driver code             /* Start with the empty list */        var 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);         var x = 3;        head = partition(head, x);        printList(head); // This code contributed by aashish1995 </script>
2  10  4  5  30  50  
Time complexity: O(n) where n is the size of the linked listAuxiliary Space: O(1)
This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 
prerna saini
princiraj1992
andrew1234
aashish1995
gabaa406
Kirti_Mangal
surinderdawra388
adityakumar129
polymatir3j
hardikkoriintern
Linked List
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Merge two sorted linked lists
Find the middle of a given linked list
What is Data Structure: Types, Classifications and Applications
Linked List vs Array
Merge Sort for Linked Lists
Implementing a Linked List in Java using Class
Add two numbers represented by linked lists | Set 1
Queue - Linked List Implementation
Detect and Remove Loop in a Linked List