Documentación

Estructuras de datos

Array

array<int> nums;
int[] nums;

array es un contenedor que encapsula matrices de tamaño fijo.

Este contenedor es un tipo agregado con la misma semántica que un struct que
contiene un array estilo C T[N] como único miembro de datos no estático. A
diferencia de una matriz estilo C, no decae a T* automáticamente. Como tipo
agregado, puede ser inicializado con inicialización-agregada dado un máximo de N
inicializadores que son convertibles a T: std::array<int, 3> a = {1,2,3};

Methods and non-member functions

at: El método at se utiliza para acceder a un elemento específico en un array

mediante su índice. A diferencia del operador de corchetes [], el método at realiza
una verificación de límites y lanza una excepción std::out_of_range si el índice está
fuera del rango válido.

back: El método back se utiliza para acceder al último elemento de un array. Es

similar a array[size-1], donde size es el tamaño del array.

front: El método front se utiliza para acceder al primer elemento de un array. Es

similar a array[0].

data: El método data se utiliza para obtener un puntero al primer elemento del array.
Puede ser útil cuando se necesita pasar el array a una función que espera un
puntero.

begin: El método begin se utiliza para obtener un iterador que apunta al primer
elemento del array. Los iteradores se utilizan para recorrer los elementos de un
contenedor en C++. Puedes usar el iterador devuelto por begin en un bucle para
acceder a todos los elementos del array.

end: El método end se utiliza para obtener un iterador que apunta al elemento
siguiente al último elemento del array. Este iterador marca el final del rango válido
de elementos en el array. Al igual que con begin, puedes usar el iterador devuelto
por end en un bucle para recorrer todos los elementos del array.

empty: El método empty se utiliza para verificar si el array está vacío. Devuelve true
si el array no contiene elementos y false en caso contrario.
size: El método size se utiliza para obtener el número de elementos en el array.
Devuelve un valor entero que representa la cantidad de elementos presentes en el
array.

max_size: El método max_size se utiliza para obtener el número máximo de

elementos que el array puede contener. Devuelve un valor entero que representa la
capacidad máxima del array.

fill: El método fill se utiliza para asignar un valor específico a todos los elementos del
array. Toma un valor como argumento y asigna ese valor a cada elemento del array.

swap: El método swap se utiliza para intercambiar el contenido de dos arrays del
mismo tipo y tamaño. Los arrays deben ser del mismo tipo y tener el mismo tamaño
para que el intercambio sea válido.

get: No existe un método get específico en los arrays en C++. Sin embargo, puedes
acceder a los elementos de un array utilizando el operador de corchetes []. Por
ejemplo, myArray[0] devuelve el primer elemento del array myArray.

Vector

vector<int> nums;

vector es un contenedor de secuencias que encapsula matrices de tamaño

dinámico.
vector es una plantilla de alias que utiliza un asignador polimórfico.
Los elementos se almacenan de forma contigua, lo que significa que se puede
acceder a los elementos no sólo a través de iteradores, sino también utilizando
offsets a punteros regulares a elementos. Esto significa que un puntero a un
elemento de un vector puede pasarse a cualquier función que espere un puntero a
un elemento de un array.
El almacenamiento del vector se gestiona automáticamente, ampliándose según sea
necesario. Los vectores suelen ocupar más espacio que las matrices estáticas,
porque se asigna más memoria para gestionar el crecimiento futuro. De este modo,
un vector no necesita reasignarse cada vez que se inserta un elemento, sino sólo
cuando se agota la memoria adicional. La cantidad total de memoria asignada
puede consultarse utilizando la función capacity(). La memoria adicional puede
devolverse al sistema mediante una llamada a shrink_to_fit().

Methods and non-member functions

at: El método at se utiliza para acceder a un elemento específico en un vector

mediante su índice. A diferencia del operador de corchetes [], el método at realiza
una verificación de límites y lanza una excepción std::out_of_range si el índice está
fuera del rango válido.

back: El método back se utiliza para acceder al último elemento de un vector. Es

similar a vector[size-1], donde size es el tamaño del vector.

front: El método front se utiliza para acceder al primer elemento de un vector. Es

similar a vector[0].

data: El método data se utiliza para obtener un puntero al primer elemento del
vector. Puede ser útil cuando se necesita pasar el vector a una función que espera
un puntero.

begin: El método begin se utiliza para obtener un iterador que apunta al primer
elemento del vector. Los iteradores se utilizan para recorrer los elementos de un
contenedor en C++. Puedes usar el iterador devuelto por begin en un bucle para
acceder a todos los elementos del vector.

end: El método end se utiliza para obtener un iterador que apunta al elemento
siguiente al último elemento del vector. Este iterador marca el final del rango válido
de elementos en el vector. Al igual que con begin, puedes usar el iterador devuelto
por end en un bucle para recorrer todos los elementos del vector.

empty: El método empty se utiliza para verificar si el vector está vacío. Devuelve
true si el vector no contiene elementos y false en caso contrario.

size: El método size se utiliza para obtener el número de elementos en el vector.

Devuelve un valor entero que representa la cantidad de elementos presentes en el
vector.

max_size: El método max_size se utiliza para obtener el número máximo de

elementos que el vector puede contener. Devuelve un valor entero que representa la
capacidad máxima del vector.
reverse: El método reverse se utiliza para invertir el orden de los elementos en el
vector.

capacity: El método capacity se utiliza para obtener la capacidad actual del vector,
es decir, el número máximo de elementos que puede contener sin necesidad de
asignar más memoria.

shrink_to_fit: El método shrink_to_fit se utiliza para reducir la capacidad del vector

para que coincida con su tamaño actual. Esto puede ser útil para liberar memoria
adicional que no se está utilizando.

clear: El método clear se utiliza para eliminar todos los elementos del vector,
dejándolo vacío.

insert: El método insert se utiliza para insertar elementos en una posición específica
del vector. Puede tomar diferentes formas de argumentos, como un iterador y un
valor, o un rango de elementos.

emplace: El método emplace se utiliza para construir e insertar un elemento en una

posición específica del vector utilizando argumentos pasados directamente al
constructor del elemento.

erase: El método erase se utiliza para eliminar elementos de una posición específica
o un rango de posiciones del vector.

push_back: El método push_back se utiliza para agregar un elemento al final del

vector.

emplace_back: El método emplace_back se utiliza para construir e insertar un

elemento al final del vector utilizando argumentos pasados directamente al
constructor del elemento.

pop_back: El método pop_back se utiliza para eliminar el último elemento del vector.

resize: El método resize se utiliza para cambiar el tamaño del vector. Puede tomar
diferentes formas de argumentos, como un nuevo tamaño y un valor opcional para
inicializar los nuevos elementos.

swap: El método swap se utiliza para intercambiar el contenido de dos vectores del
mismo tipo y tamaño. Los vectores deben ser del mismo tipo y tener el mismo
tamaño para que el intercambio sea válido.
List

list<int> mi_lista;

list es un contenedor que admite la inserción y extracción en tiempo constante de

elementos de cualquier parte del contenedor. No admite el acceso aleatorio rápido.
Normalmente se implementa como una lista doblemente enlazada. En comparación
con forward_list, este contenedor ofrece la posibilidad de iteración bidireccional,
pero ocupa menos espacio.

Añadir, eliminar y mover los elementos dentro de la lista o a través de varias listas
no invalida los iteradores o referencias. Un iterador sólo se invalida cuando se
elimina el elemento correspondiente.

Methods and non-member functions

push_back y push_front : Estos métodos se utilizan para insertar elementos al final y

al principio de la lista, respectivamente.

list<int> mi_lista;
mi_lista.push_back(10); // Insertar al final de la lista
mi_lista.push_front(5); // Insertar al principio de la lista

pop_back y pop_front: Estos métodos se utilizan para eliminar el último y el primer

elemento de la lista, respectivamente.

list<int> mi_lista;
mi_lista.push_back(10);
mi_lista.push_front(5);

mi_lista.pop_back(); // Eliminar el último elemento de la lista (10)

mi_lista.pop_front(); // Eliminar el primer elemento de la lista (5)

insert: Este método se utiliza para insertar un elemento en una posición específica
de la lista.

list<int> mi_lista;
mi_lista.push_back(10);
mi_lista.push_back(20);
 mi_lista.push_back(30);

list<int>::iterator it = mi_lista.begin();
advance(it, 1); // Avanzar el iterador a la posición deseada

mi_lista.erase(it); // Eliminar el elemento en la posición 1 de la lista

size: Este método se utiliza para obtener el tamaño (cantidad de elementos) de la

lista.

list<int> mi_lista;
mi_lista.push_back(10);
mi_lista.push_back(20);
mi_lista.push_back(30);

cout << "Tamaño de la lista: " << mi_lista.size() << std::endl; // Imprimir el
tamaño de la lista (3)

empty: Este método se utiliza para verificar si la lista está vacía.

lista.empty();

clear: Este método se utiliza para eliminar todos los elementos de la lista.

lista.clear();

begin y end: Estos métodos se utilizan para obtener iteradores que apuntan al
primer y último elemento de la lista, respectivamente.

list<int>::iterator it_begin = lista.begin();

list<int>::iterator it_end = lista.end();

reverse: Este método se utiliza para invertir el orden de los elementos en la lista.

lista.reverse();

sort: Este método se utiliza para ordenar los elementos de la lista en orden
ascendente.

lista.sort();
merge: Esta operación combina dos listas ordenadas en una sola lista ordenada.
Los elementos de ambas listas se insertan en la lista resultante de manera que se
mantenga el orden ascendente.

lista1.merge(lista2);

splice : Esta operación permite transferir elementos de una lista a otra lista en una
posición específica . Puede transferir un solo elemento, un rango de elementos o
incluso la lista completa.

list<int>::iterator it = lista1.begin();
advance(it, 2);

lista1.splice(it, lista2);

remove : Esta operación elimina todos los elementos de una lista que coinciden con
un valor específico.

lista.remove(2);

unique : Esta operación elimina los elementos duplicados consecutivos de una lista.
Solo se mantiene una instancia de cada elemento.

lista.unique();

resize: Este método se utiliza para cambiar el tamaño de una lista. Puedes
especificar el nuevo tamaño y, opcionalmente, el valor con el que se deben
inicializar los nuevos elementos.

lista.resize(5);

emplace: Este método se utiliza para insertar un elemento en una posición

específica de la lista. En lugar de utilizar push_back o push_front, emplace
construye el elemento directamente en la lista utilizando los argumentos
proporcionados.

list<Persona> lista;

lista.emplace(lista.begin(), "Juan", 25); // Insertar al inicio de la lista

lista.emplace(lista.end(), "María", 30); // Insertar al final de la lista
emplace_back: Este método se utiliza para insertar un elemento al final de la lista. Al
igual que emplace, construye el elemento directamente en la lista utilizando los
argumentos proporcionados.

emplace_front: Este método se utiliza para insertar un elemento al inicio de la lista.

Al igual que emplace, construye el elemento directamente en la lista utilizando los
argumentos proporcionados

lista.emplace_front("Juan", 25); // Insertar al inicio de la lista

lista.emplace_back("María", 30); // Insertar al final de la lista

max_size: Este método devuelve el número máximo de elementos que la lista puede
contener.

lista.max_size()

back: Este método devuelve una referencia al último elemento de la lista.

lista.back()

front: Este método devuelve una referencia al primer elemento de la lista.

lista.front()

Pair

pair<int, int> coordinate;

pair es una plantilla de clase que proporciona una forma de almacenar dos objetos
heterogéneos como una sola unidad. Un par es un caso específico de una tupla
std::con dos elementos. Donde T1 y T2 son los tipos de los elementos que se
desean almacenar juntos.

Si ni T1 ni T2 son un tipo de clase posiblemente cualificado por cv con un destructor

no trivial, o un array de los mismos, el destructor de pair es trivial
Member objects

Member name Type

first T1

second T2

Para acceder a los elementos individuales de un objeto "pair", se puede utilizar la

función first para acceder al primer elemento y la función second para acceder al
segundo elemento. Por ejemplo:

coordinate.first = 0;

coordinate.second = 10;

Methods and non-member functions

make_pair Este método se utiliza pair<int, string>

para crear un nuevo par nuevo_par =
con los valores make_pair(20,
especificados. "Mundo");

operator== Compara if (par1 == par2) {

operator!= lexicográficamente los // Los pares son
operator< valores del par iguales
operator<= } else {
operator> // Los pares son
operator>= diferentes
operator<=> }

swap Este método se utiliza pair<int, string>

para intercambiar el par1(10, "Hola");
contenido de dos pares pair<int, string>
par2(20, "Mundo");

par1.swap(par2);

// Ahora par1 tiene el

valor (20, "Mundo") y
par2 tiene el valor (10,
 "Hola")

get Accede a un elemento de pair<int, string>

un par mi_par(10, "Hola");

int primer_elemento =
get<0>(mi_par); //
Acceder al primer
elemento (10)
string
segundo_elemento =
get<1>(mi_par); //
Acceder al segundo
elemento ("Hola")

Tuple

tuple<int, int> coordinate;

tuple es una colección de valores heterogéneos de tamaño fijo. Es una

generalización de std::pair.
Si std::is_trivially_destructible<Ti>::value es verdadero para cada Ti en Types, el
destructor de tupla es trivial.

Methods and non-member functions

get: El método get se utiliza para acceder a los elementos de una tupla mediante su
índice. Por ejemplo, std::get<0>(myTuple) devuelve el elemento en la posición 0 de
la tupla myTuple.

tie: El método tie se utiliza para desempaquetar los elementos de una tupla en
variables individuales. Por ejemplo, std::tie(myInt, myString, myDouble) = myTuple
asigna los elementos de myTuple a las variables myInt, myString y myDouble.

make_tuple: El método make_tuple se utiliza para crear una nueva tupla con los
valores proporcionados . Por ejemplo, std::make_tuple(1, "dos", 3.14) crea una tupla
con los valores 1, "dos" y 3.14.
tuple_size: El método tuple_size se utiliza para obtener el tamaño de una tupla. Por
ejemplo, std::tuple_size<decltype(myTuple)>::value devuelve el tamaño de la tupla
myTuple.

tuple_element: El método tuple_element se utiliza para obtener el tipo de un

elemento en una tupla. Por ejemplo, std::tuple_element<1, decltype(myTuple)>::type
devuelve el tipo del elemento en la posición 1 de la tupla myTuple.

Set

set<int, int> conjunto;

set es un contenedor asociativo que contiene un conjunto ordenado de objetos

únicos de tipo Clave. La ordenación se realiza mediante la función de comparación
de claves Compare. Las operaciones de búsqueda, eliminación e inserción tienen
una complejidad logarítmica. Los conjuntos suelen implementarse como árboles
rojo-negro.

Methods and non-member functions

begin y end: Estos métodos devuelven iteradores que apuntan al primer y último
elemento del conjunto, respectivamente.

conjunto.begin();
conjunto.end();

empty y size: Estos métodos devuelven un valor booleano que indica si el conjunto
está vacío y el número de elementos en el conjunto, respectivamente.

conjunto.empty()
conjunto.size()

max_size: Este método devuelve el número máximo de elementos que el conjunto

puede contener.

conjunto.max_size()
clear: Este método elimina todos los elementos del conjunto.

conjunto.clear();

insert: Este método inserta un elemento en el conjunto.

conjunto.insert(4);

emplace y emplace_hint: Estos métodos insertan un elemento en el conjunto

utilizando la construcción in-place.

set<Persona> conjunto;
// Utilizando emplace
conjunto.emplace("Juan", 25);

// Utilizando emplace_hint
auto hint = conjunto.end();
conjunto.emplace_hint(hint, "María", 30);

erase: Este método elimina un elemento del conjunto.

conjunto.erase(2);

swap: Este método intercambia el contenido de dos conjuntos.

conjunto1.swap(conjunto2);

extract: Este método extrae un elemento del conjunto y lo devuelve.

auto elementoExtraido = conjunto.extract(2);

cout << elementoExtraido.value();

merge: Este método fusiona dos conjuntos ordenados en uno solo.

conjunto1.merge(conjunto2);

count y find: Estos métodos se utilizan para buscar elementos en el conjunto.

if (conjunto.count(2) > 0) {}
auto it = conjunto.find(3);
if (it != conjunto.end()) {}

contains: Este método devuelve un valor booleano que indica si el conjunto contiene
un elemento específico.

if (conjunto.contains(2)) {}

equal_range: Este método devuelve un par de iteradores que representan el rango

de elementos equivalentes a un valor dado.

set<int> conjunto = {1, 2, 2, 3, 4};

auto rango = conjunto.equal_range(2);

cout << "Elementos equivalentes a 2: ";

for (auto it = rango.first; it != rango.second; ++it) {
cout << *it << " ";
}

lower_bound y upper_bound: Estos métodos devuelven iteradores que apuntan al

primer elemento mayor o igual y al primer elemento mayor a un valor dado,
respectivamente.

auto it1 = conjunto.lower_bound(3);

auto it2 = conjunto.upper_bound(3);
cout << "Elementos mayores o iguales a 3: ";
for (auto it = it1; it != conjunto.end(); ++it) {
cout << *it << " ";
}
cout << endl;
cout << "Elementos mayores a 3: ";
for (auto it = it2; it != conjunto.end(); ++it) {
cout << *it << " ";
}

erase_if: Este método elimina elementos del conjunto que cumplen cierta condición.

set<int> conjunto = {1, 2, 3, 4, 5};

conjunto.erase_if([](int elemento) { return elemento % 2 == 0; });

key_comp y value_comp: Estos métodos devuelven comparadores que se utilizan
para comparar claves y valores en el conjunto, respectivamente.

set<int> mySet = {1, 2, 3, 4, 5};

// Ejemplo de uso de key_comp

set<int>::key_compare keyComp = mySet.key_comp();
int highest = *(mySet.rbegin()); // Obtener el elemento más alto en el
conjunto

for (int i = 1; i <= highest; i++) {

if (keyComp(i, *mySet.begin())) {
cout << i << " es menor que " << *mySet.begin() << endl;
}
}

// Ejemplo de uso de value_comp

set<int>::value_compare valueComp = mySet.value_comp();
int target = 3;

for (const auto& element : mySet) {

if (valueComp(element, target)) {
cout << element << " es menor que " << target << endl;
}
}

Map

map<int, string> mapa;

map es un contenedor asociativo ordenado que contiene pares clave-valor con

claves únicas. Las claves se ordenan mediante la función de comparación Compare.
Las operaciones de búsqueda, eliminación e inserción tienen una complejidad
logarítmica. Los mapas suelen implementarse como árboles rojo-negro.

Methods and non-member functions

begin: devuelve un iterador al principio.

std::map<int, std::string>::iterator it_begin = mapa.begin();

end: devuelve un iterador hasta el final

std::map<int, std::string>::iterator it_end = mapa.end();

empty: comprueba si el contenedor está vacío

bool estaVacio = mapa.empty();

size: devuelve el número de elementos

mapa.size();

max_size: devuelve el número máximo posible de elementos

mapa.max_size();

clear: borra el contenido

mapa.clear();

insert: inserta elementos o nodos

mapa.insert(std::make_pair(1, "Uno"));

insert_or_assign: inserta un elemento o asigna al elemento actual si la clave ya

existe

mapa.insert_or_assign(4, "Nuevo Cuatro");

emplace: construye el elemento en su lugar

mapa.emplace(5, "Cinco");

emplace_hint: construye elementos in-place utilizando una sugerencia

std::map<int, std::string>::iterator hint = mapa.begin();

mapa.emplace_hint(hint, 6, "Seis");
try_emplace: inserta in-place si la clave no existe, no hace nada si la clave existe

mapa.try_emplace(7, "Siete");

erase: borra elementos

mapa.erase(4);

swap: intercambia el contenido

mapa.swap(otroMapa);

extract: extrae nodos del contenedor

otroMapa.extract(5).mapped();

merge: empalma nodos de otro contenedor

mapa1.merge(mapa2);

count: devuelve el número de elementos que coinciden con una clave específica

mapa1.count(6);

find: encuentra un elemento con una clave específica

mapa1.find(6);

contains: comprueba si el contenedor contiene un elemento con una clave

específica

mapa1.contains(6);

equal_range: devuelve el rango de elementos que coinciden con una clave

específica

mapa1.equal_range(6);
lower_bound: devuelve un iterador al primer elemento no menor que la clave dada

mapa1.lower_bound(6);

upper_bound: devuelve un iterador al primer elemento mayor que la clave dada

mapa1.upper_bound(6);

key_comp: devuelve la función que compara claves

mapa1.key_comp();

value_comp: devuelve la función que compara claves en objetos de tipo value_type

mapa1.value_comp();

Queue

queue<int> cola;

queue es un adaptador de contenedor que proporciona al programador la

funcionalidad de una cola, en concreto, una estructura de datos FIFO (primero en
entrar, primero en salir).

La plantilla de la clase actúa como una envoltura del contenedor subyacente - sólo
se proporciona un conjunto específico de funciones. La cola empuja los elementos
en la parte trasera del contenedor subyacente y los saca de la parte delantera.

Methods and non-member functions

back: El método back se utiliza para acceder al último elemento de la cola. No

modifica la cola.

front: El método front se utiliza para acceder al primer elemento de la cola. No

modifica la cola.
empty: El método empty se utiliza para verificar si la cola está vacía. Devuelve true
si la cola no contiene elementos y false en caso contrario.

size: El método size se utiliza para obtener el número de elementos en la cola.

Devuelve un valor entero que representa la cantidad de elementos presentes en la
cola.

emplace: El método emplace se utiliza para construir e insertar un elemento en la

parte posterior de la cola utilizando argumentos pasados directamente al constructor
del elemento.

std::queue<int> myQueue;
myQueue.emplace(42); // Inserta el elemento 42 en la parte posterior de la
cola

swap: El método swap se utiliza para intercambiar el contenido de dos colas del
mismo tipo y tamaño. Las colas deben ser del mismo tipo y tener el mismo tamaño
para que el intercambio sea válido.

std::queue<int> queue1;
std::queue<int> queue2;

// Realizar operaciones en las colas...

queue1.swap(queue2); // Intercambia el contenido de queue1 y queue2

push: El método push se utiliza para agregar un elemento a la parte posterior de la

cola.

std::queue<int> myQueue;
myQueue.push(42); // Agrega el elemento 42 a la parte posterior de la cola

pop: El método pop se utiliza para eliminar el elemento de la parte frontal de la cola.

std::queue<int> myQueue;
myQueue.push(42); // Agrega el elemento 42 a la parte posterior de la cola
myQueue.pop(); // Elimina el elemento de la parte frontal de la cola

Deque
 deque<int> partida;
deque (double-ended queue) es un contenedor secuencial indexado que permite la
inserción y eliminación rápidas tanto al principio como al final. Además, la inserción
y eliminación en cualquiera de los extremos de un deque nunca invalida los
punteros o referencias al resto de los elementos.

A diferencia de std::vector, los elementos de un deque no se almacenan de forma

contigua: las implementaciones típicas utilizan una secuencia de matrices de
tamaño fijo asignadas individualmente, con contabilidad adicional, lo que significa
que el acceso indexado a deque debe realizar dos desreferencias de punteros, en
comparación con el acceso indexado de vector que sólo realiza una.

Methods and non-member functions

erase: El método erase se utiliza para eliminar uno o varios elementos de un deque
en una posición específica o en un rango determinado.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.erase(myDeque.begin() + 2); // Elimina el elemento en la posición 2
(valor 3)

resize: El método resize se utiliza para cambiar el tamaño de un deque. Puede

aumentar o disminuir el tamaño del deque. Si se aumenta el tamaño, se agregan
elementos adicionales con un valor predeterminado. Si se reduce el tamaño, se
eliminan los elementos adicionales.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.resize(3); // Redimensiona el deque a un tamaño de 3, eliminando
los elementos adicionales

pop_front: El método pop_front se utiliza para eliminar el primer elemento de un

deque.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.pop_front(); // Elimina el primer elemento del deque (valor 1)

pop_back: El método pop_back se utiliza para eliminar el último elemento de un

deque.
std::deque<int> myDeque = {1, 2, 3, 4, 5};
myDeque.pop_back(); // Elimina el último elemento del deque (valor 5)

back: El método back se utiliza para acceder al último elemento de un deque. No

modifica el deque.

front: El método front se utiliza para acceder al primer elemento de un deque. No

modifica el deque.

begin: El método begin se utiliza para obtener un iterador que apunta al primer
elemento del deque.

end: El método end se utiliza para obtener un iterador que apunta al elemento
siguiente al último elemento del deque.

at: El método at se utiliza para acceder a un elemento en una posición específica del
deque. Realiza una verificación de límites y lanza una excepción out_of_range si la
posición está fuera del rango válido.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

int element = myDeque.at(2); // Accede al elemento en la posición 2 (valor 3)

assign: El método assign se utiliza para asignar nuevos valores a un deque,

reemplazando su contenido actual. Puede recibir una lista de inicialización, un rango
de elementos o un número repetido.

std::deque<int> myDeque;
myDeque.assign({1, 2, 3, 4, 5}); // Asigna los valores 1, 2, 3, 4, 5 al deque

empty: El método empty se utiliza para verificar si el deque está vacío. Devuelve
true si el deque no contiene elementos y false en caso contrario.

size: El método size se utiliza para obtener el número de elementos en el deque.

Devuelve un valor entero que representa la cantidad de elementos presentes en el
deque.

max_size: El método max_size se utiliza para obtener el número máximo de

elementos que puede contener el deque.

insert: El método insert se utiliza para insertar uno o varios elementos en una
posición específica del deque. Puede recibir una posición y un valor, una posición y
un rango de elementos, o una posición y una lista de inicialización.
 std::deque<int> myDeque = {1, 2, 3, 4, 5};
myDeque.insert(myDeque.begin() + 2, 42); // Inserta el valor 42 en la posición
2 del deque

emplace: El método emplace se utiliza para construir e insertar un elemento en una

posición específica del deque utilizando argumentos pasados directamente al
constructor del elemento.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.emplace(myDeque.begin() + 2, 42); // Construye e inserta el valor
42 en la posición 2 del deque

swap: El método swap se utiliza para intercambiar el contenido de dos deques del
mismo tipo y tamaño. Los deques deben ser del mismo tipo y tener el mismo
tamaño para que el intercambio sea válido.

std::deque<int> deque1 = {1, 2, 3};

std::deque<int> deque2 = {4, 5, 6};

deque1.swap(deque2); // Intercambia el contenido de deque1 y deque2

push_front: El método push_front se utiliza para agregar un elemento al frente del

deque.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.push_front(0); // Agrega el elemento 0 al frente del deque

push_back: El método push_back se utiliza para agregar un elemento al final del

deque.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.push_back(6); // Agrega el elemento 6 al final del deque

clear: El método clear se utiliza para eliminar todos los elementos del deque,
dejándolo vacío.

emplace_back: El método emplace_back se utiliza para construir e insertar un

elemento al final del deque utilizando argumentos pasados directamente al
constructor del elemento.
std::deque<int> myDeque = {1, 2, 3, 4, 5};
myDeque.emplace_back(6); // Construye e inserta el elemento 6 al final del
deque

emplace_front: El método emplace_front se utiliza para construir e insertar un

elemento al frente del deque utilizando argumentos pasados directamente al
constructor del elemento.

std::deque<int> myDeque = {1, 2, 3, 4, 5};

myDeque.emplace_front(0); // Construye e inserta el elemento 0 al frente del
deque

Priority Queue

priority_queue<int> fila_banco;

priority queue es un adaptador de contenedor que proporciona búsqueda en tiempo

constante del elemento mayor (por defecto), a expensas de la inserción y extracción
logarítmica.

Se puede suministrar un Compare proporcionado por el usuario para cambiar el

orden, por ejemplo, utilizando std::greater<T> haría que el elemento más pequeño
apareciera como top().

Trabajar con priority_queue es similar a gestionar un montón en algún contenedor

de acceso aleatorio, con la ventaja de no poder invalidar accidentalmente el montón.

Methods and non-member functions

top: El método top en la clase priority_queue en C++ devuelve una referencia al

elemento de mayor prioridad en la cola de prioridad. Este método no modifica la cola
de prioridad.

pq.top()

empty: El método empty en la clase priority_queue en C++ devuelve true si la cola

de prioridad está vacía, y false en caso contrario.
 pq.empty()

size: El método size en la clase priority_queue en C++ devuelve el número de

elementos en la cola de prioridad.

pq.size()

push: El método push en la clase priority_queue en C++ se utiliza para insertar un

elemento en la cola de prioridad. El elemento se inserta de acuerdo con su
prioridad.

pq.push(5);

pop: El método pop en la clase priority_queue en C++ se utiliza para eliminar el

elemento de mayor prioridad de la cola de prioridad.

pq.pop();

emplace: El método emplace en la clase priority_queue en C++ se utiliza para

construir y insertar un elemento en la cola de prioridad. El elemento se inserta de
acuerdo con su prioridad.

pq.emplace(5, "C");

swap: El método swap en la clase priority_queue en C++ se utiliza para intercambiar

el contenido de dos colas de prioridad.

pq1.swap(pq2);

Stack

stack<int> barajas;
La clase stack es un adaptador de contenedor que proporciona al programador la
funcionalidad de una pila - específicamente, una estructura de datos LIFO (último en
entrar, primero en salir).

La plantilla de clase actúa como una envoltura del contenedor subyacente - sólo se
proporciona un conjunto específico de funciones. La pila empuja y saca el elemento
de la parte posterior del contenedor subyacente, conocido como la parte superior de
la pila.

Methods and non-member functions

top: El método top en la clase stack de C++ se utiliza para acceder al elemento
superior (el elemento en la parte superior) de la pila sin eliminarlo. Devuelve una
referencia al elemento superior de la pila.

s.top()

empty: El método empty en la clase stack de C++ se utiliza para verificar si la pila
está vacía o no. Devuelve true si la pila está vacía y false si no lo está.

s.empty()

size: El método size en la clase stack de C++ se utiliza para obtener el número de
elementos en la pila. Devuelve un valor entero que representa el tamaño de la pila.

s.size()

push: El método push en la clase stack de C++ se utiliza para agregar un elemento
a la parte superior de la pila. Toma el elemento que se va a agregar como
argumento.

s.push(5);

pop: El método pop en la clase stack de C++ se utiliza para eliminar el elemento
superior de la pila. No devuelve ningún valor.

s.pop();
emplace: El método emplace en la clase stack de C++ se utiliza para construir y
agregar un elemento a la parte superior de la pila. Toma los argumentos necesarios
para construir el elemento.

s.emplace(5, "C");

swap: El método swap en la clase stack de C++ se utiliza para intercambiar el

contenido de dos pilas. Toma otra pila como argumento y realiza el intercambio.

s1.swap(s2);

Librería Math
La librería Math en C++ proporciona una serie de funciones matemáticas
predefinidas que se pueden utilizar en programas C++. Estas funciones permiten
realizar operaciones matemáticas comunes, como cálculos trigonométricos,
operaciones exponenciales, redondeo, generación de números aleatorios, entre
otros.

Algunos de los métodos más utilizados de la librería Math en C++ son:

sqrt(x): Calcula la raíz cuadrada de un número.

pow(x, y): Calcula x elevado a la potencia y.
sin(x): Calcula el seno de un ángulo en radianes.
cos(x): Calcula el coseno de un ángulo en radianes.
tan(x): Calcula la tangente de un ángulo en radianes.
log(x): Calcula el logaritmo natural de un número.
exp(x): Calcula la función exponencial de un número.
abs(x): Devuelve el valor absoluto de un número.
ceil(x): Redondea un número hacia arriba al entero más cercano.
floor(x): Redondea un número hacia abajo al entero más cercano.
round(x): Redondea un número al entero más cercano.
rand(): Genera un número aleatorio.