Sorting objects using In-Place sorting algorithm

15 Jun, 2022
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 yellowInput: arr[] = {“red”, “blue”, “red”, “yellow”, “blue”} Output: blue blue red red yellow  
 
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++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Partition function which will partition// the array and into two partsint partition(vector<string>& objects, int l, int r,            unordered_map<string, int>& 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 algorithmvoid quicksort(vector<string>& objects, int l, int r,                    unordered_map<string, int>& 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 objectsvoid sortObj(vector<string>& objects){     // Create a hash table    unordered_map<string, int> 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 codeint main(){     // Let's represent objects as strings    vector<string> objects{ "red", "blue",                            "red", "yellow", "blue" };     sortObj(objects);     return 0;}
// Java implementation of the approachimport java.util.*;class GFG{ // Partition function which will partition// the array and into two partsstatic int partition(Vector<String> objects, int l, int r,                        Map<String, Integer> 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 algorithmstatic void quicksort(Vector<String> objects, int l, int r,                         Map<String, Integer> 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 objectsstatic void sortObj(Vector<String> objects){     // Create a hash table    Map<String, Integer> 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 codepublic static void main(String []args){    // Let's represent objects as strings    Vector<String> objects = new Vector<>(Arrays.asList( "red", "blue",                                                         "red", "yellow",                                                         "blue" ));     sortObj(objects);}} // This code is contributed by PrinciRaj1992
# Python3 implementation of the approach # Partition function which will partition# the array and into two partsobjects = []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 algorithmdef quicksort(l, r):    if (l < r):        mid = partition(l, r)        quicksort(l, mid - 1)        quicksort(mid + 1, r) # Function to sort and print the objectsdef 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 stringsobjects = ["red", "blue", "red",               "yellow", "blue"] sortObj() # This code is contributed# by Mohit Kumar
// C# implementation of the approachusing System;using System.Collections.Generic; class GFG{ // Partition function which will partition// the array and into two partsstatic int partition(List<String> objects, int l, int r,                           Dictionary<String, int> 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 algorithmstatic void quicksort(List<String> objects, int l, int r,                            Dictionary<String, int> 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 objectsstatic void sortObj(List<String> objects){     // Create a hash table    Dictionary<String,               int> hash = new Dictionary<String,                                          int>();     // 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 codepublic static void Main(String []args){    // Let's represent objects as strings    List<String> objects = new List<String>{"red", "blue",                                            "red", "yellow",                                            "blue"};     sortObj(objects);}} // This code is contributed by Rajput-Ji
<script>// Javascript implementation of the approach // Partition function which will partition// the array and into two partsfunction partition(objects, l, r, hash){    let j = l - 1;       let last_element = hash.get(objects[r]);       for (let i = l; i < r; i++)    {           // Compare hash values of objects        if (hash.get(objects[i]) <= last_element)        {            j++;            let temp = objects[i];            objects[i] = objects[j];            objects[j] = temp;        }    }       j++;       let temp = objects[r];            objects[r] = objects[j];            objects[j] = temp;       return j;} // Classic quicksort algorithmfunction quicksort(objects, l, r, hash){    if (l < r)    {        let mid = partition(objects, l, r, hash);        quicksort(objects, l, mid - 1, hash);        quicksort(objects, mid + 1, r, hash);    }} // Function to sort and print the objectsfunction sortObj(objects){     // Create a hash table    let hash = new Map();       // As the sorting order is blue objects,    // red objects and then yellow objects    hash. set("blue", 1);    hash. set("red", 2);    hash. set("yellow", 3);       // Quick sort function    quicksort(objects, 0, objects.length - 1, hash);       // Printing the sorted array    for (let i = 0; i < objects.length; i++)        document.write(objects[i] + " ");} // Driver codelet objects = ["red", "blue","red", "yellow", "blue"];sortObj(objects); // This code is contributed by patel2127</script>
blue blue red red yellow
 
Time complexity: O(n^2) since using qucksort
princiraj1992
Rajput-Ji
mohit kumar 29
Code_Mech
patel2127
polymatir3j
Quick Sort
Algorithms
Competitive Programming
Sorting
Sorting
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.