# Sorting objects using In-Place sorting algorithm

Given an array of red, blue and yellow objects, the task is to use an in-place sorting algorithm to sort the array in such a way that all the blue objects appear before all the red objects and all the red objects appear before all the yellow objects.

Examples:

Input: arr[] = {“blue”, “red”, “yellow”, “blue”, “yellow”}
Output: blue blue red yellow yellow

Input: arr[] = {“red”, “blue”, “red”, “yellow”, “blue”}
Output: blue blue red red yellow

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

Approach: First of all map the values of blue, red and yellow objects to 1, 2 and 3 respectively using a hash table. Now use these mapped values whenever a comparison of two objects is required. So, the algorithm will sort the array of objects such that all blue objects ( mapping to value 1 ) will appear first, then all red objects ( mapping to value 2 ) and then all yellow objects ( mapping to value 3 ).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Partition function which will partition ` `// the array and into two parts ` `int` `partition(vector& objects, ``int` `l, ``int` `r, ` `            ``unordered_map& hash) ` `{ ` `    ``int` `j = l - 1; ` ` `  `    ``int` `last_element = hash[objects[r]]; ` ` `  `    ``for` `(``int` `i = l; i < r; i++) { ` ` `  `        ``// Compare hash values of objects ` `        ``if` `(hash[objects[i]] <= last_element) { ` `            ``j++; ` `            ``swap(objects[i], objects[j]); ` `        ``} ` `    ``} ` ` `  `    ``j++; ` ` `  `    ``swap(objects[j], objects[r]); ` ` `  `    ``return` `j; ` `} ` ` `  `// Classic quicksort algorithm ` `void` `quicksort(vector& objects, ``int` `l, ``int` `r,  ` `                    ``unordered_map& hash) ` `{ ` `    ``if` `(l < r) { ` `        ``int` `mid = partition(objects, l, r, hash); ` `        ``quicksort(objects, l, mid - 1, hash); ` `        ``quicksort(objects, mid + 1, r, hash); ` `    ``} ` `} ` ` `  `// Function to sort and print the objects ` `void` `sortObj(vector& objects) ` `{ ` ` `  `    ``// Create a hash table ` `    ``unordered_map hash; ` ` `  `    ``// As the sorting order is blue objects, ` `    ``// red objects and then yellow objects ` `    ``hash[``"blue"``] = 1; ` `    ``hash[``"red"``] = 2; ` `    ``hash[``"yellow"``] = 3; ` ` `  `    ``// Quick sort function ` `    ``quicksort(objects, 0, ``int``(objects.size() - 1), hash); ` ` `  `    ``// Printing the sorted array ` `    ``for` `(``int` `i = 0; i < objects.size(); i++) ` `        ``cout << objects[i] << ``" "``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``// Let's represent objects as strings ` `    ``vector objects{ ``"red"``, ``"blue"``, ` `                            ``"red"``, ``"yellow"``, ``"blue"` `}; ` ` `  `    ``sortObj(objects); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` `class` `GFG  ` `{ ` ` `  `// Partition function which will partition ` `// the array and into two parts ` `static` `int` `partition(Vector objects, ``int` `l, ``int` `r, ` `                        ``Map hash) ` `{ ` `    ``int` `j = l - ``1``; ` ` `  `    ``int` `last_element = hash.get(objects.get(r)); ` ` `  `    ``for` `(``int` `i = l; i < r; i++)  ` `    ``{ ` ` `  `        ``// Compare hash values of objects ` `        ``if` `(hash.get(objects.get(i)) <= last_element)  ` `        ``{ ` `            ``j++; ` `            ``Collections.swap(objects, i, j); ` `        ``} ` `    ``} ` ` `  `    ``j++; ` ` `  `    ``Collections.swap(objects, j, r); ` ` `  `    ``return` `j; ` `} ` ` `  `// Classic quicksort algorithm ` `static` `void` `quicksort(Vector objects, ``int` `l, ``int` `r, ` `                         ``Map hash) ` `{ ` `    ``if` `(l < r) ` `    ``{ ` `        ``int` `mid = partition(objects, l, r, hash); ` `        ``quicksort(objects, l, mid - ``1``, hash); ` `        ``quicksort(objects, mid + ``1``, r, hash); ` `    ``} ` `} ` ` `  `// Function to sort and print the objects ` `static` `void` `sortObj(Vector objects) ` `{ ` ` `  `    ``// Create a hash table ` `    ``Map hash = ``new` `HashMap<>(); ` ` `  `    ``// As the sorting order is blue objects, ` `    ``// red objects and then yellow objects ` `    ``hash. put(``"blue"``, ``1``); ` `    ``hash. put(``"red"``, ``2``); ` `    ``hash. put(``"yellow"``, ``3``); ` ` `  `    ``// Quick sort function ` `    ``quicksort(objects, ``0``, objects.size() - ``1``, hash); ` ` `  `    ``// Printing the sorted array ` `    ``for` `(``int` `i = ``0``; i < objects.size(); i++) ` `        ``System.out.print(objects.get(i) + ``" "``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String []args) ` `{ ` `    ``// Let's represent objects as strings ` `    ``Vector objects = ``new` `Vector<>(Arrays.asList( ``"red"``, ``"blue"``, ` `                                                         ``"red"``, ``"yellow"``,  ` `                                                         ``"blue"` `)); ` ` `  `    ``sortObj(objects); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Partition function which will partition ` `# the array and into two parts ` `objects ``=` `[] ` `hash` `=` `dict``() ` ` `  `def` `partition(l, r): ` `    ``global` `objects, ``hash` `    ``j ``=` `l ``-` `1` ` `  `    ``last_element ``=` `hash``[objects[r]] ` ` `  `    ``for` `i ``in` `range``(l, r): ` ` `  `        ``# Compare hash values of objects ` `        ``if` `(``hash``[objects[i]] <``=` `last_element): ` `            ``j ``+``=` `1` `            ``(objects[i],  ` `             ``objects[j]) ``=` `(objects[j],  ` `                            ``objects[i]) ` ` `  `    ``j ``+``=` `1` ` `  `    ``(objects[j],  ` `     ``objects[r]) ``=` `(objects[r],  ` `                    ``objects[j]) ` ` `  `    ``return` `j ` ` `  `# Classic quicksort algorithm ` `def` `quicksort(l, r): ` `    ``if` `(l < r): ` `        ``mid ``=` `partition(l, r) ` `        ``quicksort(l, mid ``-` `1``) ` `        ``quicksort(mid ``+` `1``, r) ` ` `  `# Function to sort and prthe objects ` `def` `sortObj(): ` `    ``global` `objects, ``hash` ` `  `    ``# As the sorting order is blue objects, ` `    ``# red objects and then yellow objects ` `    ``hash``[``"blue"``] ``=` `1` `    ``hash``[``"red"``] ``=` `2` `    ``hash``[``"yellow"``] ``=` `3` ` `  `    ``# Quick sort function ` `    ``quicksort(``0``, ``int``(``len``(objects) ``-` `1``)) ` ` `  `    ``# Printing the sorted array ` `    ``for` `i ``in` `objects: ` `        ``print``(i, end ``=` `" "``) ` ` `  `# Driver code ` ` `  `# Let's represent objects as strings ` `objects ``=` `[``"red"``, ``"blue"``, ``"red"``,  ` `               ``"yellow"``, ``"blue"``] ` ` `  `sortObj() ` ` `  `# This code is contributed  ` `# by Mohit Kumar `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `// Partition function which will partition ` `// the array and into two parts ` `static` `int` `partition(List objects, ``int` `l, ``int` `r, ` `                           ``Dictionary hash) ` `{ ` `    ``int` `j = l - 1; ` `    ``String temp; ` `    ``int` `last_element = hash[objects[r]]; ` ` `  `    ``for` `(``int` `i = l; i < r; i++)  ` `    ``{ ` ` `  `        ``// Compare hash values of objects ` `        ``if` `(hash[objects[i]] <= last_element)  ` `        ``{ ` `            ``j++; ` `            ``temp = objects[i]; ` `            ``objects[i] = objects[j]; ` `            ``objects[j] = temp; ` `        ``} ` `    ``} ` ` `  `    ``j++; ` ` `  `    ``temp = objects[r]; ` `    ``objects[r] = objects[j]; ` `    ``objects[j] = temp; ` ` `  `    ``return` `j; ` `} ` ` `  `// Classic quicksort algorithm ` `static` `void` `quicksort(List objects, ``int` `l, ``int` `r, ` `                            ``Dictionary hash) ` `{ ` `    ``if` `(l < r) ` `    ``{ ` `        ``int` `mid = partition(objects, l, r, hash); ` `        ``quicksort(objects, l, mid - 1, hash); ` `        ``quicksort(objects, mid + 1, r, hash); ` `    ``} ` `} ` ` `  `// Function to sort and print the objects ` `static` `void` `sortObj(List objects) ` `{ ` ` `  `    ``// Create a hash table ` `    ``Dictionary hash = ``new` `Dictionary(); ` ` `  `    ``// As the sorting order is blue objects, ` `    ``// red objects and then yellow objects ` `    ``hash.Add(``"blue"``, 1); ` `    ``hash.Add(``"red"``, 2); ` `    ``hash.Add(``"yellow"``, 3); ` ` `  `    ``// Quick sort function ` `    ``quicksort(objects, 0, objects.Count - 1, hash); ` ` `  `    ``// Printing the sorted array ` `    ``for` `(``int` `i = 0; i < objects.Count; i++) ` `        ``Console.Write(objects[i] + ``" "``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``// Let's represent objects as strings ` `    ``List objects = ``new` `List{``"red"``, ``"blue"``, ` `                                            ``"red"``, ``"yellow"``,  ` `                                            ``"blue"``}; ` ` `  `    ``sortObj(objects); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```blue blue red red yellow
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.