Partitioning a linked list around a given value and If we don't care about making the elements of the list "stable"

Last Updated : 12 Jul, 2022

Given a linked list and a value x, partition a linked list around a value x, such that all nodes less than x come before all nodes greater than or equal to x. If x is contained within the list the values of x only need to be after the elements less than x (see below). The partition element x can appear anywhere in the "right partition"; it does not need to appear between the left and right partitions.

Examples:

Input :  3 -> 5 -> 10 -> 2 -> 8 -> 2 -> 1 
         x = 5
Output : 1-> 2-> 2-> 3-> 5-> 10-> 8

If we don't care about making the elements of the list "stable" then we can instead rearrange the elements by growing the list at the head and tail.
In this approach, we start a "new" list (using the existing nodes). Elements bigger than the pivot element are put at the tail and elements smaller are put at the head. Each time we insert an element, we update either the head or tail.

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 a new list(using the existing
// nodes) and return head of new list.
struct Node *partition(struct Node *head, int x)
{
    /* Let us initialize start and tail nodes of
    new list */
    struct Node *tail = head;

    // Now iterate original list and connect nodes
    Node *curr = head;
    while (curr != NULL)
    {
        struct Node *next = curr->next;
        if (curr->data < x)
        {
            /* Insert node at head. */
            curr->next = head;
            head = curr;
        }

        else // Append to the list of greater values
        {
            /* Insert node at tail. */
            tail->next = curr;
            tail = curr;
        }
        curr = next;
    }
    tail->next = NULL;

    // The head has changed, so we need
    // to return it to the user.
    return head;
}

/* 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(3);
    head->next = newNode(5);
    head->next->next = newNode(8);
    head->next->next->next = newNode(2);
    head->next->next->next->next = newNode(10);
    head->next->next->next->next->next = newNode(2);
    head->next->next->next->next->next->next = newNode(1);

    int x = 5;
    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 a new list 
// (using the existing nodes) and 
// return head of new list. 
static Node partition(Node head, int x) 
{ 
    /* Let us initialize start and tail nodes of 
    new list */
    Node tail = head; 

    // Now iterate original list and connect nodes 
    Node curr = head; 
    while (curr != null) 
    { 
        Node next = curr.next; 
        if (curr.data < x) 
        { 
            /* Insert node at head. */
            curr.next = head; 
            head = curr; 
        } 

        else // Append to the list of greater values 
        { 
            /* Insert node at tail. */
            tail.next = curr; 
            tail = curr; 
        } 
        curr = next; 
    } 
    tail.next = null; 

    // The head has changed, so we need 
    // to return it to the user. 
    return head; 
} 

/* 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(3); 
    head.next = newNode(5); 
    head.next.next = newNode(8); 
    head.next.next.next = newNode(2); 
    head.next.next.next.next = newNode(10); 
    head.next.next.next.next.next = newNode(2); 
    head.next.next.next.next.next.next = newNode(1); 

    int x = 5; 
    head = partition(head, x); 
    printList(head); 
}
} 

// This code is contributed by prerna saini

Python3

# Python3 program to partition a 
# linked list around a given value.
import math

# Link list Node 
class Node: 
    def __init__(self, data): 
        self.data = data 
        self.next = None

# A utility function to create a new node
def newNode(data):
    new_node = Node(data)
    new_node.data = data
    new_node.next = None
    return new_node

# Function to make a new list
# (using the existing nodes) 
# and return head of new list.
def partition(head, x):
    
    # Let us initialize start and
    # tail nodes of new list 
    tail = head

    # Now iterate original list 
    # and connect nodes
    curr = head
    while (curr != None):
        next = curr.next
        if (curr.data < x):
            
            # Insert node at head. 
            curr.next = head
            head = curr
        
        else:
            
            # Append to the list of greater values
            # Insert node at tail. 
            tail.next = curr
            tail = curr
        
        curr = next
    
    tail.next = None

    # The head has changed, so we need
    # to return it to the user.
    return head

# Function to print linked list 
def printList(head):
    temp = head
    while (temp != None):
        print(temp.data, end = " ")
        temp = temp.next
    
# Driver Code
if __name__=='__main__': 
    
    # Start with the empty list 
    head = newNode(3)
    head.next = newNode(5)
    head.next.next = newNode(8)
    head.next.next.next = newNode(2)
    head.next.next.next.next = newNode(10)
    head.next.next.next.next.next = newNode(2)
    head.next.next.next.next.next.next = newNode(1)

    x = 5
    head = partition(head, x)
    printList(head)
    
# This code is contributed by AbhiThakur

// C# program to partition a linked list 
// around a given value.
using System;

class GfG 
{ 

/* Link list Node */
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 a new list 
// (using the existing nodes) and 
// return head of new list. 
static Node partition(Node head, int x) 
{ 
    /* Let us initialize start and  
    tail nodes of new list */
    Node tail = head; 

    // Now iterate original list
    // and connect nodes 
    Node curr = head; 
    while (curr != null) 
    { 
        Node next = curr.next; 
        if (curr.data < x) 
        { 
            /* Insert node at head. */
            curr.next = head; 
            head = curr; 
        } 

        else // Append to the list of greater values 
        { 
            /* Insert node at tail. */
            tail.next = curr; 
            tail = curr; 
        } 
        curr = next; 
    } 
    tail.next = null; 

    // The head has changed, so we need 
    // to return it to the user. 
    return head; 
} 

/* 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(String[] args) 
{ 
    /* Start with the empty list */
    Node head = newNode(3); 
    head.next = newNode(5); 
    head.next.next = newNode(8); 
    head.next.next.next = newNode(2); 
    head.next.next.next.next = newNode(10); 
    head.next.next.next.next.next = newNode(2); 
    head.next.next.next.next.next.next = newNode(1); 

    int x = 5; 
    head = partition(head, x); 
    printList(head); 
}
}

// This code has been contributed by Rajput-Ji

JavaScript

<script>

// JavaScript program to partition a linked list 
// around a given value. 

    /* Link list Node */
     class Node {
            constructor(val) {
                this.data = val;
                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 a new list
    // (using the existing nodes) and
    // return head of new list.
    function partition(head , x) {
        /*
         * Let us initialize start and tail nodes of new list
         */
         var tail = head;

        // Now iterate original list and connect nodes
        var curr = head;
        while (curr != null) {
        var next = curr.next;
            if (curr.data < x) {
                /* Insert node at head. */
                curr.next = head;
                head = curr;
            }

            else // Append to the list of greater values
            {
                /* Insert node at tail. */
                tail.next = curr;
                tail = curr;
            }
            curr = next;
        }
        tail.next = null;

        // The head has changed, so we need
        // to return it to the user.
        return head;
    }

    /* 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(3);
        head.next = newNode(5);
        head.next.next = newNode(8);
        head.next.next.next = newNode(2);
        head.next.next.next.next = newNode(10);
        head.next.next.next.next.next = newNode(2);
        head.next.next.next.next.next.next = newNode(1);

        var x = 5;
        head = partition(head, x);
        printList(head);

// This code contributed by Rajput-Ji

</script>