¿Qué es Deque?
En C++ , un deque es un contenedor de secuencias y también se conoce con el nombre de cola de dos extremos. Como su nombre lo indica, un deque permite la inserción y eliminación desde ambos extremos. Aunque un deque es similar a un vector, los deques son más eficientes en comparación con los vectores. En los vectores, se garantiza la asignación de almacenamiento contiguo, pero este podría no ser el caso con deques. Deque es el caso especial de una cola ya que las operaciones de inserción y eliminación están permitidas en ambos extremos.
Funciones asociadas con un deque:
- push_front() : Se usa para empujar elementos en el contenedor desde el frente.
- push_back() : Se usa para empujar elementos en el contenedor desde atrás.
- front() : Usado para referirse al primer elemento del contenedor.
- back() : Se usa para referirse al último elemento del contenedor.
¿Qué es una Tupla?
Una tupla en C++ es un objeto que se utiliza para agrupar elementos. En una tupla, los elementos pueden ser del mismo tipo de datos o diferentes tipos de datos. Los elementos de las tuplas se inicializan en el orden en que se accederá a ellos.
Funciones asociadas a una tupla:
make_tuple() : make_tuple() se usa para asignar tupla con valores. Los valores pasados deben estar en orden con los valores declarados en la tupla.2. get(): get() se utiliza para acceder a los valores de la tupla y modificarlos, acepta el índice y el nombre de la tupla como argumentos para acceder a un elemento de la tupla en particular.
¿Cómo acceder a una Tupla?
Para acceder a los elementos de una tupla, utilice la función get<>().
Sintaxis:
auto fistElement = get<0>(myTuple);
auto secondElement = get<1>(myTuple);
auto tercerElemento = get<2>(myTuple);
Este artículo se centra en cómo crear un vector 2D de tuplas en C++.
deque de tuplas
Deque de tuplas es un contenedor deque en el que cada elemento es una tupla por sí mismo. Aunque una tupla puede contener más o menos elementos por simplicidad, hemos considerado tuplas de tres elementos solamente.
Sintaxis:
deque<tupla<tipo de datos1, tipo de datos2, tipo de datos3>> myContainer;
Aquí,
dataType1, dataType2 y dataType3 pueden ser tipos de datos similares o diferentes
Ejemplo 1: A continuación se muestra el programa C++ para implementar el deque de tuplas.
C++
// C++ program to demonstrate
// the working of deque
// of tuples
#include <bits/stdc++.h>
using namespace std;
// Function to print deque elements
void print(deque<tuple<string,
int, bool> >& myContainer)
{
cout << "myContainer elements: \n\n";
for (auto currentTuple : myContainer)
{
// Each element of the deque is
// a tuple itself
tuple<string, int, bool> tp =
currentTuple;
cout << "[ ";
// Printing tuple elements
cout << get<0>(tp) << ', ' <<
get<1>(tp) << ', ' <<
get<2>(tp);
cout << ']';
cout << '\n';
}
}
// Driver code
int main()
{
// Declaring a deque of tuples
// of type {string, int, bool}
deque<tuple<string, int, bool> >
myContainer;
// Declaring a tuple
tuple<string, int, bool> tuple1;
// Initializing the
// tuple
tuple1 = make_tuple("GeeksforGeeks",
22, true);
// Push the tuple at the front
// in the deque
myContainer.push_front(tuple1);
// Declaring another tuple
tuple<string, int, bool> tuple2;
// Initializing the
// tuple
tuple2 = make_tuple("GFG",
33, false);
// Push the tuple at the back
// in the deque
myContainer.push_back(tuple2);
// Declaring another tuple
tuple<string, int, bool> tuple3;
// Initializing the tuple
tuple3 = make_tuple("Java",
11, true);
// Push the tuple at the front
// in the deque
myContainer.push_front(tuple3);
// Declaring another tuple
tuple<string, int, bool> tuple4;
// Initializing the tuple
tuple4 = make_tuple("Python",
44, false);
// Push the tuple at the back
// in the deque
myContainer.push_back(tuple4);
// Calling print function
print(myContainer);
return 0;
}
myContainer elements: [ Java, 11, 1] [ GeeksforGeeks, 22, 1] [ GFG, 33, 0] [ Python, 44, 0]
Ejemplo 2: A continuación se muestra el programa C++ para implementar deque de tuplas.
C++
// C++ program to demonstrate
// the working of deque
// of tuples
#include <bits/stdc++.h>
using namespace std;
// Function to print deque elements
void print(deque<tuple<string,
float, bool> >& myContainer)
{
cout << "myContainer elements: \n\n";
for (auto currentTuple : myContainer)
{
// Each element of the deque is
// a tuple itself
tuple<string, float, bool> tp =
currentTuple;
cout << "[ ";
// Printing tuple elements
cout << get<0>(tp) << ', ' <<
get<1>(tp) << ', ' <<
get<2>(tp);
cout << ']';
cout << '\n';
}
}
// Driver code
int main()
{
// Declaring a deque of tuples
// of type {string, float, bool}
deque<tuple<string, float, bool> >
myContainer;
// Declaring a tuple
tuple<string, float, bool> tuple1;
// Initializing the
// tuple
tuple1 = make_tuple("GeeksforGeeks",
2.123, false);
// Push the tuple at the front
// in the deque
myContainer.push_front(tuple1);
// Declaring another tuple
tuple<string, float, bool> tuple2;
// Initializing the
// tuple
tuple2 = make_tuple("GFG",
3.123, false);
// Push the tuple at the back
// in the deque
myContainer.push_back(tuple2);
// Declaring another tuple
tuple<string, float, bool> tuple3;
// Initializing the tuple
tuple3 = make_tuple("Java",
1.123, true);
// Push the tuple at the front
// in the deque
myContainer.push_front(tuple3);
// Declaring another tuple
tuple<string, float, bool> tuple4;
// Initializing the tuple
tuple4 = make_tuple("Python",
4.123, true);
// Push the tuple at the back
// in the deque
myContainer.push_back(tuple4);
// Calling print function
print(myContainer);
return 0;
}
myContainer elements: [ Java, 1.123, 1] [ GeeksforGeeks, 2.123, 0] [ GFG, 3.123, 0] [ Python, 4.123, 1]
Comparando elementos de deques de tuplas
Esta sección se centra en comparar los elementos de dos deques de tuplas. Los elementos de dos deques de tuplas se pueden comparar iterando sobre ambos deques.
Ejemplo: En el siguiente programa hemos creado dos deques de tuplas. Las tuplas son de tipo {int, char, bool}. Estamos comparando ambos deques elemento por elemento usando una función de comparación. Tenga en cuenta que cada elemento de ambos deques es una tupla en sí mismo y dos tuplas se consideran iguales si y si los objetos de datos correspondientes de las tuplas son iguales.
C++
// C++ program to demonstrate
// comparing of two deque
// of tuples
#include <bits/stdc++.h>
using namespace std;
// Function to compare deque elements
bool compare(deque<tuple<int, char,
bool> >& myContainer1,
deque<tuple<int, char,
bool> >& myContainer2)
{
// If deques are of unequal size
if (myContainer1.size() !=
myContainer2.size())
return false;
// Iterators
// Initially pointing to the first elements
auto it1 = myContainer1.begin();
auto it2 = myContainer2.begin();
while (it1 != myContainer1.end() &&
it2 != myContainer2.end())
{
// Each element of the deque is
// a tuple itself
tuple<int, char, bool> tp1 = (*it1);
tuple<int, char, bool> tp2 = (*it2);
// Comparing corresponding tuples
if (get<0>(tp1) != get<0>(tp2) ||
get<1>(tp1) != get<1>(tp2) ||
get<2>(tp1) != get<2>(tp2))
return false;
it1++;
it2++;
}
return true;
}
// Driver code
int main()
{
// Declaring a deque of tuples
// of type {int, char, bool}
deque<tuple<int, char, bool> >
myContainer1;
// Declaring a tuple
tuple<int, char, bool> tuple1;
// Initializing the
// tuple
tuple1 = make_tuple(10, 'g',
false);
// Push the tuple at the front
// in the deque
myContainer1.push_front(tuple1);
// Declaring another tuple
tuple<int, char, bool> tuple2;
// Initializing the
// tuple
tuple2 = make_tuple(20, 'd',
false);
// Push the tuple at the back
// in the deque
myContainer1.push_back(tuple2);
// Declaring another tuple
tuple<int, char, bool> tuple3;
// Initializing the tuple
tuple3 = make_tuple(30, 'a',
true);
// Push the tuple at the front
// in the deque
myContainer1.push_front(tuple3);
// Declaring another tuple
tuple<int, char, bool> tuple4;
// Initializing the tuple
tuple4 = make_tuple(40, 'k',
true);
// Push the tuple at the back
// in the deque
myContainer1.push_back(tuple4);
// Declaring another deque of tuples
// of type {int, char, bool}
deque<tuple<int, char, bool> >
myContainer2;
// Push the tuple at the front
// in the deque
myContainer2.push_front(tuple1);
// Push the tuple at the back
// in the deque
myContainer2.push_back(tuple2);
// Push the tuple at the front
// in the deque
myContainer2.push_front(tuple3);
// Push the tuple at the back
// in the deque
myContainer2.push_back(tuple4);
// Declaring another deque of tuples
// of type {int, char, bool}
deque<tuple<int, char, bool> >
myContainer3;
// Declaring a tuple
tuple<int, char, bool> tuple5;
tuple5 = make_tuple(1, 'a',
true);
// Push the tuple at the front
// in the deque
myContainer3.push_front(tuple1);
// Push the tuple at the back
// in the deque
myContainer3.push_back(tuple2);
// Push the tuple at the front
// in the deque
myContainer3.push_front(tuple3);
// Push the tuple at the back
// in the deque
myContainer3.push_back(tuple5);
// Calling compare function
if (compare(myContainer1, myContainer2))
cout <<
"myContainer1 and myContainer2 are equal.";
else
cout << "myContainer1 and " <<
"myContainer2 are not equal.";
cout << '\n';
// Calling compare function
if (compare(myContainer1, myContainer3))
cout << "myContainer1 and " <<
"myContainer3 are equal.";
else
cout << "myContainer1 and " <<
"myContainer3 are not equal.";
cout << '\n';
// Calling compare function
if (compare(myContainer2, myContainer3))
cout << "myContainer2 and " <<
"myContainer3 are equal.";
else
cout << "myContainer2 and " <<
"myContainer3 are not equal.";
return 0;
}
myContainer1 and myContainer2 are equal. myContainer1 and myContainer3 are not equal. myContainer2 and myContainer3 are not equal.