Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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. 
    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 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++ 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 concatenating
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;
}
  
// This code is contributed by Aditya Kumar (adityakumar129)


C




// 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 node
Node* 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 concatenating
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 */
void printList(Node* head)
{
    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 */
    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




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




# 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 concatenating 
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 
        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 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 = 3
head = partition(head, x) 
printList(head) 
  
# This code is contributed by Arnab Kundu.


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


Javascript




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


Output

2  10  4  5  30  50  

Time complexity: O(n) where n is the size of the linked list
Auxiliary Space: O(n)

 



Last Updated : 11 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads