Related Articles
Sort a linked list of 0s, 1s and 2s
• Difficulty Level : Easy
• Last Updated : 13 May, 2021

Given a linked list of 0s, 1s and 2s, sort it.
Examples

Input: 1 -> 1 -> 2 -> 0 -> 2 -> 0 -> 1 -> NULL
Output: 0 -> 0 -> 1 -> 1 -> 1 -> 2 -> 2 -> NULL
Input: 1 -> 1 -> 2 -> 1 -> 0 -> NULL
Output: 0 -> 1 -> 1 -> 1 -> 2 -> NULL

Source: Microsoft Interview | Set 1

Following steps can be used to sort the given linked list.

• Traverse the list and count the number of 0s, 1s, and 2s. Let the counts be n1, n2, and n3 respectively.
• Traverse the list again, fill the first n1 nodes with 0, then n2 nodes with 1, and finally n3 nodes with 2.

Below image is a dry run of the above approach: Below is the implementation of the above approach:

## C++

 `// C++ Program to sort a linked list 0s, 1s or 2s``#include ``using` `namespace` `std;` `/* Link list node */``class` `Node``{``    ``public``:``    ``int` `data;``    ``Node* next;``};` `// Function to sort a linked list of 0s, 1s and 2s``void` `sortList(Node *head)``{``    ``int` `count = {0, 0, 0}; ``// Initialize count of '0', '1' and '2' as 0``    ``Node *ptr = head;` `    ``/* count total number of '0', '1' and '2'``    ``* count will store total number of '0's``    ``* count will store total number of '1's``    ``* count will store total number of '2's */``    ``while` `(ptr != NULL)``    ``{``        ``count[ptr->data] += 1;``        ``ptr = ptr->next;``    ``}` `    ``int` `i = 0;``    ``ptr = head;` `    ``/* Let say count = n1, count = n2 and count = n3``    ``* now start traversing list from head node,``    ``* 1) fill the list with 0, till n1 > 0``    ``* 2) fill the list with 1, till n2 > 0``    ``* 3) fill the list with 2, till n3 > 0 */``    ``while` `(ptr != NULL)``    ``{``        ``if` `(count[i] == 0)``            ``++i;``        ``else``        ``{``            ``ptr->data = i;``            ``--count[i];``            ``ptr = ptr->next;``        ``}``    ``}``}` `/* Function to push a node */``void` `push (Node** head_ref, ``int` `new_data)``{``    ``/* allocate node */``    ``Node* new_node = ``new` `Node();` `    ``/* put in the data */``    ``new_node->data = new_data;` `    ``/* link the old list off the new node */``    ``new_node->next = (*head_ref);` `    ``/* move the head to point to the new node */``    ``(*head_ref) = new_node;``}` `/* Function to print linked list */``void` `printList(Node *node)``{``    ``while` `(node != NULL)``    ``{``        ``cout << node->data << ``" "``;``        ``node = node->next;``    ``}``    ``cout << endl;``}` `/* Driver code*/``int` `main(``void``)``{``    ``Node *head = NULL;``    ``push(&head, 0);``    ``push(&head, 1);``    ``push(&head, 0);``    ``push(&head, 2);``    ``push(&head, 1);``    ``push(&head, 1);``    ``push(&head, 2);``    ``push(&head, 1);``    ``push(&head, 2);` `    ``cout << ``"Linked List Before Sorting\n"``;``    ``printList(head);` `    ``sortList(head);` `    ``cout << ``"Linked List After Sorting\n"``;``    ``printList(head);` `    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// C Program to sort a linked list 0s, 1s or 2s``#include``#include` `/* Link list node */``struct` `Node``{``    ``int` `data;``    ``struct` `Node* next;``};` `// Function to sort a linked list of 0s, 1s and 2s``void` `sortList(``struct` `Node *head)``{``    ``int` `count = {0, 0, 0};  ``// Initialize count of '0', '1' and '2' as 0``    ``struct` `Node *ptr = head;` `    ``/* count total number of '0', '1' and '2'``     ``* count will store total number of '0's``     ``* count will store total number of '1's``     ``* count will store total number of '2's  */``    ``while` `(ptr != NULL)``    ``{``        ``count[ptr->data] += 1;``        ``ptr = ptr->next;``    ``}` `    ``int` `i = 0;``    ``ptr = head;` `    ``/* Let say count = n1, count = n2 and count = n3``     ``* now start traversing list from head node,``     ``* 1) fill the list with 0, till n1 > 0``     ``* 2) fill the list with 1, till n2 > 0``     ``* 3) fill the list with 2, till n3 > 0  */``    ``while` `(ptr != NULL)``    ``{``        ``if` `(count[i] == 0)``            ``++i;``        ``else``        ``{``            ``ptr->data = i;``            ``--count[i];``            ``ptr = ptr->next;``        ``}``    ``}``}` `/* Function to push a node */``void` `push (``struct` `Node** head_ref, ``int` `new_data)``{``    ``/* allocate node */``    ``struct` `Node* new_node =``        ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));` `    ``/* put in the data  */``    ``new_node->data  = new_data;` `    ``/* link the old list off the new node */``    ``new_node->next = (*head_ref);` `    ``/* move the head to point to the new node */``    ``(*head_ref)    = new_node;``}` `/* Function to print linked list */``void` `printList(``struct` `Node *node)``{``    ``while` `(node != NULL)``    ``{``        ``printf``(``"%d  "``, node->data);``        ``node = node->next;``    ``}``    ``printf``(``"n"``);``}` `/* Driver program to test above function*/``int` `main(``void``)``{``    ``struct` `Node *head = NULL;``    ``push(&head, 0);``    ``push(&head, 1);``    ``push(&head, 0);``    ``push(&head, 2);``    ``push(&head, 1);``    ``push(&head, 1);``    ``push(&head, 2);``    ``push(&head, 1);``    ``push(&head, 2);` `    ``printf``(``"Linked List Before Sorting\n"``);``    ``printList(head);` `    ``sortList(head);` `    ``printf``(``"Linked List After Sorting\n"``);``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to sort a linked list of 0, 1 and 2``class` `LinkedList``{``    ``Node head;  ``// head of list`` ` `    ``/* Linked list Node*/``    ``class` `Node``    ``{``        ``int` `data;``        ``Node next;``        ``Node(``int` `d) {data = d; next = ``null``; }``    ``}` `    ``void` `sortList()``    ``{``       ``// initialise count of 0 1 and 2 as 0``       ``int` `count[] = {``0``, ``0``, ``0``};``       ` `       ``Node ptr = head;``       ` `       ``/* count total number of '0', '1' and '2'``        ``* count will store total number of '0's``        ``* count will store total number of '1's``        ``* count will store total number of '2's  */``       ``while` `(ptr != ``null``)``       ``{``            ``count[ptr.data]++;``            ``ptr = ptr.next;``       ``}` `       ``int` `i = ``0``;``       ``ptr = head;` `       ``/* Let say count = n1, count = n2 and count = n3``        ``* now start traversing list from head node,``        ``* 1) fill the list with 0, till n1 > 0``        ``* 2) fill the list with 1, till n2 > 0``        ``* 3) fill the list with 2, till n3 > 0  */``        ``while` `(ptr != ``null``)``        ``{``            ``if` `(count[i] == ``0``)``                ``i++;``            ``else``            ``{``               ``ptr.data= i;``               ``--count[i];``               ``ptr = ptr.next;``            ``}``         ``}``    ``}                      ` `                   ` `    ``/* Utility functions */` `    ``/* Inserts a new Node at front of the list. */``    ``public` `void` `push(``int` `new_data)``    ``{``        ``/* 1 & 2: Allocate the Node &``                  ``Put in the data*/``        ``Node new_node = ``new` `Node(new_data);`` ` `        ``/* 3. Make next of new Node as head */``        ``new_node.next = head;`` ` `        ``/* 4. Move the head to point to new Node */``        ``head = new_node;``    ``}` `    ``/* Function to print linked list */``    ``void` `printList()``    ``{``        ``Node temp = head;``        ``while` `(temp != ``null``)``        ``{``           ``System.out.print(temp.data+``" "``);``           ``temp = temp.next;``        ``} ``        ``System.out.println();``    ``}` `     ``/* Driver program to test above functions */``    ``public` `static` `void` `main(String args[])``    ``{``        ``LinkedList llist = ``new` `LinkedList();``        ` `        ``/* Constructed Linked List is 1->2->3->4->5->6->7->``           ``8->8->9->null */``        ``llist.push(``0``);``        ``llist.push(``1``);``        ``llist.push(``0``);``        ``llist.push(``2``);``        ``llist.push(``1``);``        ``llist.push(``1``);``        ``llist.push(``2``);``        ``llist.push(``1``);``        ``llist.push(``2``);``        ` `        ``System.out.println(``"Linked List before sorting"``);``        ``llist.printList();``        ` `        ``llist.sortList();` `        ``System.out.println(``"Linked List after sorting"``);``        ``llist.printList();``    ``}``}``/* This code is contributed by Rajat Mishra */`

## Python

 `# Python program to sort a linked list of 0, 1 and 2``class` `LinkedList(``object``):``    ``def` `__init__(``self``):` `         ``# head of list``         ``self``.head ``=` `None` `    ``# Linked list Node``    ``class` `Node(``object``):``        ``def` `__init__(``self``, d):``            ``self``.data ``=` `d``            ``self``.``next` `=` `None` `    ``def` `sortList(``self``):` `        ``# initialise count of 0 1 and 2 as 0``        ``count ``=` `[``0``, ``0``, ``0``]` `        ``ptr ``=` `self``.head` `        ``# count total number of '0', '1' and '2'``        ``# * count will store total number of '0's``        ``# * count will store total number of '1's``        ``# * count will store total number of '2's ``        ``while` `ptr !``=` `None``:``            ``count[ptr.data]``+``=``1``            ``ptr ``=` `ptr.``next` `        ``i ``=` `0``        ``ptr ``=` `self``.head` `        ``# Let say count = n1, count = n2 and count = n3``        ``# * now start traversing list from head node,``        ``# * 1) fill the list with 0, till n1 > 0``        ``# * 2) fill the list with 1, till n2 > 0``        ``# * 3) fill the list with 2, till n3 > 0 ``        ``while` `ptr !``=` `None``:``            ``if` `count[i] ``=``=` `0``:``                ``i``+``=``1``            ``else``:``                ``ptr.data ``=` `i``                ``count[i]``-``=``1``                ``ptr ``=` `ptr.``next`  `    ``# Utility functions``    ``# Inserts a new Node at front of the list.``    ``def` `push(``self``, new_data):` `        ``# 1 & 2: Allocate the Node &``        ``# Put in the data``        ``new_node ``=` `self``.Node(new_data)` `        ``# 3. Make next of new Node as head``        ``new_node.``next` `=` `self``.head` `        ``# 4. Move the head to point to new Node``        ``self``.head ``=` `new_node` `    ``# Function to print linked list``    ``def` `printList(``self``):``        ``temp ``=` `self``.head``        ``while` `temp !``=` `None``:``            ``print` `str``(temp.data),``            ``temp ``=` `temp.``next``        ``print` `''` `# Driver program to test above functions``llist ``=` `LinkedList()``llist.push(``0``)``llist.push(``1``)``llist.push(``0``)``llist.push(``2``)``llist.push(``1``)``llist.push(``1``)``llist.push(``2``)``llist.push(``1``)``llist.push(``2``)` `print` `"Linked List before sorting"``llist.printList()` `llist.sortList()` `print` `"Linked List after sorting"``llist.printList()` `# This code is contributed by BHAVYA JAIN`

## C#

 `// C# program to sort a linked``// list of 0, 1 and 2``using` `System;` `public` `class` `LinkedList``{``    ``Node head; ``// head of list` `    ``/* Linked list Node*/``    ``class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;``        ``public` `Node(``int` `d)``        ``{``            ``data = d; next = ``null``;``        ``}``    ``}` `    ``void` `sortList()``    ``{``        ` `        ``// initialise count of 0 1 and 2 as 0``        ``int` `[]count = {0, 0, 0};``        ` `        ``Node ptr = head;``        ` `        ``/* count total number of '0', '1' and '2'``        ``* count will store total number of '0's``        ``* count will store total number of '1's``        ``* count will store total number of '2's */``        ``while` `(ptr != ``null``)``        ``{``               ``count[ptr.data]++;``            ``ptr = ptr.next;``        ``}` `        ``int` `i = 0;``        ``ptr = head;` `        ``/* Let say count = n1, count = n2 and count = n3``        ``* now start traversing list from head node,``        ``* 1) fill the list with 0, till n1 > 0``        ``* 2) fill the list with 1, till n2 > 0``        ``* 3) fill the list with 2, till n3 > 0 */``        ``while` `(ptr != ``null``)``        ``{``            ``if` `(count[i] == 0)``                ``i++;``            ``else``            ``{``                ``ptr.data= i;``                ``--count[i];``                ``ptr = ptr.next;``            ``}``        ``}``    ``}                    ` `                    ` `    ``/* Utility functions */` `    ``/* Inserts a new Node at front of the list. */``    ``public` `void` `push(``int` `new_data)``    ``{``        ``/* 1 & 2: Allocate the Node &``                ``Put in the data*/``        ``Node new_node = ``new` `Node(new_data);` `        ``/* 3. Make next of new Node as head */``        ``new_node.next = head;` `        ``/* 4. Move the head to point to new Node */``        ``head = new_node;``    ``}` `    ``/* Function to print linked list */``    ``void` `printList()``    ``{``        ``Node temp = head;``        ``while` `(temp != ``null``)``        ``{``            ``Console.Write(temp.data+``" "``);``            ``temp = temp.next;``        ``}``        ``Console.WriteLine();``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `Main(String []args)``    ``{``        ``LinkedList llist = ``new` `LinkedList();``        ` `        ``/* Constructed Linked List is 1->2->3->4->``        ``5->6->7->8->8->9->null */``        ``llist.push(0);``        ``llist.push(1);``        ``llist.push(0);``        ``llist.push(2);``        ``llist.push(1);``        ``llist.push(1);``        ``llist.push(2);``        ``llist.push(1);``        ``llist.push(2);``        ` `        ``Console.WriteLine(``"Linked List before sorting"``);``        ``llist.printList();``        ` `        ``llist.sortList();` `        ``Console.WriteLine(``"Linked List after sorting"``);``        ``llist.printList();``    ``}``}` `/* This code is contributed by 29AjayKumar */`

## Javascript

 ``

Output:

```Linked List Before Sorting
2  1  2  1  1  2  0  1  0
0  0  1  1  1  1  2  2  2```

Time Complexity: O(n) where n is the number of nodes in the linked list.
Auxiliary Space: O(1)

https://youtu.be/4

-3TU2FRs70?list=PLqM7alHXFySH41ZxzrPNj2pAYPOI8ITe7
Sort a linked list of 0s, 1s and 2s by changing links