Clasificación de vectores 2D de pares en C++

Un vector 2D, también conocido como vector de vectores, es un vector en el que cada elemento es un vector en sí mismo. En otras palabras, es una array implementada con la ayuda de vectores.

¿Qué es un vector 2D de pares?

Un vector 2D de pares es un vector en el que cada elemento es un vector de pares por sí mismo. En otras palabras, es una array implementada con la ayuda de vectores de pares.

Ejemplo: A continuación se muestra el programa C++ para implementar un vector 2D de pares.

// C++ program to demonstrate the
// working of vector of vectors
// of pairs
#include <bits/stdc++.h>
using namespace std;
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >& myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
         {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
    vector<pair<int, int> > vect2 =
    {{9, 10}, {11, 12}, {13, 14}, {15, 16}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}, {21, 22}, {23, 24}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    print(myContainer);
 
    return 0;
}

Este artículo se enfoca en discutir diferentes técnicas utilizadas para ordenar un vector 2D de pares.

Caso 1: Para ordenar una fila particular de un vector 2D:

•  Sobre la base de los primeros valores de los pares: este tipo de clasificación organiza una fila seleccionada de un vector 2D en orden ascendente del primer valor de los pares. Esto se logra usando «sort()» y pasando iteradores de vector 1D como sus argumentos.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                     

Salida:
(1, 9) (4, 1) (7, 2)  
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)

A continuación se muestra la implementación del enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs
#include <bits/stdc++.h>
using namespace std;
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {1, 9}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}, {21, 22}, {23, 24}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements
    // before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting the first row of 2D vector
    // of pairs on the basis of first
    // element of pairs
    sort(myContainer[0].begin(),
         myContainer[0].end());
 
    cout << "\n\n After sorting the first row " <<
            "on the basis of first element of pairs, ";
    print(myContainer);
 
    return 0;
}

• Sobre la base del segundo valor de los pares: este tipo de clasificación organiza una fila seleccionada de un vector 2D en orden ascendente del segundo valor del par. Esto se logra usando «sort()» y pasando iteradores de vector 1D como sus argumentos. En este caso, es necesario pasar un comparador personalizado como tercer argumento que implemente la lógica para ordenar en función del segundo valor de los pares.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                     

Salida:
(4, 1) (7, 2) (1, 9)  
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)

 A continuación se muestra la implementación del enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(pair<int, int>& pair1,
                  pair<int, int>& pair2)
{
    return pair1.second < pair2.second;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {1, 9}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}, {21, 22}, {23, 24}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting first row of 2D vector of pairs
    // on the basis of second element of pairs
    // By passing a custom comparator as a
    // third argument
    sort(myContainer[0].begin(),
         myContainer[0].end(), myComparator);
 
    cout << "\n\n After sorting the first row on " <<
            "the basis of second element of pairs, ";
    print(myContainer);
 
    return 0;
}

Caso 2: para ordenar todo el vector 2D en función de una columna en particular:

• Sobre la base de los primeros valores de los pares: en este tipo de clasificación, el vector 2D se clasifica por completo en función de una columna elegida. Por ejemplo, si la columna elegida es la segunda, la fila con el primer valor más pequeño de los pares de la segunda columna se convierte en la primera fila, el segundo primer valor más pequeño de los pares en la segunda columna se convierte en la segunda fila, y así sucesivamente.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                     

Salida:
(4, 1) (1, 9) (7, 2)  
(1, 6) (3, 2) (1, 4)    
(3, 2) (4, 5) (8, 1)  

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1[1].first < vector2[1].first;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{3, 5}, {10, 3}, {2, 1}, {3, 8}};
    vector<pair<int, int> > vect2 =
    {{1, 6}, {9, 1}, {2, 5}, {1, 5}};
    vector<pair<int, int> > vect3 =
    {{1, 5}, {2, 5}, {12, 12}, {1, 4}};
    vector<pair<int, int> > vect4 =
    {{5, 2}, {1, 52}, {9, 3}, {3, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements
    // before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting 2D vector of pairs on the basis
    // of first element of pairs of the second
    // column by passing a custom comparator
    // as a third argument
    sort(myContainer.begin(), myContainer.end(),
         myComparator);
 
    cout << "\n\n After sorting the 2D vector on the " <<
            "basis of first element of pairs of the second column, ";
    print(myContainer);
 
    return 0;
}

•  Sobre la base de los segundos valores de los pares: en este tipo de clasificación, el vector 2D se clasifica por completo en función de una columna elegida. Por ejemplo, si la columna elegida es la segunda, la fila con el segundo valor más pequeño de los pares de la segunda columna se convierte en la primera fila, el segundo valor más pequeño de los pares en la segunda columna se convierte en la segunda fila, y así sucesivamente.

Por ejemplo, clasificar todo el vector 2D en función del segundo valor de los pares de la segunda columna daría como resultado,

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                      

Salida:  
(1, 6) (3, 2) (1, 4) 
(3, 2) (4, 5) (8, 1)  
(4, 1) (1, 9) (7, 2) 

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1[1].second < vector2[1].second;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{3, 5}, {10, 3}, {2, 1}, {3, 8}};
    vector<pair<int, int> > vect2 =
    {{1, 6}, {9, 1}, {2, 5}, {1, 5}};
    vector<pair<int, int> > vect3 =
    {{1, 5}, {2, 5}, {12, 12}, {1, 4}};
    vector<pair<int, int> > vect4 =
    {{5, 2}, {1, 52}, {9, 3}, {3, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting 2D vector of pairs on the basis of
    // first element of pairs of the second column
    // By passing a custom comparator as a third argument
    sort(myContainer.begin(), myContainer.end(),
         myComparator);
 
    cout << "\n\n After sorting the 2D vector on " <<
            "the basis of first element of pairs of " <<
            "the second column, ";
    print(myContainer);
 
    return 0;
}

Caso 3: ordenar una fila particular de un vector 2D de pares en orden descendente

• Sobre la base de los primeros valores de los pares: este tipo de clasificación organiza una fila seleccionada de un vector 2D en orden descendente por el primer elemento de los pares. Esto se logra usando «sort()» y pasando iteradores de vector 1D como sus argumentos. En este caso, es necesario pasar un comparador personalizado como tercer argumento que implemente la lógica para ordenar en función del primer elemento de pares.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                     

Salida:
(7, 2) (4, 1) (1, 9)  
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs in descending order
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(pair<int, int>& pair1,
                  pair<int, int>& pair2)
{
    return pair1.first > pair2.first;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {1, 9}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}, {21, 22}, {23, 24}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements
    // before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting the first row of 2D vector
    // of pairs in descending order
    // of the first element of pairs
    sort(myContainer[0].begin(),
         myContainer[0].end(), myComparator);
 
    cout << "\n\n After sorting the first row " <<
            "in descending order of the first " <<
            "element of pairs, ";
    print(myContainer);
 
    return 0;
}

• Sobre la base de los segundos valores de los pares: este tipo de clasificación organiza una fila seleccionada de un vector 2D en orden descendente por el segundo elemento de los pares. Esto se logra usando «sort()» y pasando iteradores de vector 1D como sus argumentos. En este caso, es necesario pasar un comparador personalizado como tercer argumento que implemente la lógica para clasificar en orden descendente sobre la base del segundo elemento de pares.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)              
(1, 6) (3, 2) (1, 4)                     

Salida:
(1, 9) (7, 2) (4, 1)  
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs in descending order
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(pair<int, int>& pair1,
           pair<int, int>& pair2)
{
    return pair1.second > pair2.second;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {1, 9}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}, {21, 22}, {23, 24}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting first row of 2D vector of pairs
    // in descending order of second element of pairs
    // By passing a custom comparator as a third argument
    sort(myContainer[0].begin(),
         myContainer[0].end(), myComparator);
 
    cout << "\n\n After sorting the first row " <<
            "in descending order of second element " <<
            "of pairs, ";
    print(myContainer);
 
    return 0;
}

Caso 4: Para ordenar todo el vector 2D en base a una columna en particular en orden descendente:

• Sobre la base de los primeros valores de los pares: En este tipo de clasificación, el vector 2D se ordena por completo en función del primer valor de los pares de la columna elegida en orden descendente. Por ejemplo, si la columna elegida es la segunda, la fila con el mayor valor del primer elemento de pares en la segunda columna se convierte en la primera fila, el segundo mayor valor del segundo elemento de pares en la segunda columna se convierte en la segunda fila, y así. 
  En este caso, es necesario pasar un comparador personalizado como tercer argumento que implemente la lógica para clasificar en orden descendente sobre la base del primer elemento de pares.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)                      

Salida:
(3, 2) (4, 5) (8, 1)
(1, 6) (3, 2) (1, 4)  
(4, 1) (1, 9) (7, 2)

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs in descending order
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1[1].first > vector2[1].first;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{3, 5}, {10, 3}, {2, 1}, {3, 8}};
    vector<pair<int, int> > vect2 =
    {{1, 6}, {9, 1}, {2, 5}, {1, 5}};
    vector<pair<int, int> > vect3 =
    {{1, 5}, {2, 5}, {12, 12}, {1, 4}};
    vector<pair<int, int> > vect4 =
    {{5, 2}, {1, 52}, {9, 3}, {3, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting 2D vector of pairs in descending
    // order of the first element of pairs of
    // the second column by passing a custom
    // comparator as a third argument
    sort(myContainer.begin(),
         myContainer.end(), myComparator);
 
    cout << "\n\n After sorting the 2D vector in " <<
            "descending order of the first element " <<
            "of pairs of the second column, ";
    print(myContainer);
 
    return 0;
}

• Sobre la base de los segundos valores de los pares: En este tipo de clasificación, el vector 2D se ordena completamente en función del segundo elemento de los pares de la columna elegida en orden descendente. Por ejemplo, si la columna elegida es la segunda, la fila con el mayor valor del segundo elemento de pares en la segunda columna se convierte en la primera fila, el segundo mayor valor del segundo elemento de pares en la segunda columna se convierte en la segunda fila, y así. 
  En este caso, es necesario pasar un comparador personalizado como tercer argumento que implemente la lógica para clasificar en orden descendente sobre la base del segundo elemento de pares.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)                      
(3, 2) (4, 2) (8, 1)      
(1, 6) (3, 5) (1, 4)                     

Salida:
(4, 1) (1, 9) (7, 2)        
(1, 6) (3, 5) (1, 4)   
(3, 2) (4, 2) (8, 1) 

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting vector of vectors
// of pairs in descending order
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1[1].second > vector2[1].second;
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{3, 5}, {10, 3}, {2, 1}, {3, 8}};
    vector<pair<int, int> > vect2 =
    {{1, 6}, {9, 1}, {2, 5}, {1, 5}};
    vector<pair<int, int> > vect3 =
    {{1, 5}, {2, 5}, {12, 12}, {1, 4}};
    vector<pair<int, int> > vect4 =
    {{5, 2}, {1, 52}, {9, 3}, {3, 32}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
 
    // Print the vector elements before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting 2D vector of pairs in descending
    // order of second element of pairs of the
    // second column by passing a custom comparator
    // as a third argument
    sort(myContainer.begin(),
         myContainer.end(), myComparator);
 
    cout << "\n\n After sorting the 2D vector " <<
            "in descending order of second element " <<
            "of pairs of the second column, ";
    print(myContainer);
 
    return 0;
}

Caso 5: Clasificación de un vector 2D de pares en función del número de columnas en una fila en orden ascendente:

En este tipo de clasificación, un vector 2D de pares se clasifica en función de un número de la columna en orden ascendente. Esto se logra pasando un tercer argumento, una función de comparación personalizada al método «sort()».

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(8, 11)
(1, 6) (3, 2)                     

Salida:
(8, 11) 
(1, 6) (3, 2)
(4, 1) (1, 9) (7, 2)

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting a 2D vector or
// vector of vectors of pairs in
// descending order of number of
// columns in a row
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1.size() < vector2.size();
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}, {16, 18}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
    vector<pair<int, int> > vect5 =
    {{7, 2}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
    myContainer.push_back(vect5);
 
    // Print the vector elements
    // before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting the 2D vector of pairs
    // in ascending order
    // of number of columns in a row
    sort(myContainer.begin(),
         myContainer.end(), myComparator);
 
    cout << "\n\n After sorting the 2D vector " <<
            "in ascending order of the number of " <<
            "columns in a row, ";
    print(myContainer);
 
    return 0;
}

Caso 6: Clasificación de un vector 2D de pares en función del número de columnas en una fila en orden descendente:

En este tipo de clasificación, un vector 2D se clasifica en función del número de columnas en orden descendente. Esto se logra pasando un tercer argumento, un comparador personalizado al método “sort()”.

Ejemplo:

Entrada:
(4, 1) (1, 9) (7, 2)
(8, 11)
(1, 6) (3, 2)                               

Salida:
(4, 1) (1, 9) (7, 2)
(1, 6) (3, 2)
(8, 11)  

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to demonstrate the
// working of sorting a 2D vector or
// vector of vectors of pairs in
// descending order of number of
// columns in a row
 
#include <bits/stdc++.h>
using namespace std;
 
// Custom comparator function
bool myComparator(vector<pair<int, int> >& vector1,
                  vector<pair<int, int> >& vector2)
{
    return vector1.size() > vector2.size();
}
 
// Function to print 2D vector elements
void print(vector<vector<pair<int, int> > >
           & myContainer)
{
 
    // Iterating over 2D vector elements
    for (auto currentVector : myContainer)
    {
        // Each element of the 2D vector is
        // a vector itself
        vector<pair<int, int> > myVector =
                                currentVector;
 
        // Iterating over the vector
        // elements
        cout << "[  ";
        for (auto pr : myVector)
        {
            // Print the element
            cout << "{";
            cout << pr.first << ", " <<
                    pr.second;
            cout << "}  ";
        }
        cout << "]\n";
    }
}
 
// Driver code
int main()
{
    // Declaring a 2D vector of pairs
    // Pairs are of type {char, bool}
    vector<vector<pair<int, int> > > myContainer;
 
    // Initializing vectors of pairs
    vector<pair<int, int> > vect1 =
    {{2, 1}, {4, 3}, {8, 1}};
    vector<pair<int, int> > vect2 =
    {{19, 10}, {11, 2}, {12, 14}, {14, 6}, {16, 18}};
    vector<pair<int, int> > vect3 =
    {{17, 18}, {19, 20}};
    vector<pair<int, int> > vect4 =
    {{25, 26}, {27, 28}, {29, 30}, {31, 32}};
    vector<pair<int, int> > vect5 = {{7, 2}};
 
    // Inserting vectors in the 2D vector
    myContainer.push_back(vect1);
    myContainer.push_back(vect2);
    myContainer.push_back(vect3);
    myContainer.push_back(vect4);
    myContainer.push_back(vect5);
 
    // Print the vector elements
    // before sorting
    cout << "Before sorting, ";
    print(myContainer);
 
    // Sorting the first row of 2D
    // vector of pairs in descending
    // order of the first element of pairs
    sort(myContainer.begin(),
         myContainer.end(), myComparator);
 
    cout << "\n\n After sorting the 2D vector " <<
            "in descending order of the number " <<
            "of columns in a row, ";
    print(myContainer);
 
    return 0;
}