[Link]
com/biblioteca-en-c-stl/
Operaciones de secuencia que no modifican
std::all_of : Condición de prueba en todos los elementos en el rango
std::any_of : prueba si algún elemento en el rango cumple la condición
std::none_of : prueba si ningún elemento cumple la condición
std::for_each : Aplicar función al rango
std::find : Encuentra el valor en el rango
std::find_if : Buscar elemento en el rango
std::find_if_not : Buscar elemento en rango (condición negativa)
std::find_end : Encuentra la última subsecuencia en el rango
std::find_first_of : Buscar elemento del conjunto en el rango
std::adyacente_find : Encuentra elementos adyacentes iguales en el rango
std::count : cuenta las apariciones de valor en el rango
std::count_if : Devuelve el número de elementos en el rango que satisface la
condición
std::discrepancia: devuelve la primera posición donde dos rangos difieren
std::equal : prueba si los elementos en dos rangos son iguales
std::is_permutation : prueba si el rango es una permutación de otro
std::search : Rango de búsqueda de subsecuencia
std::search_n : rango de búsqueda para el elemento
Modificación de operaciones de secuencia
std:: copy : Copia rango de elementos
std::copy_n : Copiar elementos
std::copy_if : Copia ciertos elementos del rango
std::copy_backward : Copiar rango de elementos hacia atrás
std::move : Mover rango de elementos
std::move_backward : Mueve el rango de elementos hacia atrás
std::swap : Intercambia valores de dos objetos
std ::swap_ranges : Intercambia valores de dos rangos
std::iter_swap : Intercambia valores de objetos apuntados por dos iteradores
std ::transform : Rango de transformación
std ::replace : Reemplazar valor en rango
std ::replace_if : Reemplazar valores en el rango
std::replace_copy : Copiar rango reemplazando valor
std::replace_copy_if : Copiar rango reemplazando valor
std ::fill : Rango de relleno con valor
std::fill_n : Secuencia de relleno con valor
std ::generate: genera valores para el rango con la función
std ::generate_n : Generar valores para secuencia con función
std ::remove : Eliminar valor del rango
std::remove_if : Eliminar elementos del rango
remove_copy: Copiar valor de eliminación de rango
remove_copy_if : Copiar rango eliminando valores
std ::unique: eliminar duplicados consecutivos en el rango
std::unique_copy : Copiar rango eliminando duplicados
std ::reverse : Rango inverso
std::copia_inversa : Rango de copia invertido
std::rotar : Gira a la izquierda los elementos en el rango
std::rotar_copiar : Copiar rango rotado a la izquierda
std::random_shuffle : Reorganiza aleatoriamente los elementos en el rango
std::shuffle : reorganiza aleatoriamente los elementos en el rango usando el
generador
Operaciones de partición
std::is_partitioned : prueba si el rango está particionado
std::partición: rango de partición en dos
std::stable_partition : Rango de partición en dos – ordenación estable
partición_copia: rango de partición en dos
partición_punto : Obtener punto de partición
Clasificación
std::sort : Ordenar elementos en rango
std::stable_sort : Ordenar elementos conservando el orden de los equivalentes
std::shared_sort : ordenar parcialmente los elementos en el rango
std::shared_sort_copy: copia y ordena parcialmente el rango
std::is_sorted : comprueba si el rango está ordenado
std::is_sorted_until : Encuentra el primer elemento sin clasificar en el rango
std::nth_element : Ordenar elemento en rango
Búsqueda binaria (operando en rangos particionados/ordenados)
std::lower_bound : Devuelve el iterador al límite inferior
std::upper_bound : Devuelve el iterador al límite superior
std::equal_range : Obtener subrango de elementos iguales
std::binary_search : prueba si el valor existe en secuencia ordenada
Fusionar (operando en rangos ordenados)
std::merge : Combinar rangos ordenados
std::inplace_merge: Combinar rangos ordenados consecutivos
std::include: prueba si el rango ordenado incluye otro rango ordenado
std::set_union : Unión de dos rangos ordenados
std::set_intersection : Intersección de dos rangos ordenados
std::set_difference : Diferencia de dos rangos ordenados
std::set_symmetric_difference : Diferencia simétrica de dos rangos ordenados
Operaciones de montón
std::push_heap : Empuje el elemento dentro del rango del montón
std::pop_heap : Elemento emergente del rango de
std::make_heap : Hacer un montón a partir del rango
std::sort_heap : Ordenar elementos del montón
std::is_heap : prueba si el rango es un montón
std::is_heap_until : Encuentra el primer elemento que no está en el orden del
montón
std::max : Devuelve el mayor
std::minmax : Devuelve los elementos más pequeño y más grande
std::min_element : Devuelve el elemento más pequeño en el rango
std::max_element : Devuelve el elemento más grande en el rango
std::minmax_element : Devuelve los elementos más pequeños y más grandes en el rango
Otras operaciones
std::lexicographical_compare : Comparación lexicográfica menor que
std::next_permutation : Transformar rango a la siguiente permutación
std::prev_permutation : Transformar el rango a la permutación anterior
-------------------------------------
Algunos de los algoritmos más utilizados en vectores y más útiles en Programación
Competitiva se mencionan a continuación:
Algoritmos de no manipulación
sort (first_iterator, last_iterator) – Para ordenar el vector dado.
reverse(first_iterator, last_iterator) – Para invertir un vector.
*max_element (first_iterator, last_iterator) – Para encontrar el elemento máximo de
un vector.
*min_element (first_iterator, last_iterator) – Para encontrar el elemento mínimo de
un vector.
acumular (primer_iterador, último_iterador, valor inicial de la suma) – Hace la
suma de los elementos del vector
CPP
// A C++ program to demonstrate working of sort(),
// reverse()
#include <algorithm>
#include <iostream>
#include <vector>
#include <numeric> //For accumulate operation
using namespace std;
int main()
{
// Initializing vector with array values
int arr[] = {10, 20, 5, 23 ,42 , 15};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
cout << "Vector is: ";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
// Sorting the Vector in Ascending order
sort([Link](), [Link]());
cout << "\nVector after sorting is: ";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
// Reversing the Vector
reverse([Link](), [Link]());
cout << "\nVector after reversing is: ";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
cout << "\nMaximum element of vector is: ";
cout << *max_element([Link](), [Link]());
cout << "\nMinimum element of vector is: ";
cout << *min_element([Link](), [Link]());
// Starting the summation from 0
cout << "\nThe summation of vector elements is: ";
cout << accumulate([Link](), [Link](), 0);
return 0;
}
Producción
Vector is: 10 20 5 23 42 15
Vector after sorting is: 5 10 15 20 23 42
Vector after reversing is: 42 23 20 15 10 5
Maximum element of vector is: 42
Minimum element of vector is: 5
The summation of vector elements is: 115
[Link](first_iterator, last_iterator,x) – Para contar las ocurrencias de x
en el vector.
7. find(first_iterator, last_iterator, x) : devuelve un iterador a la
primera aparición de x en el vector y apunta a la última dirección del vector
((name_of_vector).end()) si el elemento no está presente en el vector.
// C++ program to demonstrate working of count()
// and find()
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Initializing vector with array values
int arr[] = {10, 20, 5, 23 ,42, 20, 15};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
cout << "Occurrences of 20 in vector : ";
// Counts the occurrences of 20 from 1st to
// last element
cout << count([Link](), [Link](), 20);
// find() returns iterator to last address if
// element not present
find([Link](), [Link](),5) != [Link]()?
cout << "\nElement found":
cout << "\nElement not found";
return 0;
}
8. binary_search (first_iterator, last_iterator, x) – Comprueba si x existe
en el vector ordenado o no.
9. lower_bound(first_iterator, last_iterator, x) – devuelve un iterador que
apunta al primer elemento en el rango [primero, último] que tiene un valor no menor
que ‘x’.
10. upper_bound(first_iterator, last_iterator, x) – devuelve un iterador que
apunta al primer elemento en el rango [primero, último] que tiene un valor mayor
que ‘x’.
C++
// C++ program to demonstrate working of lower_bound()
// and upper_bound().
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Initializing vector with array values
int arr[] = {5, 10, 15, 20, 20, 23, 42, 45};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
// Sort the array to make sure that lower_bound()
// and upper_bound() work.
sort([Link](), [Link]());
// Returns the first occurrence of 20
auto q = lower_bound([Link](), [Link](), 20);
// Returns the last occurrence of 20
auto p = upper_bound([Link](), [Link](), 20);
cout << "The lower bound is at position: ";
cout << [Link]() << endl;
cout << "The upper bound is at position: ";
cout << [Link]() << endl;
return 0;
}
Producción
The lower bound is at position: 3
The upper bound is at position: 5
Algunos algoritmos de manipulación
[Link] (posición a eliminar) : esto borra el elemento seleccionado en el vector
y cambia y cambia el tamaño de los elementos del vector en consecuencia.
[Link](unique([Link](),[Link]()),[Link]()) – Esto borra las ocurrencias
duplicadas en el vector ordenado en una sola línea.
Producción
El vector es: 5 10 15 20 20 23 42 45
El vector después de borrar el elemento: 5 15 20 20 23 42 45
El vector antes de eliminar las ocurrencias duplicadas: 5 15 20 20 23 42 45
El vector después de eliminar los duplicados: 5 15 20 23 42 45
3. next_permutation(first_iterator, last_iterator) – Esto modificó el vector
a su siguiente permutación.
4. prev_permutation(first_iterator, last_iterator) – Esto modificó el vector
a su permutación anterior.
CPP
// C++ program to demonstrate working
// of next_permutation()
// and prev_permutation()
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Initializing vector with array values
int arr[] = {5, 10, 15, 20, 20, 23, 42, 45};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
cout << "Given Vector is:\n";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
// modifies vector to its next permutation order
next_permutation([Link](), [Link]());
cout << "\nVector after performing
next permutation:\n";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
prev_permutation([Link](), [Link]());
cout << "\nVector after performing prev
permutation:\n";
for (int i=0; i<n; i++)
cout << vect[i] << " ";
return 0;
}
Producción
Given Vector is:
5 10 15 20 20 23 42 45
Vector after performing next permutation:
5 10 15 20 20 23 45 42
Vector after performing prev permutation:
5 10 15 20 20 23 42 45
5. distancia (first_iterator,desired_position) : devuelve la distancia de
la posición deseada desde el primer iterador. Esta función es muy útil para
encontrar el índice.
CPP
// C++ program to demonstrate working of distance()
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Initializing vector with array values
int arr[] = {5, 10, 15, 20, 20, 23, 42, 45};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
// Return distance of first to maximum element
cout << "Distance between first to max element: ";
cout << distance([Link](),
max_element([Link](), [Link]()));
return 0;
}
Producción
Distance between first to max element: 7
