给定一个红色，蓝色和黄色对象的数组，任务是使用就地排序算法对数组进行排序，以使所有蓝色对象出现在所有红色对象之前，所有红色对象出现在所有对象之前。黄色物体。
例子：
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
方法：首先分别使用哈希表的蓝色，红色和黄色的对象的值映射到1，2和3。现在，只要需要比较两个对象，就使用这些映射值。因此，该算法将对对象数组进行排序，以便首先显示所有蓝色对象(映射到值1)，然后显示所有红色对象(映射到值2)，然后显示所有黄色对象(映射到值3)。
下面是上述方法的实现：
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 print the 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 KumarC#
// 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 输出：
blue blue red red yellow