Programación

Introducción a STL: Biblioteca de
plantillas estándar
STL es un acrónimo de biblioteca de plantillas estándar. Es un conjunto de clases
de plantilla de C ++ que proporcionan clases y funciones genéricas que se
pueden usar para implementar estructuras de datos y algoritmos. STL se
compone principalmente de:
1. Algoritmos
2. Contenedores
3. Iteradores
STL proporciona numerosos contenedores y algoritmos que son muy útiles en la

programación completa, por ejemplo, puede definir fácilmente una lista vinculada
en una sola declaración utilizando el contenedor de lista de la biblioteca de
contenedores en STL, ahorrando su tiempo y esfuerzo.
STL es una biblioteca genérica, es decir, se puede operar un mismo contenedor
o algoritmo en cualquier tipo de datos, no es necesario que defina el mismo
algoritmo para diferentes tipos de elementos.
Por ejemplo, el algoritmo de clasificación clasificará los elementos en el rango
dado independientemente de su tipo de datos, no tenemos que implementar un
algoritmo de clasificación diferente para diferentes tipos de datos.
C ++: Algoritmos en STL

STL proporciona una cantidad de algoritmos que se pueden usar en cualquier
contenedor, independientemente de su tipo. La biblioteca de algoritmos contiene
funciones integradas que realizan algoritmos complejos en las estructuras de
datos.
Por ejemplo: uno puede revertir un rango con reverse()función, ordenar un rango
con sort()función, buscar en un rango con binary_search()y así sucesivamente.
La biblioteca de algoritmos proporciona abstracción, es decir, no necesariamente
necesita saber cómo funciona el algoritmo.
C ++: Contenedores en STL

La biblioteca de contenedores en STL proporciona contenedores que se utilizan
para crear estructuras de datos como matrices, listas vinculadas, árboles, etc.
Estos contenedores son genéricos, pueden contener elementos de cualquier tipo
de datos, por ejemplo: vector puede usarse para crear matrices dinámicas de
caracteres char, enteros, flotantes y otros tipos.
C ++: Iteradores en STL

Los iteradores en STL se utilizan para señalar los contenedores. Los iteradores
en realidad actúan como un puente entre contenedores y algoritmos.
Por ejemplo: el sort()algoritmo tiene dos parámetros, el iterador inicial y el
iterador final, ahora sort () compara los elementos apuntados por cada uno de
estos iteradores y los organiza en orden ordenado, por lo que no importa cuál
sea el tipo de contenedor y el mismo tipo ( ) se puede utilizar en diferentes tipos
de contenedores.
Uso y aplicación de STL

La biblioteca genérica STL proporciona contenedores y algoritmos que se
pueden usar para almacenar y manipular diferentes tipos de datos, por lo que
nos ahorra la definición de estas estructuras de datos y algoritmos desde
cero. Debido a STL, ahora no tenemos que definir nuestra función de
clasificación cada vez que hacemos un nuevo programa o definimos la misma
función dos veces para los diferentes tipos de datos, en su lugar podemos usar
el contenedor genérico y los algoritmos en STL.
Esto ahorra mucho tiempo, código y esfuerzo durante la programación, por lo
tanto, STL se usa mucho en la programación competitiva, además es confiable
y rápido.
¿Qué son los contenedores en STL?
La Biblioteca de Contenedores en STL nos proporciona los Contenedores, que
en palabras más simples, pueden describirse como los objetos utilizados para
contener datos o, más bien, la colección de objetos. Los contenedores nos
ayudan a implementar y replicar estructuras de datos simples y complejas muy
fácilmente, como matrices, listas, árboles, matrices asociativas y muchas más.
Los contenedores se implementan como plantillas de clase genéricas, lo que

significa que se puede usar un contenedor para contener diferentes tipos de
objetos y son de naturaleza dinámica.
Los siguientes son algunos contenedores comunes:
• vector : replica matrices

• cola : replica colas
• pila : replica la pila
• Priority_queue : replica montones
• lista : replica la lista vinculada
• conjunto : replica árboles
• mapa : matrices asociativas
Clasificación de contenedores en STL

Los contenedores se clasifican en cuatro categorías:
• Contenedores de secuencia : se utilizan para implementar estructuras

de datos que son de naturaleza secuencial, como las matrices (matriz) y
la lista vinculada (lista).
• Contenedores asociativos : se utilizan para implementar estructuras de

datos clasificadas, como mapas, conjuntos, etc.
• Contenedores asociativos desordenados : se utilizan para

implementar estructuras de datos sin ordenar.
• Adaptadores de contenedores : se utilizan para proporcionar una

interfaz diferente a los contenedores de secuencia.
Uso de la biblioteca de contenedores

en STL
A continuación se muestra un ejemplo de implementación de lista vinculada,
primero mediante el uso de estructuras y luego mediante contenedores de lista.
#include <iostream>
struct node
{
int data;
struct node * next;
}
int main ()
{
struct node *list1 = NULL;
}
El programa anterior solo crea un nodo de lista, no se definen funciones de

inserción y eliminación, para ello, tendrá que escribir más líneas de código.
Ahora veamos cómo usar Container Library lo simplifica. Cuando usamos
contenedores de lista para implementar una lista vinculada, solo tenemos que
incluir el archivo de encabezado de lista y usar el constructor de lista para
inicializar la lista.
#include <iostream>
#include <list>
int main ()
{
list<int> list1;
}
¡Y eso es! tenemos una lista, y no solo eso, la biblioteca de contenedores

también proporciona todos los diferentes métodos que se pueden usar para
realizar diferentes operaciones en la lista, como inserción, eliminación, recorrido,
etc.
Por lo tanto, puede ver que es increíblemente fácil implementar estructuras de
datos utilizando la biblioteca de contenedores.
Emparejar plantilla en STL

NOTA : Aunque Pair y Tuple no son realmente parte de la biblioteca de
contenedores, aún los discutiremos ya que son muy comunes en las
competencias de programación y hacen que ciertas cosas sean muy fáciles de
implementar.
La sintaxis del par es:
pair<T1,T2> pair1, pair2 ;
El código anterior crea dos pares, a saber, par1 y par2, ambos con el primer
objeto de tipo T1 y el segundo objeto de tipo T2.
Ahora T1 se denominará primero y T2 se denominará segundo miembro de pair1
y pair2.
Plantilla de par: algunas funciones de
uso común
Aquí hay algunas funciones para la plantilla de pares:
• Operador =: asigna valores a un par.

• swap: intercambia el contenido del par.
• make_pair (): crea y devuelve un par que tiene objetos definidos por la
lista de parámetros.
• Operadores (==,! =,>, <, <=,> =): Compara lexicográficamente dos pares.
PROGRAMA QUE DEMUESTRA LA PLANTILLA PAIR
#include <iostream>
using namespace std;
int main ()
{
pair<int,int> pair1, pair3; //creats pair of integers
pair<int,string> pair2; // creates pair of an integer an a string
pair1 = make_pair(1, 2); // insert 1 and 2 to the pair1

pair2 = make_pair(1, "Studytonight") // insert 1 and "Studytonight" in
pair2
pair3 = make_pair(2, 4)
cout<< pair1.first << endl; // prints 1, 1 being 1st element of pair1
cout<< pair2.second << endl; // prints Studytonight
if(pair1 == pair3)
cout<< "Pairs are equal" << endl;
else
cout<< "Pairs are not equal" << endl;
return 0;
}
TUPLE en STL
tupley pairson muy similares en su estructura. Al igual que en el par podemos
emparejar dos objetos heterogéneos, en la tupla podemos emparejar tres objetos
heterogéneos.
La sintaxis de una tupla es:
// creates tuple of three object of type T1, T2 and T3

tuple<T1, T2, T3> tuple1;
Plantilla de tupla: algunas funciones de

uso común
Similar a la pareja, la plantilla de tupla tiene sus propias funciones miembro y no
miembro, algunas de las cuales se enumeran a continuación:
• Un constructor para construir una nueva tupla

• Operador = : para asignar valor a una tupla
• swap: para intercambiar el valor de dos tuplas
• make_tuple (): crea y devuelve una tupla que tiene elementos descritos
por la lista de parámetros.
• Operadores (==,! =,>, <, <=,> =): Compara lexicográficamente dos pares.
• Tuple_element: devuelve el tipo de elemento de tupla
• Empate: ata los valores de una tupla a sus referencias.
PROGRAMA QUE MUESTRA LA PLANTILLA TUPLE
#include <iostream>
int main ()
{
tuple<int, int, int> tuple1; //creates tuple of integers
tuple<int, string, string> tuple2; // creates pair of an integer an 2 string
tuple1 = make_tuple(1,2,3); // insert 1, 2 and 3 to the tuple1

tuple2 = make_pair(1,"Studytonight", "Loves You");
/* insert 1, "Studytonight" and "Loves You" in tuple2 */
int id;
string first_name, last_name;
tie(id,first_name,last_name) = tuple2;
/* ties id, first_name, last_name to
first, second and third element of tuple2 */
cout << id <<" "<< first_name <<" "<< last_name;

/* prints 1 Studytonight Loves You */
return 0;
}
ARRAY Contenedor en STL

Las matrices, como todos sabemos, son una colección de objetos
homogéneos. El contenedor de matriz en STL nos proporciona la
implementación de una matriz estática, aunque rara vez se usa en la
programación competitiva ya que es de naturaleza estática, pero aún
discutiremos el contenedor de matriz porque proporciona algunas funciones
miembro y no miembro, lo que le da una ventaja sobre la matriz definida
clásicamente como, int nombre_arrays [tamaño_matriz].
SINTAXIS DEL CONTENEDOR DE MATRIZ:
array<object_type, array_size> array_name;
El código anterior crea una matriz vacía de object_type con un tamaño máximo
de array_size . Sin embargo, si desea crear una matriz con elementos, puede
hacerlo simplemente usando el = operador, aquí hay un ejemplo:
#include <vector>
int main()
{
array<int, 4> odd_numbers = { 2, 4, 6, 8 };
}
La declaración anterior creará una matriz con 2,4,6,8 como datos en la

matriz. Tenga en cuenta que la inicialización entre {}paréntesis solo es posible
en c ++ 17.
Funciones de miembro de plantilla de

matriz
Las siguientes son las funciones miembro importantes y más utilizadas de la
plantilla de matriz.
at función
Este método devuelve valor en la matriz en el rango dado. Si el rango dado es
mayor que el tamaño de la matriz, se genera la excepción out_of_range . Aquí
hay un fragmento de código
#include <iostream>
#include <array>
int main ()
{
array<int,10> array1 = {1,2,3,4,5,6,7,8,9};
cout << array1.at(2) // prints 3

cout << array1.at(4) // prints 5
[ ] OPERADOR
El uso del operador [ ] es el mismo que para las matrices normales. Devuelve el
valor en la posición dada en la matriz. Ejemplo: en el código anterior, la
instrucción cout << array1[5];imprimiría 6 en la consola ya que 6 tiene el índice 5
en la matriz1.
front() función
Este método devuelve el primer elemento en la matriz.
back() función
Este método devuelve el último elemento en la matriz. El punto a tener en cuenta
aquí es que si la matriz no está completamente llena, back () devolverá el
elemento más a la derecha en la matriz.
fill() función
Este método asigna el valor dado a cada elemento de la matriz, por ejemplo:
#include <array>
int main()
{
array<int,8> myarray;
myarray.fill(1);
}
Esto llenará la matriz myarray con el valor 1, en todas sus 8 posiciones

disponibles.
swap función
Este método intercambia el contenido de dos matrices del mismo tipo y el mismo
tamaño. Intercambia el índice, por lo tanto, el elemento del índice i de la primera
matriz se intercambiará con el elemento del índice i de la segunda matriz, y si el
intercambio de cualquiera de los dos elementos genera una ejecución, swap ()
arroja una excepción. A continuación se muestra un ejemplo para demostrar su
uso:
#include <array>
int main()
{
array<int,8> a = {1,2,3,4,5,6,7,8};
array<int,8> b = {8,7,6,5,4,3,2,1};
a.swap(b) // swaps array a and b
cout << "a is : ";

for(int i=0; i < 8; i++) {
cout << a[i] <<" ";
}
cout << endl;
cout << "b is : ";
for(int i=0; i < 8; i++) {
cout << a[i] <<" ";
}
/* ouput will be
a is : 8 7 6 5 4 3 2 1
b is : 1 2 3 4 5 6 7 8 */
}
OPERADORES (==,! =,>, <,> =, <=)
Todos estos operadores se pueden usar para comparar lexicográficamente los
valores de dos matrices.
empty función
Este método se puede utilizar para verificar si la matriz está vacía o no.
Sintaxis:, array_name.empty()devuelve verdadero si la matriz está vacía; de lo
contrario, devuelve falso.
size función
Este método devuelve el número de elementos presentes en la matriz.
max_size función
Este método devuelve el tamaño máximo de la matriz.
begin función
Este método devuelve el iterador apuntando al primer elemento de la matriz. Los
iteradores son como punteros y los discutiremos más adelante en las lecciones,
por ahora puedes pensar en un iterador como un puntero a la matriz.
end función
Este método devuelve un iterador que apunta a un elemento al lado del último
elemento de la matriz, por ejemplo, la matriz anterior tiene 4 elementos y la
llamada end () devolverá el iterador que apunta al cuarto índice de la matriz.
VECTOR Contenedor en STL

Una matriz funciona bien cuando tenemos que implementar estructuras de
datos secuenciales como las matrices, excepto que es estática, es decir,
tenemos que definir su tamaño máximo durante su inicialización y no puede
contener elementos mayores que su tamaño máximo. Ahora suponga que si
durante la ejecución del programa tenemos que almacenar elementos más que
su tamaño, o si estamos leyendo una secuencia de entrada de elementos y no
conocemos el límite superior del número de elementos, existen altas
posibilidades de que ocurra la excepción index_out_bound o terminación no
deseada del programa.
Podemos hacer una cosa, inicializar la matriz con el tamaño máximo permitido
por el compilador, es decir, 10^6elementos por matriz, pero es un enfoque que
consume mucho espacio y hay un desperdicio de espacio si el número de
elementos a ingresar es demasiado bajo, por lo tanto esto enfoque nunca se
utiliza en la programación.
¡La solución del problema anterior son las matrices dinámicas! Tienen un tamaño
dinámico, es decir, su tamaño puede cambiar durante el tiempo de ejecución. La
biblioteca de contenedores proporciona vectores para replicar matrices
dinámicas.
La SINTAXIS para crear un vector es: vector< object_type > vector_name;

Por ejemplo:
#include <vector>
int main()
{
std::vector<int> my_vector;
}
El vector es una matriz dinámica, no necesita tamaño durante la declaración, por

lo tanto, el código anterior creará un vector en blanco. Hay muchas formas de
inicializar un vector como,
#include <vector>
int main()
{
std::vector<string> v {"Pankaj" ,"The" ,"Java" ,"Coder"};
}
Tenga en cuenta que este tipo de inicialización solo funciona en C ++ 11 y

superior. También puede inicializar el vector en función del rango de otros
vectores, como:
#include <vector>
int main()
{
std::vector<string> v(v1.begin(), v1.end());
}
El código anterior inicializa el vector por elementos señalados por iteradores
devueltos por v1.begin () y v2.end (), begin () y end () son la misma función que
hemos estudiado con array, funcionan igual con vectores.
También puede inicializar un vector con un elemento una cierta cantidad de

veces, como:
#include <vector>
int main()
{
std::vector<string> v(4 , "test");
}
Estas son algunas de las formas en que puede inicializar su vector, pero
recuerde, inicializar su vector usando otro vector o usando elementos
directamente no limita su tamaño, su tamaño siempre será dinámico y se pueden
insertar más elementos en el vector , siempre que sea necesario.
Funciones de miembro de Vector

Las siguientes son algunas de las funciones más utilizadas para el contenedor
de vectores en STL:
push_back función
push_back()se usa para insertar un elemento al final del vector. Si el tipo de
objeto pasado como parámetro en push_back () no es el mismo que el del vector
o no es interconvertible, se genera una excepción.
La siguiente ilustración mostrará cómo funciona push_back ():
#include <iostream>
#include <vector>
int main()
{
vector<int> v;
v.push_back(1); //insert 1 at the back of v
for(vector<int>::iterator i = v.begin(); i != v.end(); i++)

{
cout << *i <<" "; // for printing the vector
}
}
124
insert función
insert(itr, element) El método inserta el elemento en el vector antes de la posición
señalada por el iterador itr.
La siguiente ilustración mostrará cómo funciona la inserción:

La función de inserción puede sobrecargarse con un tercer
argumento, contar también. Este parámetro de recuento define cuántas veces se
debe insertar el elemento antes de la posición puntiaguda.
Este método también se puede utilizar para insertar elementos de cualquier otro
vector en un rango dado, especificado por dos iteradores, que definen el punto
inicial y final del rango.
v.insert(i, v2.begin(), v2.end());
El código anterior insertará los elementos de v2.begin () a v2.end () antes del

índice señalado por i .
pop_back función
pop_back () se usa para eliminar el último elemento del vector. Reduce el tamaño
del vector en uno.
A continuación se muestra un ejemplo:
#include <iostream>
#include <vector>
int main()
{
vector<int> v1 {10,20,30,40};
v1.pop_back();
vector<int>::iterator it;
for(it = v.begin(); it != v.end(); it++)

{
cout << *it <<" "; // for printing the vector
}
}
10 20 30
erase función
erase(itr_pos)elimina el elemento señalado por el iterador itr_pos . El método de
borrado también se puede sobrecargar con un iterador adicional que especifica
el punto final del rango que se va a eliminar, es decir erase(itr_start, itr_end).
El siguiente código ilustrará borrar:
#include <iostream>
#include <vector>
int main()
{
vecto<int>v1 {10,20,30,40};
vector<int>iterator:: it = v.begin();
v.erase(it); //removes first element from the vector
v.erase(v1.begin(), v1.end() - 2 )
/*removes all the elements except last two */
for(it = v.begin(); it != v.end(); it++)

{
cout << *it <<" "; // for printing the vector
}
}
OUTPUT:
30 40
resize función
resize(size_type n, value_type val)El método cambia el tamaño del vector
a n elementos. Si el tamaño actual del vector es mayor que n , los elementos
finales se eliminan del vector y si el tamaño actual es menor que n , se insertan
elementos val adicionales en la parte posterior del vector.
Por ejemplo, si el tamaño del vector es 4 en este momento, con los elementos
{10, 20, 30, 40} y usamos el resizemétodo para redimensionarlo al tamaño 5.
Entonces, por defecto , se insertará un quinto elemento con valor 0 en el
vector. Podemos especificar que los datos no sean cero, al mencionarlos
explícitamente como val al llamar al método de cambio de tamaño.
swap función
Este método intercambia el valor de dos vectores.
Si tenemos dos vectores v1 y v2 y queremos intercambiar los elementos dentro
de ellos, solo necesita llamar v1.swap(v2), esto intercambiará los valores de los
dos vectores.
clear función
Este método borra todo el vector, elimina todos los elementos del vector pero no
lo elimina.
SINTAXIS: clear()
Para un vector v , v.clear()lo borrará, pero no lo eliminará.
size función
Este método devuelve el tamaño del vector.
empty función
Este método devuelve verdadero si el vector está vacío; de lo contrario, devuelve
falso.
capacity función
Este método devuelve el número de elementos que se pueden insertar en el
vector en función de la memoria asignada al vector.
at función
Este método funciona igual en el caso del vector que para la
matriz. vector_name.at(i)devuelve el elemento en el índice i-ésimo en el
vector vector_name .
fronty backfunciones
vector_name.front()vuelve a ejecutar el elemento en la parte frontal del vector
(es decir, el elemento más a la izquierda). Mientras vector_name.back()devuelve
el elemento en la parte posterior del vector (es decir, el elemento más a la
derecha).
LISTA Contenedor en STL

Array y Vector son contenedores contiguos, es decir, almacenan sus datos en
memoria continua, por lo que la operación de inserción en el medio de vector /
array es muy costosa (en términos de número de operación y tiempo de proceso)
porque tenemos que cambiar todos los elementos, Lista vinculada superar este
problema. La lista vinculada se puede implementar utilizando el contenedor de
lista.
La sintaxis para crear una nueva lista vinculada usando la plantilla de lista es:
#include <iostream>
#include <list>
int main()
{
std::list<int> l;
}
/* Creates a new empty linked list l */
Similar a vector y matriz, las listas también se pueden inicializar con parámetros,
#include <iostream>
#include <list>
int main()
{
std::list<int> l{1,2,3};
}
/* Creates a new linked list l */
Aquí hay algunas formas más por las cuales podemos inicializar nuestra lista:
#include <iostream>
#include <list>
int main()
{
list<int> myList{1,2,3};
/* creates list with 1,2,3 in it */
list<int> myNewList = 1;
/* create list myNewList of integer
and copies value of 1 into it*/
}
Funciones de miembro del contenedor

de listas
insert función
Este método, como su nombre indica, inserta un elemento en una posición
específica, en una lista. Hay 3 variaciones de insert (), son las siguientes:
• insert(iterator, element): inserta el elemento en la lista antes de la

posición señalada por el iterador .
• insert(iterator, count, element): inserta el elemento en la lista antes de la

posición señalada por el iterador , cuenta el número de veces.
• insert(iterator, start_iterator, end_iterator): inserte el elemento señalado

por start_iterator en el elemento señalado por end_iterator antes de la
posición señalada por iterador
#include <iostream>
#include <list>

int main()
{
list<int> l = {1,2,3,4,5};
list<int>::iterator it = l.begin();
l.insert (it+1, 100); // insert 100 before 2 position

/* now the list is 1 100 2 3 4 5 */
list<int> new_l = {10,20,30,40}; // new list
new_l.insert (new_l.begin(), l.begin(), l.end());

/*
insert elements from beginning of list l to end of list l
before 1 position in list new_l */
/* now the list new_l is 1 100 2 3 4 5 10 20 30 40 */
l.insert(l.begin(), 5, 10); // insert 10 before beginning 5 times

/* now l is 10 10 10 10 10 1 100 2 3 4 5 */
return 0;
}
push_backy push_frontfunciones
push_back(element) El método se utiliza para insertar elementos en una lista
desde atrás.
push_front(element) El método se utiliza para insertar elementos en una lista

desde el frente.
#include <iostream>
#include <list>
int main()
{
list<int> l{1,2,3,4,5};
l.push_back(6);
l.push_back(7);
/* now the list becomes 1,2,3,4,5,6,7 */
l.push_front(8);
l.push_front(9);
/* now the list becomes 9,8,1,2,3,4,5,6,7 */
pop_backy pop_frontfunciones
pop_front() elimina el primer elemento del inicio de la

lista. Mientras pop_back()elimina el primer elemento del final de la lista.
#include <iostream>
#include <list>
int main()
{
list<int> l{1,2,3,4,5};
l.pop_back()();
/* now the list becomes 1,2,3,4 */
l.pop_front()();
/* now the list becomes 2,3,4 */
}
empty función
Este método devuelve verdadero si la lista está vacía; de lo contrario, devuelve
falso.
size función
Este método se puede usar para encontrar el número de elementos presentes
en la lista.
front and back función

front()se usa para obtener el primer elemento de la lista desde el principio,
mientras que back()se usa para obtener el primer elemento de la lista desde
atrás.
swap función
Intercambia dos listas, si se produce una excepción al intercambiar cualquier
elemento, swap()arroja una excepción. Ambas listas que deben intercambiarse
deben ser del mismo tipo, es decir, no puede intercambiar la lista de un número
entero con la lista de cadenas.
reverse función
Este método puede usarse para revertir una lista por completo.
#include <iostream>
#include <list>
int main()
{
list<int> l{1,2,3,4,5};
l.reverse();
/* now the list becomes 5,4,3,2,1 */
}
sort función
sort()El método ordena la lista dada. No crea una nueva lista ordenada, pero
cambia la posición de los elementos dentro de una lista existente para
ordenarla. Este método tiene dos variaciones:
• sort() : ordena los elementos de la lista en orden ascendente, el elemento

de la lista debe ser numérico para esta función.
• sort(compare_function): Este tipo de sort () se usa cuando tenemos que

modificar el método de clasificación. Es muy útil para los elementos que
no son numéricos. Podemos definir cómo queremos ordenar los
elementos de la lista en compare_funtion. Por ejemplo, la lista de cadenas
se puede ordenar por la longitud de la cadena, también se puede usar
para ordenar en orden descendente.
#include <iostream>
#include <list>
bool compare_function( string& s1 , string& s2 )

{
return ( s1.length() > s2.length() );
}
int main()
{
list<int> list1 = {2,4,5,6,1,3};
list<string> list2 = {"h", "hhh", "hh"};
list1.sort();
/* list1 is now 1 2 3 4 5 6 */
list2.sort(compare_function);
/* list2 is now h hh hhh */
}
splice función
splice()El método transfiere los elementos de una lista a otra. Hay tres versiones
de empalme:
• splice(iterator, list_name): Transfiere la lista completa nombre_lista en la

posición señalada por el iterador .
• splice(iterator, list_name, iterator_pos): Elementos de transferencia

señalaron por iterator_pos de LIST_NAME en la posición apuntada
por iterador .
• splice(iterator, list_name, itr_start, itr_end): Rango de transferencia

especificado por itr_start e itr_end desde list_name en la posición
apuntada por el iterador .
#include <iostream>
#include <list>
int main ()
{
list<int> list1 = {1,2,3,4};
list<int> list2 = {5,6,7,8};
list<int>::iterator it;
it = list1.begin();
++it; //pointing to second position
list1.splice(it, list2);
/* transfer all elements of list2 at position 2 in list1 */
/* now list1 is 1 5 6 7 8 2 3 4 and list2 is empty */
list2.splice(list2.begin(), list1, it);

/* transfer element pointed by it in list1 to the beginning of list2 */
/* list2 is now 5 and list1 is 1 6 7 8 2 3 4*/
return 0;
}
merge función
Fusiona dos listas ordenadas. Es obligatorio que ambas listas se ordenen
primero. merge()combina las dos listas de modo que cada elemento se coloque
en su posición correcta en la lista resultante. La sintaxis para fusionar
es list1.merge(list2).
La lista que se pasa como parámetro no se elimina y la lista que llama a merge
() se convierte en la lista fusionada.
#include <iostream>
#include <list>
int main ()
{
list<int> list1 = {1,3,5,7,9};
list<int> list2 = {2,4,6,8,10};
/* both the lists are sorted. In case they are not ,

first they should be sorted by sort function() */
list1.merge(list2);
/* list list1 is now 1,2,3,4,5,6,7,8,9,10 */
cout << list1.size() << endl; // prints 10

}
Listas de comparación lexicográfica
Como las listas son una colección de elementos, no tienen un valor estándar
propio. Por lo tanto, para comparar listas o vectores, comparamos sus elementos
en su orden lexicográfico.
Por ejemplo, dejemos que list1 = {1, 2, 3} y list2 = {1, 3, 2}, ahora si queremos
verificar si list1 es mayor que list2 o no, solo verificamos el elemento de cada
lista en el ordenar que aparezcan en las listas. Como 1 en la lista1 es igual a 1
en la lista2, procedemos más, ahora 2 en la lista1 es más pequeño que 3 en la
lista2, por lo tanto, la lista2 es lexicográficamente mayor que la lista1.
Operadores ==, >, < , <=, >=se pueden utilizar para comparar la lista de orden
lexicográfico.
Contenedor MAP en STL

Los mapas se utilizan para replicar matrices asociativas. Los mapas
contienen un par clave-valor ordenado , en el que cada clave es única y no se
puede cambiar, y se puede insertar o eliminar, pero no se puede modificar. El
valor asociado con las claves puede ser alterado. Podemos buscar, eliminar e
insertar en un mapa dentro de la O(n)complejidad del tiempo.
Por ejemplo: un mapa de estudiantes donde el número de rollo es la clave y

el nombre es el valor puede representarse gráficamente como:
Tenga en cuenta que las claves están organizadas en orden ascendente, es

porque los mapas siempre organizan sus claves en orden ordenado. En caso de
que las claves sean de tipo cadena, se ordenan lexicográficamente.
Crear un mapa en C ++ STL

Los mapas se pueden crear fácilmente con la siguiente declaración:
map<key_type , value_type> map_name;

Esto creará un mapa con clave de tipo Key_type y valor de
tipo value_type . Una cosa que debe recordarse es que la clave de un mapa y
los valores correspondientes siempre se insertan como un par, no puede insertar
solo la clave o solo un valor en un mapa.
Aquí hay un programa que ilustrará la creación de un mapa de diferentes

maneras:
#include <iostream>
#include <map>
int main ()
{
map<int,int> m{ {1,2} , {2,3} , {3,4} };
/* creates a map m with keys 1,2,3 and
their corresponding values 2,3,4 */
map<string,int> map1;
/* creates a map with keys of type character and
values of type integer */
map1["abc"]=100; // inserts key = "abc" with value = 100

map1["b"]=200; // inserts key = "b" with value = 200
map1["c"]=300; // inserts key = "c" with value = 300
map1["def"]=400; // inserts key = "def" with value = 400
map<char,int> map2 (map1.begin(), map1.end());

/* creates a map map2 which have entries copied
from map1.begin() to map1.end() */
map<char,int> map3 (m);

/* creates map map3 which is a copy of map m */
}
Funciones de miembro de Map en C ++

STL
Las siguientes son algunas de las funciones comúnmente utilizadas del
contenedor de mapas en STL:
at y [ ]
Tanto en y [ ]se utilizan para acceder a los elementos en el mapa. La única
diferencia entre ellos es que en una excepción si la clave de acceso no está
presente en el mapa, por el otro lado del operador [ ]inserta la llave en el mapa
si la clave no está ya presente en el mapa.
#include <iostream>
#include <map>
int main ()
{
map<int,string> m{ {1,”nikhilesh”} , {2,”shrikant”} , {3,”ashish”} };
cout << m.at(1) ; // prints value associated with key 1 ,i.e nikhilesh
cout << m.at(2) ; // prints value associated with key 2 ,i.e shrikant
/* note that the parameters in the above at() are the keys not the index */
cout << m[3] ; // prints value associated with key 3 , i.e ashish
m.at(1) = "vikas"; // changes the value associated with key 1 to vikas

m[2] = "navneet"; // changes the value associated with key 2 to navneet
m[4] = "doodrah";
/* since there is no key with value 4 in the map,
it insert a key-value pair in map with key=4 and value = doodrah */
m.at(5) = "umeshwa";
/* since there is no key with value 5 in the map ,
it throws an exception */
}
empty, sizeymax_size
empty()devuelve boolean verdadero si el mapa está vacío, de lo contrario
devuelve booleano falso. size()devuelve el número de entradas en el mapa, una
entrada consta de una clave y un valor. max_size()devuelve el límite superior de
las entradas que puede contener un mapa (entradas máximas posibles) en
función de la memoria asignada al mapa.
insert y insert_or_assign
insert()se usa para insertar entradas en el mapa. Como las claves son únicas en
un mapa, primero verifica si la clave dada ya está presente en el mapa o no, si
está presente, la entrada no se inserta en el mapa y el iterador de la clave
existente se devuelve; de lo contrario, la nueva entrada es insertado en el mapa.
Hay dos variaciones de insert ():
• insert(pair) : En esta variación, se inserta un par de clave y valor en el

mapa. El par insertado siempre se inserta en la posición adecuada, ya
que las teclas están ordenadas en orden.
• insert(start_itr , end_itr): Esta variación inserta las entradas en el rango
definido por start_itr y end_itr de otro mapa.
El insert_or_assing()funciona exactamente como insert (), excepto que si la clave

dada ya está presente en el mapa a continuación, su valor se modifica.
#include <iostream>
#include <map>
int main ()
{
map<int,int> m{{1,2} , {2,3} , {3,4} };
m.insert( pair<int,int> (4,5));

/* inserts a new entry of key = 4 and value = 5 in map m */
/* make_pair() can also be used for creating a pair */

m.insert( make_pair(5, 6));
/* inserts a new entry of key = 5 and value = 6 */
map::iterator i , j;
i = m.find(2); // points to entry having key =2
j = m.find(5); // points to entry having key =5
map<int,int> new_m;
new_m.insert(i,j);
/* insert all the entries which are pointed
by iterator i to iterator j*/
m.insert( make_pair(3,6));
// do not insert the pair as map m already contain key = 3 */
m.insert_or_assign( make_pair(3,6)); // assign value = 6 to key =3

}
erase y clear
erase()elimina la entrada del mapa señalado por el iterador (que se pasa como
parámetro), sin embargo, si queremos eliminar todos los elementos del mapa,
podemos usarlo clear(), borra el mapa y establece su tamaño en 0.
Hay dos variaciones de borrado:
• erase(iterator_itr): Esto elimina la entrada del mapa señalada por

iterator iterator_itr , reduciendo el tamaño del mapa en 1.
• erase(start_iterator, end_iterator): Elimina los elementos en el rango
especificado por start_iterator y end_iterator .
begin, endyfind
comenzar, finalizar y buscar devuelve un iterador. begin()devuelve el iterador a
la entrada inicial del mapa, end()devuelve el iterador junto a la última entrada en
el mapa y find()devuelve el iterador a la entrada que tiene una clave igual a la
clave dada (pasada como parámetro).
Contenedor STACK en C ++ STL

El contenedor de pila se usa para replicar pilas en c ++, la inserción y eliminación
siempre se realiza en la parte superior de la pila.
Para saber más acerca de la estructura de datos de la pila, visite: Estructura pila
de datos
Aquí está la sintaxis de definir una pila en STL:
stack<object_type> stack_name;
La declaración anterior creará una pila llamada stack_name de tipo object_type
Funciones de miembro de Stack Container

Las siguientes son algunas de las funciones más utilizadas de Stack container
en STL:
push función
push () se usa para insertar el elemento en la pila, los elementos se insertan en
la parte superior de la pila.
#include <iostream>
#include <stack>
int main ()
{
stack<int> s; // creates an empty stack of integer s
s.push(2); // pushes 2 in the stack , now top =2

s.push(3); // pushes 3 in the stack , now top =3
pop función
Este método se usa para eliminar un solo elemento de la pila. Reduce el tamaño
de la pila en 1. El elemento eliminado siempre es el elemento superior de la pila
(elemento agregado más recientemente). El pop()método no devuelve nada.
top función
Este método devuelve el elemento superior de la pila. Tenga en cuenta que este
método devuelve el elemento, no lo elimina, a diferencia de pop ().
SINTAXIS: top()
sizey emptyfunciones
size()devuelve el número de elementos presentes en la pila, mientras
que empty()verifica si la pila está vacía o no. vacío devuelve verdadero si la pila
está vacía, de lo contrario se devuelve falso.
swap función
Este método intercambia los elementos de las dos pilas.
#include <iostream>
#include <stack>
int main ()
{
stack<int> s;
// pushing elements into stack

s.push(2);
s.push(3);
s.push(4);
cout << s.top(); // prints 4, as 4 is the topmost element

cout << s.size(); // prints 3, as there are 3 elements in
}
Contenedor de cola en STL

El contenedor de la cola se usa para replicar la cola en C ++, la inserción siempre
se realiza en la parte posterior de la cola y la eliminación siempre se realiza en
la parte delantera de la cola.
Aquí está la sintaxis para definir una cola:
queue< object_type > queue_name;
La instrucción anterior creará una cola llamada queue_name de tipo object_type.

Funciones de miembro del contenedor de cola.
Las siguientes son algunas de las funciones comúnmente utilizadas de Queue

Container en STL:
push función
push()se usa para insertar el elemento en la cola. El elemento se inserta en la
parte posterior o posterior de la cola.
#include <iostream>
#include <queue>

int main ()
{
queue <int> q; // creates an empty queue of integer q
q.push>(2); // pushes 2 in the queue , now front = back = 2

q.push(3); // pushes 3 in the queue , now front = 2 , and back = 3
}
pop función
Este método elimina un solo elemento del frente de la cola y, por lo tanto, reduce
su tamaño en 1. El elemento eliminado es el elemento que se ingresó
primero. El pop()no devuelve nada.
#include <iostream>
#include <queue>
int main ()
{
queue <int> q; // creates an empty queue of integer q
q.push>(2); // pushes 2 in the queue , now front = back = 2

q.push(3); // pushes 3 in the queue , now front = 2 , and back = 3
q.pop() ; // removes 2 from the stack , front = 3

}
front and back funciones

front()devuelve el elemento frontal de la cola mientras que back()devuelve el
elemento en la parte posterior de la cola. Tenga en cuenta que ambos devuelven
el elemento, no lo eliminan, a diferencia de pop () .
sizey emptyfunciones
size()devuelve el número de elementos presentes en la cola, mientras
que empty()verifica si la cola está vacía o no. vacío devuelve verdadero si la cola
está vacía, de lo contrario se devuelve falso.
Swap función
Método swap()Intercambia los elementos de las dos colas.
Contenedor PRIORITY QUEUE en C ++

STL
priority_queuees como una cola normal, excepto que el elemento eliminado de
la cola siempre es el mejor entre todos los elementos de la cola, por lo tanto, este
contenedor se usa generalmente para replicar Max Heap en C ++. Los
elementos se pueden insertar en cualquier orden y tiene O(log(n))una
complejidad de tiempo para la inserción.
La siguiente es la sintaxis para crear una cola prioritaria:
priority_queue<int> pq;
Función de miembro de la cola de

prioridad
Las siguientes son algunas de las funciones comúnmente utilizadas de Priority
Queue Container en STL:
push función
Este método inserta un elemento en la prioridad_queue. La inserción de los
elementos tiene una complejidad temporal del tiempo logarítmico.
#include <iostream>>
#include <queue>
int main ()
{
priority_queue<int> pq1;
pq1.push(30); // inserts 30 to pq1 , now top = 30

pq1.push(40); // inserts 40 to pq1 , now top = 40 ( maxinmum element)
pq1.push(60); // inserts 60 to pq1 , top still is 90
return 0;
}
pop función
Este método elimina el elemento superior de la prioridad_queue (elemento
mayor), reduciendo el tamaño de la cola de prioridad en 1.
#include <iostream>>
#include <queue>
int main ()
{
priority_queue<int> pq1;
pq1.push(40); // inserts 40 to pq1 , now top = 40 ( maxinmum element)
pq1.push(60); // inserts 60 to pq1 , top still is 90
pq1.pop(); // removes 90 ( greatest element in the queue
return 0;
}
top función
Este método devuelve el elemento en la parte superior de priority_queue, que es
el elemento más grande presente en la cola.
emptyy sizefunciones
size()devuelve el número de elemento presente en la prioridad _queue, mientras
que empty()devuelve booleano verdadero si la prioridad_queue está vacía; de lo
contrario, se devuelve booleano falso.
swap función
Este método intercambia los elementos de dos priority_queue.
DEQUE Contenedor en C ++ STL

Deque es una abreviatura de cola doblemente terminada . Deque permite una
inserción y eliminación rápidas en ambos extremos de la cola. Aunque también
podemos usar el contenedor de vectores para la inserción y eliminación en
ambos extremos, pero la inserción y eliminación en la parte frontal de la matriz
es más costosa que en la parte posterior, en caso de deque pero deque son más
complejos internamente.
La sintaxis para crear una Deque es:
deque< object_type > deque_name;
Funciones de miembro de Deque

Las siguientes son algunas de las funciones comúnmente utilizadas de Deque
Container en STL:
push_back, push_frontY insertfunciones

push_back(element e)inserta un elemento e en la parte posterior de la
calcomanía, push_front(element e)inserta el elemento e en la parte frontal de la
calcomanía.
insert() El método tiene tres variaciones:

• insert(iterator i, element e): Inserta el elemento e en la posición apuntada
por el iterador i en la deque.
• insert(iterator i, int count, element e): Inserta el elemento e , cuenta
el número de veces desde la posición señalada por el iterador i .
• insert(iterator i, iterator first, iterator last): Inserta el elemento en el rango

[primero, último] en la posición apuntada por el iterador i en deque.
#include <iostream>
#include <deque>
#include <vector>
int main ()
{
int a[] = { 1,5,8,9,3 };

deque<int> dq(a, a+5);
/* creates s deque with elements 1,5,8,9,3 */
dq.push_back(10);
/* now dq is : 1,5,8,9,3,10 */
dq.push_front(20);
/* now dq is : 20,1,5,8,9,3,10 */
deque<int>::iterator i;
i=dq.begin()+2;
/* i points to 3rd element in dq */
dq.insert(i,15);
/* now dq 20,1,15,5,8,9,3,10 */
int a[]={7,7,7,7};
d1.insert(dq.begin() , a , a+4 );
/* now dq is 7,7,7,7,20,1,15,5,8,9,3,10 */
}
pop_backy pop_frontfunciones
pop_back()elimina un elemento de la parte posterior de la calcomanía, mientras
que pop_frontelimina un elemento de la parte frontal de la calcomanía, ambos
disminuyen el tamaño de la calcomanía en uno.
#include <iostream>
#include <deque>
#include <vector>

int main ()
{
int a[] = { 1,5,8,9,3,5,6,4 };

deque<int> dq(a,a+8);
/* creates s deque with elements 1,5,8,9,3,5,6,4 */
dq.pop_back();
/* removes an element from the back */
/* now the deque dq is : 1,5,8,9,3,5,6 */
dq.pop_front();
/* now dq is : 1,5,8,9,3,5,6 */
}
empty, sizeY max_sizefunciones

empty()devuelve booleano verdadero si la deque está vacía, de lo contrario se
devuelve booleano falso. size()devuelve el número de elementos presentes en
la deque y max_size()devuelve el número de elementos que puede contener la
deque dada.
swap función
Este método puede usarse para intercambiar elementos de dos deques.
Descripción general de iteradores en C

++ STL
Como hemos discutido anteriormente, los iteradores se usan para señalar los
contenedores en STL, debido a los iteradores es posible que un algoritmo
manipule diferentes tipos de estructuras de datos / contenedores.
Los algoritmos en STL no funcionan en contenedores, sino que funcionan en

iteradores, manipulan los datos apuntados por los iteradores. Por lo tanto, no
importa cuál sea el tipo de contenedor y, debido a esto, un algoritmo funcionará
para cualquier tipo de elemento y no tenemos que definir el mismo algoritmo para
diferentes tipos de contenedores.
El diagrama anterior muestra a los iteradores i y j , que apuntan al principio y al
final de un vector.
DEFINICIÓN DE UN ITERADOR EN STL

La sintaxis para definir un iterador es:
container_type <parameter_list>::iterator iterator_name;
Veamos un ejemplo para comprender los iteradores de una mejor manera:
#include<iostream>
#include<vector>
int main()
{
vector<int>::iterator i;
/* create an iterator named i to a vector of integers */
vector<string>::iterator j;
/* create an iterator named j to a vector of strings */
list<int>::iterator k;
/* create an iterator named k to a vector of integers */
map<int, int>::iterator l;
/* create an iterator named l to a map of integers */
}
Los iteradores pueden usarse para atravesar el contenedor, y podemos

desreferenciar el iterador para obtener el valor del elemento al que apunta.
Aquí hay un ejemplo:
#include<iostream>
#include<vector>
int main()
{
vector<int> v(10);
/* creates an vector v : 0,0,0,0,0,0,0,0,0,0 */
vector<int>::iterator i;
for(i = v.begin(); i! = v.end(); i++)

cout << *i <<" ";
/* in the above for loop iterator I iterates though the
vector v and *operator is used of printing the element
pointed by it. */
return 0;
}
Operaciones en iteradores en STL

Las siguientes son las operaciones que se pueden usar con Iteradores para
realizar diversas acciones.
• avanzar
• distancia
• siguiente
• prev
• empezar
• fin
advance() Operación
Incrementará el iterador i por el valor de la distancia. Si el valor de la distancia
es negativo, se disminuirá el iterador.
SINTAXIS: advance(iterator i ,int distance)
#include<iostream>
#include<vector>
int main()
{
vector<int> v(10) ; // create a vector of 10 0's
vector<int>::iterator i; // defines an iterator i to the vector of integers
i = v.begin();
/* i now points to the beginning of the vector v */
advance(i,5);
/* i now points to the fifth element form the
beginning of the vector v */
advance(i,-1);
/* i now points to the fourth element from the
beginning of the vector */
}
distance() Operación
Devolverá el número de elementos o podemos decir la distancia entre el primer
y el último iterador.
SINTAXIS: distance(iterator first, iterator last)

#include<iostream>
#include<vector>
int main()
{
vector<int> v(10) ; // create a vector of 10 0's
vector<int>::iterator i, j; // defines iterators i,j to the vector of integers
i = v.begin();
/* i now points to the beginning of the vector v */
j = v.end();
/* j now points to the end() of the vector v */
cout << distance(i,j) << endl;

/* prints 10 , */
next() Operación
Devolverá el enésimo iterador a i , es decir, el iterador que señala al enésimo
elemento desde el elemento señalado por i.
SINTAXIS: next(iterator i ,int n)
prev() Operación
Devolverá el enésimo predecesor a i , es decir, el iterador que señala al
enésimo elemento predecesor desde el elemento señalado por i.
SINTAXIS: prev(iterator i, int n)
begin() Operación
Este método devuelve un iterador al inicio del contenedor dado.
SINTAXIS: begin()
end() Operación
Este método devuelve un iterador al final del contenedor dado.
SINTAXIS: end()
Descripción general de los algoritmos

en C ++ STL
STL proporciona diferentes tipos de algoritmos que se pueden implementar en
cualquiera de los contenedores con la ayuda de iteradores. Por lo tanto, ahora
no tenemos que definir un algoritmo complejo, sino que solo usamos las
funciones integradas proporcionadas por la biblioteca de algoritmos en STL.
Como ya se discutió anteriormente, las funciones de algoritmo proporcionadas
por la biblioteca de algoritmos funcionan en los iteradores, no en los
contenedores. Por lo tanto, una función de algoritmo se puede utilizar en
cualquier tipo de contenedor.
El uso de algoritmos de STL ahorra tiempo, esfuerzo, código y es muy confiable.

Por ejemplo, para implementar la búsqueda binaria en C ++, tendríamos que
escribir una función como:
bool binary_search( int l , int r , int key ,int a[])

{
if(l > r)
return -1;
else
{
int mid=(l+r)/2;
if(a[mid] == key)
{
return true;
}
else if(a[mid] > key)
{
return binary_search(l, mid-1, key, a);
}
else if(a[mid] < key)
{
return binary_search(mid+1, r, key, a);
}
}
}
Tenga en cuenta que la función anterior solo funcionará si la matriz es de

números enteros y caracteres.
Pero en STL solo podemos usar el binary_search()proporcionado por la

biblioteca de algoritmos para realizar una búsqueda binaria. Ya está definido en
la biblioteca como:
return binary_search(a, a+a.size())
Además, la función anterior funcionará en cualquier tipo de contenedor.

Tipos de algoritmos en la biblioteca de
algoritmos
1. Algoritmos de clasificación
2. Algoritmos de búsqueda
3. Algoritmos no modificables
4. Modificando algoritmos
5. Algoritmos numéricos
6. Operaciones mínimas y máximas.
Algoritmos de clasificación en STL

Estudiaremos tres métodos en Algoritmos de clasificación, a saber:
• ordenar
• se clasifica
• parcial_sort
sort método
Esta función de STL, ordena el contenido del rango dado. Hay dos versiones de
sort ():
1. sort(start_iterator, end_iterator ) : ordena el rango definido por iteradores

start_iterator y end_iterator en orden ascendente.
2. sort(start_iterator, end_iterator, compare_function) : esto también ordena

el rango dado pero puede definir cómo se debe hacer la clasificación
mediante compare_function.
#include<iostream>
#include<algorithm>
#include<vector>
bool compare_function(int i, int j)

{
return i > j; // return 1 if i>j else 0
}
bool compare_string(string i, string j)
{
return (i.size() < j.size());
}
int main()
{
int arr[5] = {1,5,8,4,2};
sort(arr , arr+5); // sorts arr[0] to arr[4] in ascending order

/* now the arr is 1,2,4,5,8 */
vector<int> v1;
v1.push_back(8);
v1.push_back(4);
v1.push_back(5);
v1.push_back(1);
/* now the vector v1 is 8,4,5,1 */

vector<int>::iterator i, j;
i = v1.begin(); // i now points to beginning of the vector v1

j = v1.end(); // j now points to end of the vector v1
sort(i,j); //sort(v1.begin() , v1.end() ) can also be used

/* use of compare_function */
int a2[] = { 4,3,6,5,6,8,4,3,6 };
sort(a2,a2+9,compare_function); // sorts a2 in descending order

/* here we have used compare_function which uses operator(>),
that result into sorting in descending order */
/* compare_function is also used to sort non-numeric elements such as*/
string s[]={"a" , "abc", "ab" , "abcde"};
sort(s,s+4,compare_string);
/* now s is "a","ab","abc","abcde" */
}
partial_sort método
partial_sort()clasifica los primeros elementos de la mitad en el rango dado, los
otros elementos de la mitad permanecen como estaban inicialmente. partial_sort
() también tiene dos variaciones:
• partial_sort(start, middle, end ) : ordena el rango de principio a fin de

manera que los elementos antes del medio estén en orden ascendente y
sean los elementos más pequeños del rango.
• partial_sort(start, middle, end, compare_function) : ordena el rango de

principio a fin de tal manera que los elementos antes del medio se ordenan
con la ayuda de compare_function y son los elementos más pequeños del
rango.
#include<iostream>
#include<algorithm>
#include<vector>
int main()
{
int a[] = {9,8,7,6,5,4,3,2,1};
partial_sort(a, a+4, a+9);

/* now a is 1,2,3,4,9,8,7,6,5 */
int b[] = {1,5,6,2,4,8,9,3,7};
/* sorts b such that first 4 elements are the greatest elements

in the array and are in descending order */
partial_sort(b, b+4, b+9);
/* now b is 9,8,7,6,1,2,4,3,5 */
}
is_sorted método
Esta función de STL devuelve verdadero si se ordena el rango dado. Hay dos
versiones de is_sorted ():
1. is_sorted(start_iterator, end_iterator) : Comprueba el rango definido por

iteradores start_iterator y end_iterator en orden ascendente.
2. is_sorted(start_iterator, end_iterator, compare_function) : También

verifica el rango dado, pero puede definir cómo se debe hacer la
clasificación.
#include<iostream>
#include<algorithm>
#include<vector>
int main()
{
int a[5] = {1,5,8,4,2};
cout<<is_sorted(a, a+5);
/* prints 0 , Boolean false */
vector<int> v1;
v1.push_back(8);
v1.push_back(4);
v1.push_back(5);
v1.push_back(1);

cout<<is_sorted(v1.begin() , v1.end() );
/* prints 0 */
sort(v1.begin() , v1.end() );
/* sorts the vector v1 */
cout<<is_sorted(v1.begin() , v1.end());
/* prints 1 , as vector v1 is sorted */
}
Algoritmo de búsqueda binaria en STL

Esta función devuelve Boolean verdadero si el elemento está presente en el
rango dado, de lo contrario, se devuelve Boolean falso. Hay dos variaciones de
binary_search ():
• binary_search(first, last, value): esta versión devuelve verdadero si hay un

elemento presente, satisfaciendo la condición (! (a <valor) &&! (valor <a))
en el rango dado, es decir, del primero al último, en otras palabras, el
operador (<) es se usa para verificar la igualdad de los dos elementos.
• binary_search(first, last, value, compare_function) : esta versión devuelve

verdadero si hay un elemento presente en el rango dado, es decir, del
primero al último.
Tenga en cuenta que first y last son iteradores y el elemento señalado por last
se excluye de la búsqueda.
Aquí no tenemos que ordenar primero el contenedor de elementos,

binary_search () hará todo el trabajo por nosotros, solo tenemos que dar un
rango y un valor para buscar.
#include <iostream>
#include <algorithm>
#include <vector>
bool compare_string_by_length (string i,string j)

{
return (i.size() == j.size());
}
int main ()
{
int inputs[] = {7,8,4,1,6,5,9,4};
vector<int> v(inputs, inputs+8);
cout<<binary_search(v.begin() , v.end() , 7 ); //prints 1 , Boolean true
cout<<binary_search(v.begin() , v.end() , 217); //prints 0 , Boolean false
/* compare_function can be used to search

non numeric elements based on their properties */
string s[] = { "test" , "abcdf" , "efghijkl" , "pop" };
cout<<binary_search(s, s+4, "nickt" , compare_string_by_length);

/* search for the string in s which have same length as of "nicky" */
Algoritmo de rango igual en STL

equal_range
equal_range()devuelve un par de iteradores donde los iteradores representan el
sub rango de elementos en el rango dado que son iguales al valor dado o
satisfacen la función compare_function . El rango dado ya debería estar
ordenado. Hay dos variaciones de equal_range:
• equal_range(first, last, value) : devuelve un par de iteradores que

representan el subrango de (primero, último) que tienen elementos
iguales al valor.
• equal_range(first, last, value, compare_function) : devuelve un par de

iteradores que representan el subrango de (primero, último) que tienen
elementos que satisfacen la función de comparación con el valor.
#include <iostream>
#include <vector>
bool compare_function (int i,int j)

{
return (i <= j);
}
int main ()
{
int input[] = {1,1,1,2,2,2,3,3,6,7,7,7,7,7,8,9};
vector v(input, input+16);
pair< vector<int>::iterator, vector<int>::iterator > sub_range;

/* defining the pair of two iterators to an integer vector */
sub_range = equal_range (v.begin(), v.end(), 2);
/* now sub_range.first points to 4th element in the vector v and
sub_range.second points to 7th element ,
note that sub_range.secong points to the element
which is next to the element in the subrange */
sub_range = equal_range (v.begin(), v.end(), 20, compare_function);

/* sub_range.first points to first element in the vector v ,
as it satisfy the condition exerted by compare_function , <= ,
sub_range.second points to 7th element in the vector . */
}
Límite superior y Límite inferior Buscar

Algo en STL
upper_bound()devuelve un iterador a los elementos en el rango dado que no
compara más que el valor dado. El rango dado ya debería estar ordenado para
que upper_bound () funcione correctamente. En otras palabras, devuelve un
iterador al límite superior del elemento dado en el rango ordenado dado.
#include <iostream>
#include <vector>
int main ()
{
int input[] = {1,2,2,3,4,4,5,6,7,8,10,45};
vector<int> v(input, input+12);
vector<int>::iterator it1 , it2;
it1 = upper_bound(v.begin(), v.end(), 6);

/* points to eight element in v */
it2 = upper_bound(v.begin(), v.end(), 4);

/* points to seventh element in v */
}
lower_bound método
lower_bound()devuelve un iterador a los elementos en el rango dado que no
compara menos que el valor dado. El rango dado ya debería estar ordenado para
que lower_bound () funcione correctamente. En otras palabras, devuelve un
iterador al límite inferior del elemento dado en el rango ordenado dado.
#include <iostream>
#include <vector>
int main ()
{
int input[] = {1,2,2,3,4,4,5,6,7,8,10,45};
vector<int> v(input,input+12);
vector<int>::iterator it1 , it2;
it1 = lower_bound(v.begin(), v.end(), 4);

/* points to fifth element in v */
it2 = lower_bound (v.begin(), v.end(), 10);

/* points to second last element in v */
}
Algoritmos no modificantes en C ++ STL

Los siguientes son algunos algoritmos no modificables en la biblioteca de
plantillas estándar que cubriremos:
• contar
• igual
• discordancia
• buscar
• buscar_n
count método
count()devuelve el número de elementos en el rango dado que son iguales al
valor dado. La sintaxis para contar es:
count(first ,last ,value) : Esto devolverá el número del elemento en el rango

definido por los iteradores primero y último (excluidos) que son iguales (==) al
valor.
#include <iostream>
#include <vector>
int main ()
{
int values[] = {5,1,6,9,10,1,12,5,5,5,1,8,9,7,46};
int count_5 = count(values, values+15, 5);

/* now count_5 is equal to 4 */
vector<int> v(values, values+15);
int count_1 = count(v.begin(), v.end(), 1);

/* now count_1 is equal to */
return 0;
}
equal método
equal()compara los elementos en dos rangos, si todos los elementos en un rango
se comparan iguales a sus elementos correspondientes en otro rango, se
devuelve Boolean true, de lo contrario se devuelve Boolean false. Hay dos
variaciones:
• equal(first1, last1, first2): Esta función compara la igualdad de elementos

en el rango señalado por first1 y last1 (excluido) al rango con la posición
inicial first2. Si todos los elementos son iguales, se devuelve verdadero,
de lo contrario, es falso.
• equal(first1 ,last1 ,first2 ,cmp_function) : Aquí la función cmp_function se

usa para decidir cómo verificar la igualdad de dos elementos, es útil para
elementos no numéricos como cadenas y objetos.
#include <iostream>
#include <vector>
bool cmp_string(string i, string j)

{
return (i.size() == j.size());
}
int main()
{
int inputs1[] = { 1,2,3,4,5,6,7,8};
int inputs2[] = { -1,2,1,2,3,4,6,7,8,9};
vector<int> v1(inputs1 , inputs1+9 );

vector<int> v2(inputs2 , inputs2+10 );
cout<<equal(v1.begin(), v1.end(), v2.begin()+2 ) ; // prints 0 , boolean false
/* use of compare function */

string s1[] = { "abc" , "def" , "temp" , "testing" };
string s2[] = { "xyz" , "emp" , "resr" , "testing" };
cout<<equal( s1 , s1+4 , s2 , cmp_string); // prints 1

/* note that the stings in s1 and s2 are not actually
equal but still equal() returns 1 , beacause we are defining
equality of two string by their length in cmp_function */
}
mismatch método
Este método devuelve un par de iteradores, donde el primer iterador del par
apunta al elemento en el primer contenedor y el segundo iterador apunta al
elemento en el segundo contenedor donde se ha producido una falta de
coincidencia. Hay dos variaciones de mismatch().
• mismatch(first1, last1, first2): Aquí first1 y last1 son los iteradores al

primer recipiente que especifican la gama y primero2 es el iterador al
segundo recipiente que especifica la posición dónde empezar la
comparación. Los elementos se verifican por defecto para la
igualdad == y el par de iteradores se devuelve dando la posición de los
elementos donde se ha producido una falta de coincidencia.
• mismatch(first1, last1, first2, compare_function): Esta versión funciona

igual que la anterior, excepto que compare_function se usa para
verificar si los elementos deben considerarse iguales o no.
#include<iostream>
#include<algorithm>
#include<vector>
bool cmp_string(string i , string j)

{
return ( i.size() == j.size() );
}
int main()
{
int inputs1[] = {1,2,3,4,5,6,7,8};
int inputs1[] = {-1,2,1,2,3,4,6,7,8,9};
vector<int> v1(inputs1 ,inputs1+9);

vector<int> v2(inputs2 ,inputs2+9);
pair<vector<int<::iterartor, vector<int>::iterator> position;

/* defining a pair of iterator to the vector of integer */
position = mismatch(v1.begin(), v1.end(), v2.begin()+2) ;
/* now position.first is an iterator pointing

to the 5th element in the vector v1 and position.second
points to the 7th element in the vector v2 */
/* use of compare function */

string s1[] = {"abc", "def", "temp", "testing"};
string s2[] = {"xyz", "emp", "res", "testing"};
pair<string::iterator, string::iterator> position2;
position2 = mismatch( s1, s1+4, s2, cmp_string);

/* now position2.first is an iterator pointing
to the 3rd element in s1 and position2.second points
to the 3rd element in the s2 */
}
search método
Esta función se utiliza para realizar búsquedas de una secuencia dada en
un rango dado . Hay dos variaciones de search():
• search(first1 ,last1 ,first2 ,last2): Esta función busca la secuencia definida

por primero2 y ultimo2 en el intervalo first1 y last1 (donde se excluye
last1). Si hay una coincidencia, se devuelve un iterador al primer elemento
de la secuencia en el rango [first1, last1], de lo contrario, se devuelve el
iterador a last1.
• search(first1 ,last1 ,first2 ,last2 ,cmp_functions): Aquí la

función cmp_function se usa para decidir cómo verificar la igualdad de
dos elementos, es útil para elementos no numéricos como cadenas y
objetos.
#include<iostream>
#include<algorithm>
#include<vector>
int main()
{
int inputs1[] = { 1,2,3,4,5,6,7,8};
int inputs2[] = { 2,3,4};
vector<int> v1(inputs1, inputs1+9);

vector<int>::iterator i ,j;
i = search(v1.begin(), v1.end(), v2.begin(), v2.end());
/* now i points to the second element in v1 */
j = search(v1.begin()+2, v1.end(), v2.begin(), v2.end());
/* j now points to the end of v1 as no sequence is equal to 2,3,4 in

[v1.begin()+2 ,v1.end()] */
}
search_n método
Este método busca en un rango dado una secuencia de un valor de conteo. Hay
dos variaciones de search():
• search(first1, last1, count, value): Este método búsquedas de una

secuencia de recuento y el valor en el intervalo definido por los
iteradores first1 y last1 (last1 se excluye). Si hay una coincidencia, se
devuelve un iterador al primer elemento de la secuencia en el rango [first1,
last1], de lo contrario, se devuelve el iterador a last1.
• search(first1, last1, count, value, cmp_functions): Aquí la

función cmp_function se usa para decidir cómo verificar la igualdad de
dos elementos, es útil para elementos no numéricos como cadenas y
objetos.
#include<iostream>
#include<algorithm>
#include<vector>
int main()
{
int inputs1[] = {1,2,3,4,4,4,8,5,6,7,8};

vector<int>::iterator I;
i = search_n(v1.begin(), v1.end(), 3, 4);
/* now i points to the 4th element in v1 */
j = search(v1.begin()+2, v1.end(), 2, 5);
/* j now points to the end of v1 as no sequence is equal to 5,5 in

[v1.begin()+2 ,v1.end() ). */
}
Modificación de algoritmos en C ++ STL

Los siguientes son algunos algoritmos de modificación en la biblioteca de
plantillas estándar que cubriremos:
• copiar y copiar_n
• llenar y llenar_n
• moverse
• transformar
• generar
• intercambiar
• swap_ranges
• marcha atrás
• copia inversa
• girar
• único
• copia_unica
copy y copy_n
Cubramos cada método uno por uno comenzando con el copymétodo:
copy método
Este método copia los elementos del rango definido por dos
iteradores primero y último en el rango que comienza por el iterador first2 .
#include <iostream>
#include <vector>
int main ()
{
vector<int> v1,v2;
v1.push(2);
v1.push(4);
v1.push(6);
v1.push(8);
v1.push(10);
copy(v1.begin(), v1.end(), v2.begin());
/* v2 is now 2,4,6,8,10 */
}
copy_n método
Esta función copia los primeros n elementos de la posición definida por los
iteradores primero en el rango que comienza por el iterador first2 .
#include <iostream>
#include <vector>
int main ()
{
int values[] = {1,2,3,4,5,6,7,8,9};
vector<int> v1(values, values+9), v2;
copy_n(v1.begin(), 5, v2.begin()); // copies first 5 elements from v1 to v2.

/* v2 is now 1,2,3,4,5 */
}
fill y fill_n
Cubramos cada método uno por uno comenzando con el fillmétodo:
fill método
Este método asigna al elemento un valor dado en el rango definido por dos
iteradores primero y último . La sintaxis para fill () es fill(iterator first, iterator
last, int value),.
#include <iostream>
#include <vector>
int main ()
{
vector<int> v1(10); // v1 is now 0,0,0,0,0,0,0,0,0,0
fill(v.begin(), v.end(), 5);
/* now v1 is 5,5,5,5,5,5,5,5,5,5 */
fill(v.begin(), v.end() - 5, 3);
/* now v11 is 3,3,3,3,3,5,5,5,5,5 */

}
fill_n método
Este método le asigna a los primeros n elementos un valor dado desde la
posición definida por el iterador primero . La sintaxis para fill_n esfill_n(iterator
first, iterator last, int value)
#include <iostream>
#include <vector>
int main ()
{
int values[] = {1,2,3,4,5,6,7,8,9};
vector<int> v1(values, values+9);
fill_n(v1.begin(), 5 ,10);
/* v1 is now 10,10,10,10,10,6,7,8,9 */
}
move método
Este método mueve los elementos del contenedor actual y devuelve
su referencia de valor r . La sintaxis para mover es move(element). move () está
disponible en C ++ 11 y superior.
#include <iostream>
#include <vector>
int main ()
{
string a = "nicky";
string b = "Vicky";
vector<string> name;
// inserts "nicky" in name , a is still = nicky

name.push_back(a);
// inserts "Vicky" in name , b is now NULL
name.push_back(move(b));
}
transform
transform aplica una operación unaria / binaria en un rango dado y copia el
resultado en el rango comenzando desde el iterador res . Hay dos versiones de
transform () que difieren según el tipo de operaciones realizadas en los
elementos.
• transform(iterator first1, iterator last1, iterator res, unaryoperation op):

Este método realiza la operación unaria op en los elementos en el rango
[first1, last1] y almacena el resultado en el rango a partir de res.
• transform(iterator first1, iterator last1, iterator first2, iterator res,

unaryoperation op): Este método realiza la operación binaria op en los
elementos en el rango [first1, last1] con los elementos en el rango
comenzando con el iterador first2 y almacena el resultado en el rango
comenzando desde res.
#include <iostream>
#include <vector>
int unaryoperation (int a)

{
return a*2;
}
int main()
{
vector<int> v1;
vector<int> v2;
vector<int> res1;
vector<int> res2;
for(int i=0; i < 10; i++)

{
v2.push_back(i);
v1.push_back(i*10);
}
/* v2 : 1,2,3,4,5,6,7,8,9 */
/* v1 : 10,20,30,40,50,60,70,80,90 */
res2.resize(10);
transform(v2.begin(), v2.end(), res1.begin(), unaryoperation);

/* now res1 is : 2,4,6,8,10,12,14,16,18 */
}
generate y generate_n
Cubramos cada método uno por uno comenzando con el generatemétodo:
generate método
Este método asigna todos los elementos en el rango dado al valor devuelto por
la llamada sucesiva a la función generate_element. La sintaxis
para generar es generate(iterator first, iterator last, generator_function
generate_element).
generate_n método
Este método asigna los primeros n elementos en el rango dado al valor devuelto
por la llamada sucesiva a la función generate_element. La sintaxis
para generar es generate(iterator first, int n, generator_function
generate_element).
#include <iostream>
#include <vector>
#include <time.h>
#include <cstdlib>
int generate_random()
{
return rand()%10;
}
int main()
{
srand(time(NULL));
vector<int> v1 , v2;
v1.resize(10);
v2.resize(10);
generate(v1.begin(), v1.end(), generate_random) ;
/* this assign each element a random value generated

by the generate_random() */
generate_n(v2.begin(), 5, generate_random);
/* this assign first 5 elements a random value

and rest of the elements are un changed */
}
swap Método
Este método intercambia los elementos de dos contenedores del mismo tipo.
#include <iostream>
#include <utility>
#include <vector>
int main ()
{
int a = 6;
int b = 9;
swap(a,b);
/* a = 9 , b=6 */
/* you can also swap an entire container with swap */
vector<int> v, c;
for(int j=0; j < 10; j++)
{
v.push_back(j);
c.push_back(j+1);
}
swap(v,c);
for(vector>int>::iterator i = v.begin(); i! = v.end(); i++)

cout<<*i<<" ";
cout<<endl;
for(vector<int>::iterator k = c.begin(); k! = c.end(); k++)

cout<< *k <<" ";
}
swap_ranges método
swap_ranges(iterator first1, iterato last1, iterato first2): Intercambia los elementos
en el rango [first1, last1] con los elementos presentes en el rango a partir
de first2 .
#include <iostream>
#include <utility>
#include <vector>
int main ()
{
vector<int> v, c;
for(int j=0; j < 10; j++)
{
v.push_back(j);
c.push_back(j+1);
}
swap_ranges(v.begin(), v.begin()+5, c.begin());
/* swaps the first five element of

vector v by the elements of vector c */
for(vector<int>::iterator i = v.begin(); i!= v.end(); i++)

cout<< *i <" ";
cout<<endl;
for(vector<int>::iterator k = c.begin(); k!= c.end(); k++)

cout<<*k<<" ";
}
reverse método
reverse(iterator first, iterator last) se usa para invertir el orden de los elementos
en el rango [primero, último].
#include <iostream>
#include <vector>
int main ()
{
int a[] = {1,5,4,9,8,6,1,3,5,4};
reverse(a, a+10);
/* reverse all the elements of the array a*/

/* now a is : 4,5,3,1,6,8,9,4,5,1 */
reverse(a, a+5);
/* reverse first 5 elements of the array a */

/* now a is : 6,1,3,5,4,8,9,4 */
vector<int> v(a, a+10);
reverse(v.begin(), v.end());
/* reverse the elements of the vector v */

/* vector is now 4,9,8,4,5,3,1,6 */
}
reverse_copy método
Este método copia los elementos en el rango dado en el orden inverso. No
cambia el orden del contenedor original. La sintaxis
para reverse_copy es reverse_copy(iterator first ,iterator last ,iterator res), copia
los elementos en el rango [primero, último] en el orden inverso al rango
comenzando por el iterador res .
#include <iostream>
#include <vector>
int main()
{
int values[] = {1,4,8,9,5,6,2,7,4,1};

/* v1 is now 1,4,8,9,5,6,2,7,4,1 */
vector<int> v2;
v2.resize(v1.size()); // allocate size for v2
reverse_copy(v1.begin(), v1.end(), v2.begin());

/* copies elements of v1 in reverse order in v2 */
/* now v2 is : 1,4,7,2,6,5,9,8,4,1 */
}
rotate método
Este método se utiliza para rotate(iterator first, iterator middle, iterator last)los
elementos presentes en el rango dado [primero, último] de modo que el elemento
señalado por el iterador central se convierta en el primer elemento.
#include <iostream>
#include <vector>
int main ()
{
int a[] = {1,5,9,8,4,6,9,2};
vector<int> v(a,a+8);
rotate(a,a+4,a+8);
/* rotate a such that a[4] is now the first element of array a */
/* now a is : 4,6,9,2,1,5,9,8 */
rotate(v.begin(), v.begin()+5, v.end());

/* now vector v is :6,9,2,1,5,9,8,4 */
}
unique método
Este método elimina los elementos duplicados consecutivos del rango
dado. Tiene dos variaciones. Devuelve un iterador a la posición que está al lado
del último elemento del nuevo rango. resize()se puede usar para ajustar el
tamaño del contenedor después de unique ().
• unique(iterator first, iterator last): Elimina todos los elementos duplicados

consecutivos, excepto el primero en el rango [primero,
último]. Operador ==, se utiliza para verificar si los elementos están
duplicados o no.
• unique(iterator first, iterator last, bool compare_function): En esta versión,

usamos compare_function para verificar si los elementos son
duplicados o no.
#include <iostream>
#include <vector>
#include <utility>
bool cmp_function(int a , int b )

{
return a+b;
}
int main ()
{
int values[] = {10,5,5,5,9,6,6,4,4};
vector<int> v (values,values+9) , v4;
it = unique(v.begin(), v.end());
/* vector v is now : 10,5,9,6,4,-,-,-,- */
/* - indicates that the elements are removed from the vector

and next elements are shifted to their position */
/* now it is pointing to the first occurrence of the “-“ in

the vector , i.e the position next to the last element (4) */
/* adjusting the size of vector v */
v.resize(distance(v.begin(),it));
/* resize the vector by the size returned by distance function,
which returns the distance between the two iterators */
/* vector v is now 10,5,9,6,4 */
/* using compare_function */
it = unique(v3.begin(), v3.end(), cmp_function);

v3.resize(distance(v3.begin(), it));
/* removes copies the duplicate elements from v3*/
return 0;
}
unique_copy método
Este método copia los elementos únicos del rango [primero, último] y devuelve
el iterador a la posición al lado del último elemento en el nuevo rango. Tiene dos
variaciones. Devuelve un iterador a la posición que está al lado del último
elemento del nuevo rango. resize()se puede usar para ajustar el tamaño del
contenedor después de unique ().
• unique_copy(iterator first, iterator last): Elimina todos los elementos

duplicados consecutivos, excepto el primero en el rango [primero,
último]. Operador ==, se utiliza para verificar si los elementos están
duplicados o no.
• unique_copy(iterator first, iterator last, bool compare_function) : En esta
versión, usamos compare_function para verificar si los elementos son
duplicados o no.
#include <iostream>
#include <vector>
bool cmp_fuction(int a , int b )

{
return a+b;
}
int main ()
{
int values[] = {10,5,5,5,9,6,6,4,4};
vector<int> v (values,values+9);
vector<int> v2;
v2.resize(v.size());
it = unique(v.begin(), v.end());
/* vector v2 is now : 10,5,9,6,4,-,-,-,- */
/* - indicates that the elements are removed from the vector

and next elements are shifted to their position */
/* now it is pointing to the first occurrence of the “-“

in the vector, i.e the position next to the last element (4) */
/* adjusting the size of vector v */
v.resize(distance(v.begin(), it));
/* resize the vector by the size returned by distance function,
which returns the distance between the two iterators */
/* vector v is now 10,5,9,6,4 */
/* using compare_function */
vector<int> v3(values,values+9),v4;
v4.resize(v3.size());
it = unique_copy(v3.begin(), v3.end(), v4.begin(), cmp_fuction);

v4.resize(distance(v4.begin(), it));
/* copies the unique elements from v3 to v4 */

return 0;
}
Algoritmos numéricos en C ++ STL

Los siguientes son algunos algoritmos numéricos en la biblioteca de plantillas
estándar que cubriremos:
• Método iota
• Método de acumulación
• Método parcial_sum
iota Método
Este método asigna todos los elementos sucesivos en el rango [primero, último]
como un valor incrementado del elemento mismo. Está disponible en c ++ 11 y
superior. Su sintaxis es iota(iterator first, iterator last, int value ).
#include<iostream>
#include<numeric>
#include<vector>
int main()
{
vector<int> v(10);
/* now vector v is : 0,0,0,0,0,0,0,0,0,0 */
iota(v.begin(), v.end(), 10 );
/* now the vector v is 10,11,12,13,14,15,16,17,18,19 */

}
accumulate Método
Este método realiza la operación op en todos los elementos en el rango [primero,
último] y almacena el resultado en el resultado del contenedor. Hay dos
variaciones de acumulación, en la primera no se define ningún operador binario
en la llamada a la función, por lo que, por defecto, se realiza la adición , de lo
contrario se realiza el operador binario op .
La siguiente es la sintaxis del método de acumulación con el operador binario

op:
accumulate(iterator first, iterator last, object_type result, binaryoperator op)

El siguiente es un ejemplo para demostrar el uso de acumular:
#include<iostream>
#include<numeric>
#include<vector>
int myoperator(int a, int b )

{
return a*b;
}
int main()
{
vector<int> v;
for(int i = 0 ; i < 10; i++) {

v.push_back(i);
}
/* now vector v is : 0,1,2,3,4,5,6,7,8,9 */
int result;
accumulate(v.begin(), v.end(), result) ;
/* as no operator is specified, accumulate add all the elements

between v.begin() and v.end() and store the sum in result */
/* now result = 45 */
accumulate(v.begin(), v.end(), result, myoperator) ;
/* applies myoperator on all the elements in the range v.begin() and v.end()
and store them in result */
/* now result = 9! */
}
partial_sum Método
Este método asigna todos los elementos en el rango a partir
del resultado del iterador de la operación op en el rango sucesivo en [first,
last]. Aquí se puede omitir la operación binaria, si no se especifica un operador
binario, la adición se realiza de manera predeterminada.
La sintaxis de partial_sum es:
partial_sum(iterator first, iterator last, iterator result, binary_operation op)

El siguiente es un ejemplo para demostrar el uso de partial_sum:
#include<iostream>
#include<numeric>
#include<vector>
int myoperator(int a, int b)

{
return a*b;
}
int main()
{
int a[] = {1,2,3,4,5};
vector<int> v (a,a+5);
vector<int> v2;
/* vector v is 1,2,3,4,5 */
v2.resize(v.size());
partial_sum(v.begin(), v.end(), v2.begin());
/* now v2 is : 1,3,6,10,15 */
/* sum of the successive range in v.begin() and v.end() */
partial_sum(v.begin(), v.end(), v2.begin(), myoperator);
/* now v2 is : 1,2,6,24,120 */
}
Operaciones mínimas y máximas en

STL
Las siguientes son las funciones que cubriremos:
• Método max
• Método max_element
• Método min
• Método min_element
• Método minmax
• Método minmax_element
• Método lixicographically_compare
• Método next_permutation
• Método de permutación previa
maxy minmétodo
max La sintaxis del método es: max(object_type a, object_type b,
compare_function)
Este método devuelve el elemento más grande de a y b. compare_function se
puede omitir. Si no se utiliza la función compare_fun en max (), los elementos se
comparan con el operador > de forma predeterminada. compare_function se
utiliza para determinar cuál de los objetos es más grande cuando los objetos a y
b son de tipo no numérico.
min La sintaxis del método es: min(object_type a, object_type b,

compare_function)
Este método devuelve el elemento más pequeño de a y b. compare_function se
puede omitir. Si no se utiliza la función compare_f en min (), los elementos se
comparan con el operador < de forma predeterminada. compare_function se
usa para determinar cuál de los objetos es más pequeño cuando los objetos a y
b son de tipo no numérico.
El siguiente es un ejemplo para demostrar el uso de los métodos max () y min ().
#include<iostream>
#include<algorithm>
/*compare function for strings*/

bool myMaxCompare(string a, string b)
{
return (a.size() > b.size());
}
bool myMinCompare(string a, string b)

{
return (a.size() > b.size());
}
int main()
{
int x=4, y=5;
cout << max(x,y); // prints 5

cout << min(x,y); // prints 4
cout << max(2.312, 5.434); // prints 5.434

cout << min(2.312, 5.434); // prints 2.312
string s = "smaller srting";

string t = "longer string---";
string s1 = max(s, t, myMaxCompare);

cout<< s1 <<endl; // prints longer string---
string s1 = min(s, t, myMinCompare);

cout<< s1 <<endl; // prints smaller string
}
max_elementy min_elementmétodo
La sintaxis del método max_element es:
max_element(iterator first, iterator last, compare_function)

Este método devuelve el elemento más grande en el rango [primero,
último]. compare_function se puede omitir. Si no hay una función de
comparación utilizada en max_element (), los elementos se comparan con el
operador > de forma predeterminada. compare_function se usa para
determinar cuál de los objetos es más grande cuando los objetos a y b son tipos
no numéricos.
min_element La sintaxis del método es:
min_element(iterator first, iterator last, compare_function)

Este método devuelve el elemento más pequeño en el rango [primero,
último]. compare_function se puede omitir. Si no se utiliza la función compare_f
en min_element (), los elementos se comparan con el operador < de forma
predeterminada. compare_function se usa para determinar cuál de los objetos
es más pequeño cuando los objetos a y b son tipos no numéricos.
El siguiente es un ejemplo para demostrar el uso del método max_element () y

min_element ().
#include<iostream>
#include<algorithm>
#include<vector>
bool myMaxCompare(int a, int b)

{
return (a < b);
}
bool myMinCompare(int a, int b)

{
return (a < b);
}
int main()
{
int values[] = { 1,5,4,9,8,10,6,5,1};
vector<int> v(values,values+9);
cout<< *max_element(v.begin(), v.end());

/* prints 10 */
cout<< *min_element(v.begin(), v.end());

/* prints 1 */
/* using mycompare function */

cout<< *max_element(v.begin(), v.end(), myMaxCompare);
/* prints 10 */
cout<< *min_element(v.begin(), v.end(), myMinCompare);

/* prints 1 */
}
lexicographical_compare Método
La sintaxis para este método es:
lexicographical_compare(iterator first1, iterator last1, iterator first2, iterator last2)
Compara los rangos [first1, last1] y [first2, last2] y devuelve verdadero si el

primer rango es lexicográficamente más pequeño que el último.
Se puede definir y utilizar una función de comparación personalizada cuando

deseamos definir cómo se van a comparar los elementos. La siguiente es la
sintaxis de esa variante de este método.
lexicographical_compare(iterator first1, iterator last1, iterator first2, iterator last2,

bool compare_function)
El siguiente es un programa para demostrar su uso:
#include<iostream>
#include<algorithm>
#include<vector>
bool myoperator(char a , char b)

{
return a > b;
int main()
{
char s[] = "nkvaio";
char x[] = "xyzabc";
cout >> lexicographical_compare(s, s+6, x, x+6, myoperator);
/* prints 0 , Boolean false , since a[4] is not less than b[4] */
}
MinMax y operaciones de permutación
en STL
Las siguientes son las funciones que cubriremos, ya que ya hemos cubierto los
otros métodos de Operaciones mínimas y máximas en STL en la lección anterior.
• Método minmax
• Método minmax_element
• Método next_permutation
• Método de permutación previa
minmaxy minmax_elementmétodo
La sintaxis del método minmax es: minmax(object_type a ,object_type b)
Este método devuelve un par, donde el primer elemento del par es el elemento
más pequeño de a y by el segundo elemento del par es el elemento más grande
de a y b . Si ambos, a y b son iguales que minmax devuelve un par de <a,
b> . minmax está disponible solo en C ++ 11 y superior.
El siguiente es un ejemplo para demostrar el uso del método minmax ().
#include<iostream>
#include<algorithm>
#include<numeric>
int main()
{
pair<int,int> p;
p = minmax(2,3);
/* now p.first = 2 ( smaller element )
And p.second = 3 ( larger element ) */
pair<string,string> p2;
p2 = minmax("abcd" , "abce");
/* p2.first = "abcd" ( lexicographically smaller string )
And p2.second = "abce" (lexicographically larger string ) */
p = minmax(2,2);
/* p.first = p.second = 2 , */
/* minmax can also be used for number of elements */
p = minmax({2,6,5,4,9,8});
/* now p.first = 2 ( smaller element )
And p.second = 9 ( larger element ) */
}
minmax_element La sintaxis del método es: minmax_element(iterator first,

iterator last, compare_function)
Este método devuelve un par de iteradores donde el primer elemento del par
apunta al elemento más pequeño en el rango [primero, último] y el segundo
elemento del par apunta al elemento más grande en el rango [primero, último].
El siguiente es un ejemplo para demostrar el uso de minmax_element ().
#include<iostream>
#include<algorithm>
#include<array>
int main ()
{
array<int,7> foo {3,7,2,9,5,8,6};
auto result = minmax_element(foo.begin(), foo.end());
// print result:
cout << "min is " << *result.first;
cout << "max is " << *result.second;
return 0;
}
next_permutationy prev_permutationmétodo
La sintaxis del método next_permutation es:
next_permutation(iterator first ,iterator last)

Este método organiza los elementos en el rango [primero, último] en la siguiente
disposición lexicográfica más grande. Para elementos en el rango de longitud n ,
hay n! posibles (factoriales) formas en que los elementos se pueden organizar,
cada disposición se llama permutación .
prev_permutation La sintaxis del método es:
prev_permutation(iterator first, iterator last)

Este método organiza los elementos en el rango [primero, último] en la siguiente
disposición lexicográfica más pequeña.
El siguiente es un ejemplo para demostrar el uso del método max_element () y

min_element ().
#include<iostream>
#include<algorithm>
#include<vector>

int main ()
{
char s[] = "abcd";
next_permutation(s, s+4);
cout << s >> endl;
/* prints "abdc" */
rev_permutation(s, s+4);
cout << s >> endl;
/* prints "dcba" */
int a[] = {1,2,3,4};
next_permutation(a, a+4);
/* now a is 1,2,4,3 */

/* v is : 1,2,4,3 */
next_permutation(v.begin(), v.end() );
/* now v is : 1,3,2,4 */
/* resetting a[] for prev_permutation */

int a[] = {1,2,3,4};
prev_permutation(a, a+4);
/* now a is 4,3,2,1 */

/* v is : 4,3,2,1 */
prev_permutation(v.begin(), v.end());
/* now v is : 4,3,1,2 */
return 0;
}

Programación

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programación

Încărcat de

Drepturi de autor:

Formate disponibile

Introducción a STL: Biblioteca de

STL proporciona numerosos contenedores y algoritmos que son muy útiles en la

C ++: Algoritmos en STL

C ++: Contenedores en STL

C ++: Iteradores en STL

Uso y aplicación de STL

Los contenedores se implementan como plantillas de clase genéricas, lo que

Los siguientes son algunos contenedores comunes:

• vector : replica matrices

Clasificación de contenedores en STL

• Contenedores de secuencia : se utilizan para implementar estructuras

• Contenedores asociativos : se utilizan para implementar estructuras de

• Contenedores asociativos desordenados : se utilizan para

• Adaptadores de contenedores : se utilizan para proporcionar una

Uso de la biblioteca de contenedores

El programa anterior solo crea un nodo de lista, no se definen funciones de

¡Y eso es! tenemos una lista, y no solo eso, la biblioteca de contenedores

Emparejar plantilla en STL

La sintaxis del par es:

pair<T1,T2> pair1, pair2 ;

• Operador =: asigna valores a un par.

PROGRAMA QUE DEMUESTRA LA PLANTILLA PAIR

using namespace std;

pair1 = make_pair(1, 2); // insert 1 and 2 to the pair1

La sintaxis de una tupla es:

// creates tuple of three object of type T1, T2 and T3

Plantilla de tupla: algunas funciones de

• Un constructor para construir una nueva tupla

PROGRAMA QUE MUESTRA LA PLANTILLA TUPLE

tuple1 = make_tuple(1,2,3); // insert 1, 2 and 3 to the tuple1

cout << id <<" "<< first_name <<" "<< last_name;

ARRAY Contenedor en STL

SINTAXIS DEL CONTENEDOR DE MATRIZ:

array<object_type, array_size> array_name;

La declaración anterior creará una matriz con 2,4,6,8 como datos en la

Funciones de miembro de plantilla de

using namespace std;

cout << array1.at(2) // prints 3

Esto llenará la matriz myarray con el valor 1, en todas sus 8 posiciones

a.swap(b) // swaps array a and b

cout << "a is : ";

VECTOR Contenedor en STL

La SINTAXIS para crear un vector es: vector< object_type > vector_name;

El vector es una matriz dinámica, no necesita tamaño durante la declaración, por

Tenga en cuenta que este tipo de inicialización solo funciona en C ++ 11 y

También puede inicializar un vector con un elemento una cierta cantidad de

Funciones de miembro de Vector

using namespace std;

for(vector<int>::iterator i = v.begin(); i != v.end(); i++)

La siguiente ilustración mostrará cómo funciona la inserción:

v.insert(i, v2.begin(), v2.end());

El código anterior insertará los elementos de v2.begin () a v2.end () antes del

using namespace std;

for(it = v.begin(); it != v.end(); it++)

El siguiente código ilustrará borrar:

using namespace std;

for(it = v.begin(); it != v.end(); it++)

LISTA Contenedor en STL

using namespace std;

Funciones de miembro del contenedor

• insert(iterator, element): inserta el elemento en la lista antes de la

• insert(iterator, count, element): inserta el elemento en la lista antes de la

• insert(iterator, start_iterator, end_iterator): inserte el elemento señalado

using namespace std;