Ordenar un vector 2D en C ++

C ++ STL | Ordenar un vector 2D : En este artículo, vamos a discutir cómo ordenar un vector basado en 2D en muchos casos de uso con ejemplos?

según como un vector 2D se refiere a que es un vector de un vector 1D. Pero lo que hacemos en la clasificación de un vector como 1D,

sort(vector.begin(),vector.end());

No podemos hacer lo mismo class un vector 2D sin ningún tipo de función de comparación definida por el usuario, ya que será más que una especie basado en el primer elemento de cada columna.

Pero podemos clasificar vectorial 2D basado en casos de uso:

1) Ordenar basado en una fila en particular

El ejemplo a continuación ordena una fila en particular en el vector 2D.

ejemplo Say class, la matriz 2D es:

[[3, 5, 4],
[6, 4, 2],
[1, 7, 3]]

Así que si clasificamos la primera fila en orden ascendente la salida será:

[[3, 4, 5],
[6, 4, 2],
[1, 7, 3]]

#include <bits/stdc++.h>
using namespace std;
void print(vector<vector<int> > two_D_vector)
{
for (auto it : two_D_vector) {
//it is now an 1D vector
for (auto ij : it) {
cout << ij << " ";
}
cout << endl;
}
}
int main()
{
//2D vector initialized with
//user-defined elements only
vector<vector<int> > two_D_vector{
{ 3, 5, 4 },
{ 6, 4, 2 },
{ 1, 7, 3 }
};
//printing the 2D vector
cout << "printing the 2D vector before sortingn";
print(two_D_vector);
//sorting the 2D array based on a particular row
//here we sort the first row of the 2D vector
//so, basically we sort the 1D array(the first row)
sort(two_D_vector[0].begin(), two_D_vector[0].end());
//print the 2D vector
cout << "printing the 2D vector after sortingn";
print(two_D_vector);
return 0;
}

Salida:

printing the 2D vector before sorting
3 5 4
6 4 2
1 7 3
printing the 2D vector after sorting
3 4 5
6 4 2
1 7 3

Así que si que tipo de la primera fila en orden descendente la salida será:

[[3, 5, 4],
[6, 4, 2],
[7, 3, 1]]

#include <bits/stdc++.h>
using namespace std;
void print(vector<vector<int> > two_D_vector)
{
for (auto it : two_D_vector) {
//it is now an 1D vector
for (auto ij : it) {
cout << ij << " ";
}
cout << endl;
}
}
int main()
{
//2D vector initialized with
//user-defined elements only
vector<vector<int> > two_D_vector{
{ 3, 5, 4 },
{ 6, 4, 2 },
{ 1, 7, 3 }
};
//printing the 2D vector
cout << "printing the 2D vector before sortingn";
print(two_D_vector);
//sorting the 2D array based on a particular row
//here we sort the last row of the 2D vector
//in descending order
//so, basically we sort the 1D array in
//descending order(the last row)
sort(two_D_vector[2].begin(), two_D_vector[2].end(), greater<int>());
//print the 2D vector
cout << "printing the 2D vector after sortingn";
print(two_D_vector);
return 0;
}

salida:

printing the 2D vector before sorting
3 5 4
6 4 2
1 7 3
printing the 2D vector after sorting
3 5 4
6 4 2
7 3 1

2) Ordenar basado en una columna en particular

el ejemplo abajo ordena una columna en particular en el 2D vector.

ejemplo Say for, la matriz 2D es:

[[3, 5, 4],
[6, 4, 2],
[1, 7, 3]]

Así que si clasificamos la primera columna en orden ascendente la salida será:

[[1, 4, 5],
[3, 4, 2],
[6, 7, 3]]

Aquí tenemos que definir nuestra función de comparación definida por el usuario que hacer lo anterior. Como vamos a tomar cada elemento del vector 2D (que es un vector 1D, para ser específicos de cada fila) y comparar en base al primer elemento (o cualquier elemento particular) solamente. Es por eso que necesitamos un comparador definida por el usuario.

#include <bits/stdc++.h>
using namespace std;
void print(vector<vector<int> > two_D_vector)
{
for (auto it : two_D_vector) {
//it is now an 1D vector
for (auto ij : it) {
cout << ij << " ";
}
cout << endl;
}
}
bool mycomp(vector<int>& A, vector<int>& B)
{
//if first element of first
//row<first element of second row
if (A[0] < B[0])
return true; //no swap
//other wise swap the rows
return false;
}
int main()
{
//2D vector initialized with
//user-defined elements only
vector<vector<int> > two_D_vector{
{ 3, 5, 4 },
{ 6, 4, 2 },
{ 1, 7, 3 }
};
//printing the 2D vector
cout << "printing the 2D vector before sortingn";
print(two_D_vector);
//sorting the 2D array based on a particular row
//here we sort the last row of the 2D vector
//in descending order
//so, basically we sort the 1D array in
//descending order(the last row)
sort(two_D_vector.begin(), two_D_vector.end(), mycomp);
//print the 2D vector
cout << "printing the 2D vector after sortingn";
print(two_D_vector);
return 0;
}

Salida:

printing the 2D vector before sorting
3 5 4
6 4 2
1 7 3
printing the 2D vector after sorting
1 7 3
3 5 4
6 4 2

para ordenar en orden descendente, tenemos que acaba de cambiar la función de comparación.

#include <bits/stdc++.h>
using namespace std;
void print(vector<vector<int> > two_D_vector)
{
for (auto it : two_D_vector) {
//it is now an 1D vector
for (auto ij : it) {
cout << ij << " ";
}
cout << endl;
}
}
//to sort based on column in descending order
bool mycomp(vector<int>& A, vector<int>& B)
{
//if first element of first
//row<first element of second row
if (A[0] < B[0])
return false; //swap the rows
//other wise no swap
return true;
}
int main()
{
//2D vector initialized with
//user-defined elements only
vector<vector<int> > two_D_vector{
{ 3, 5, 4 },
{ 6, 4, 2 },
{ 1, 7, 3 }
};
//printing the 2D vector
cout << "printing the 2D vector before sortingn";
print(two_D_vector);
//sorting the 2D array based on a particular row
//here we sort the last row of the 2D vector
//in descending order
//so, basically we sort the 1D array in
//descending order(the last row)
sort(two_D_vector.begin(), two_D_vector.end(), mycomp);
//print the 2D vector
cout << "printing the 2D vector after sortingn";
print(two_D_vector);
return 0;
}

Salida:

printing the 2D vector before sorting
3 5 4
6 4 2
1 7 3
printing the 2D vector after sorting
6 4 2
3 5 4
1 7 3

No puede haber varios casos de uso para ordenar un vector 2D y tenemos que escribir nuestras funciones de comparación.

Ejercicios

(a) Ordenar basado en tamaños de fila en orden ascendente

Say the 2D vector is
{
{2, 3, 4, 5},
{3, 4, 1},
{1}}
After sorting the 2D vector based on
row size in ascending order:
{
{1},
{3, 4, 1},
{2, 3, 4, 5}
}

Aquí tenemos que utilizar nuestro usuario definir una función que intercambiar las filas de acuerdo a sus tamaños.

#include <bits/stdc++.h>
using namespace std;
void print(vector<vector<int> > two_D_vector)
{
for (auto it : two_D_vector) {
//it is now an 1D vector
for (auto ij : it) {
cout << ij << " ";
}
cout << endl;
}
}
//to sort based on column in descending order
bool mycomp(vector<int>& A, vector<int>& B)
{
//if first row size>second row size
if (A.size() > B.size())
return false; //swap the rows
//other wise no swap
return true;
}
int main()
{
//2D vector initialized with
//use- defined elements only
vector<vector<int> > two_D_vector{
{ 2, 3, 4, 5 },
{ 3, 4, 1 },
{ 1 }
};
//printing the 2D vector
cout << "printing the 2D vector before sortingn";
print(two_D_vector);
//sorting the 2D array based on a particular row
//here we sort the last row of the 2D vector
//in descending order
//so, basically we sort the 1D array in
//descending order(the last row)
sort(two_D_vector.begin(), two_D_vector.end(), mycomp);
//print the 2D vector
cout << "printing the 2D vector after sortingn";
print(two_D_vector);
return 0;
}

Salida:

printing the 2D vector before sorting
2 3 4 5
3 4 1
1
printing the 2D vector after sorting
1
3 4 1
2 3 4 5

(b) ¿Se puede ordenar en función del tamaño de columna de todos modos?

Si no se puede ordenar de esa manera, y luego hacer comentario ¿Por qué no puedes?


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *