Los mapas son contenedores asociativos que almacenan elementos en forma de mapa. Cada elemento tiene un valor clave y un valor asignado. Dos valores asignados no pueden tener valores de clave iguales. De forma predeterminada, un Mapa en C++ se ordena en orden creciente según su clave. A continuación se muestran los diversos métodos para lograr esto:
Método 1: usar el vector de pares La idea es copiar todo el contenido del mapa al vector de pares correspondiente y ordenar el vector de pares según el segundo valor usando la función lambda que se indica a continuación:
bool cmp(pair<T1, T2>& a,
pair<T1, T2>& b)
{
return a.second < b.second;
}
where T1 and T2
are the data-types
that can be the
same or different.
A continuación se muestra la implementación del enfoque anterior:
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Comparator function to sort pairs
// according to second value
bool cmp(pair<string, int>& a,
pair<string, int>& b)
{
return a.second < b.second;
}
// Function to sort the map according
// to value in a (key-value) pairs
void sort(map<string, int>& M)
{
// Declare vector of pairs
vector<pair<string, int> > A;
// Copy key-value pair from Map
// to vector of pairs
for (auto& it : M) {
A.push_back(it);
}
// Sort using comparator function
sort(A.begin(), A.end(), cmp);
// Print the sorted value
for (auto& it : A) {
cout << it.first << ' '
<< it.second << endl;
}
}
// Driver Code
int main()
{
// Declare Map
map<string, int> M;
// Given Map
M = { { "GfG", 3 },
{ "To", 2 },
{ "Welcome", 1 } };
// Function Call
sort(M);
return 0;
}
Welcome 1 To 2 GfG 3
Método 2: usar el conjunto de pares La idea es insertar todos los pares (clave-valor) del mapa en un conjunto de pares que se puede construir usando una función de comparación que ordena los pares según el segundo valor.
A continuación se muestra la implementación del enfoque anterior:
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Comparison function for sorting the
// set by increasing order of its pair's
// second value
struct comp {
template <typename T>
// Comparator function
bool operator()(const T& l,
const T& r) const
{
if (l.second != r.second) {
return l.second < r.second;
}
return l.first < r.first;
}
};
// Function to sort the map according
// to value in a (key-value) pairs
void sort(map<string, int>& M)
{
// Declare set of pairs and insert
// pairs according to the comparator
// function comp()
set<pair<string, int>, comp> S(M.begin(),
M.end());
// Print the sorted value
for (auto& it : S) {
cout << it.first << ' '
<< it.second << endl;
}
}
// Driver Code
int main()
{
// Declare Map
map<string, int> M;
// Given Map
M = { { "GfG", 3 },
{ "To", 2 },
{ "Welcome", 1 } };
// Function Call
sort(M);
return 0;
}
Welcome 1 To 2 GfG 3
Método 3: usar multimapa
Multimapa es similar a un mapa con la adición de que varios elementos pueden tener las mismas claves. En lugar de que cada elemento sea único, el par clave-valor y valor asignado tienen que ser únicos en este caso.
La idea es insertar todos los pares del mapa dado en el mapa múltiple utilizando el valor del mapa original como clave en el mapa múltiple y el valor clave del mapa original como valor en el mapa múltiple.
A continuación se muestra la implementación del enfoque anterior:
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to sort the map according
// to value in a (key-value) pairs
void sort(map<string, int>& M)
{
// Declare a multimap
multimap<int, string> MM;
// Insert every (key-value) pairs from
// map M to multimap MM as (value-key)
// pairs
for (auto& it : M) {
MM.insert({ it.second, it.first });
}
// Print the multimap
for (auto& it : MM) {
cout << it.second << ' '
<< it.first << endl;
}
}
// Driver Code
int main()
{
// Declare Map
map<string, int> M;
// Given Map
M = { { "GfG", 3 },
{ "To", 2 },
{ "Welcome", 1 } };
// Function Call
sort(M);
return 0;
}
Welcome 1 To 2 GfG 3
Publicación traducida automáticamente
Artículo escrito por chirags_30 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA