Archivo de encabezado de la biblioteca estándar <algorithm>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

Esta cabecera es parte de la librería algorithm.

Functions

Operaciones no modificadoras sobre secuencias
all_ofany_ofnone_of (C++11)(C++11)(C++11)	Comprueba si un predicado es true para todos, alguno o ninguno de los elementos de un rango. (plantilla de función)
for_each	Aplica una función a un rango de elementos. (plantilla de función)
countcount_if	Devuelve el número de elementos que cumplan con un criterio específico. (plantilla de función)
mismatch	Encuentra la primera posición donde dos rangos difieren. (plantilla de función)
equal	Determina si dos conjuntos de elementos son iguales. (plantilla de función)
findfind_iffind_if_not (C++11)	Encuentra el primer elemento que satisfaga un criterio específico. (plantilla de función)
find_end	Encuentra la última secuencia de elementos en un cierto rango. (plantilla de función)
find_first_of	Busca por cualquiera de un conjunto de elementos. (plantilla de función)
adjacent_find	Encuentra dos elementos contiguos idénticos (o que satisfagan un predicado dado). (plantilla de función)
search	Busca una subsecuencia de elementos. (plantilla de función)
search_n	Busca un número de copias consecutivas de un elemento en un rango. (plantilla de función)
Operaciones modificadoras sobre secuencias
copycopy_if (C++11)	Copia un rango de elementos a una nueva ubicación. (plantilla de función)
copy_n (C++11)	Copia un número de elementos a una nueva ubicación. (plantilla de función)
copy_backward	Copia un rango de elementos en orden inverso. (plantilla de función)
move (C++11)	Mueve una serie de elementos a una nueva ubicación. (plantilla de función)
move_backward (C++11)	Mueve una serie de elementos a una nueva ubicación en orden inverso. (plantilla de función)
fill	Asigna por copia el valor dado a todos los elementos de un rango. (plantilla de función)
fill_n	Asigna por copia el valor dado a todos los elementos de un rango. (plantilla de función)
transform	Aplica una función a un rango de elementos (plantilla de función)
generate	Asigna el resultado de las llamadas sucesivas de una función a todos los elementos de un rango. (plantilla de función)
generate_n	Asigna el resultado de las llamadas sucesivas de una función a n elementos de un rango. (plantilla de función)
removeremove_if	Elimina elementos que satisfacen un criterio específico. (plantilla de función)
remove_copyremove_copy_if	Copia un rango de elementos omitiendo los que satisfacen un criterio específico (plantilla de función)
replacereplace_if	Reemplaza todos los valores que satisfacen criterios específicos con otro valor. (plantilla de función)
replace_copyreplace_copy_if	Copia un intervalo, en sustitución de elementos que cumplan criterios específicos con otro valor Original: copies a range, replacing elements satisfying specific criteria with another value The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
swap	Intercambia los valores de dos objetos (plantilla de función)
swap_ranges	Intercambia dos rangos de elementos. (plantilla de función)
iter_swap	Intercambia los elementos a los que apuntan dos iteradores (plantilla de función)
reverse	Invierte el orden de los elementos en un rango. (plantilla de función)
reverse_copy	Crea una copia de un rango que está invertida (plantilla de función)
rotate	Rota el orden de los elementos en un rango. (plantilla de función)
rotate_copy	Copia y rota un rango de elementos. (plantilla de función)
random_shuffleshuffle (hasta C++17)(C++11)	Reordena aleatoriamente elementos en un rango. (plantilla de función)
unique	Elimina elementos duplicados consecutivos en un rango. (plantilla de función)
unique_copy	Crea una copia de un rango de elementos que no contiene duplicados consecutivos. (plantilla de función)
Operaciones de partición
is_partitioned (C++11)	Determina si el rango está particionado por el predicado dado. (plantilla de función)
partition	Divide un rango de elementos en dos grupos. (plantilla de función)
partition_copy (C++11)	Copia un rango dividiendo los elementos en dos grupos. (plantilla de función)
stable_partition	Divide elementos en dos grupos, conservando su orden relativo. (plantilla de función)
partition_point (C++11)	Ubica el punto de partición de un rango particionado. (plantilla de función)
Operaciones de ordenación
is_sorted (C++11)	Comprueba si un rango se clasifican en orden ascendente Original: checks whether a range is sorted into ascending order The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
is_sorted_until (C++11)	Encuentra el subrango ordenado más grande. (plantilla de función)
sort	Ordena un intervalo en orden ascendente Original: sorts a range into ascending order The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
partial_sort	ordena los primeros n elementos de un rango Original: sorts the first N elements of a range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
partial_sort_copy	Copia y ordena parcialmente un rango de elementos. (plantilla de función)
stable_sort	Ordena un intervalo de elementos, mientras que la preservación del orden entre los elementos iguales Original: sorts a range of elements while preserving order between equal elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
nth_element	Ordena parcialmente el rango dado asegurándose de que esté particionado por el elemento dado. (plantilla de función)
Operaciones de búsqueda binaria (en rangos ordenados)
lower_bound	Devuelve un iterador al primer elemento no menor que el valor dado. (plantilla de función)
upper_bound	Devuelve un iterador al primer elemento mayor que un valor determinado. (plantilla de función)
binary_search	Determina si un elemento existe en un rango parcialmente ordenado. (plantilla de función)
equal_range	Devuelve el rango de los elementos que coinciden con una clave específica. (plantilla de función)
Operaciones de set (en rangos ordenados)
merge	Fusiona dos rangos ordenados. (plantilla de función)
inplace_merge	Fusiona dos rangos ordenados in situ. (plantilla de función)
includes	Devuelve true si una secuencia es una subsecuencia de otra. (plantilla de función)
set_difference	Calcula la diferencia entre dos conjuntos. (plantilla de función)
set_intersection	Calcula la intersección de dos conjuntos. (plantilla de función)
set_symmetric_difference	Calcula la diferencia simétrica entre dos conjuntos. (plantilla de función)
set_union	Calcula la unión de dos conjuntos. (plantilla de función)
Operaciones de pila
is_heap (C++11)	Verifica si el rango dado es un montículo de máximos. (plantilla de función)
is_heap_until (C++11)	Encuentra el subrango más grande que es un montículo de máximos. (plantilla de función)
make_heap	Crea un montículo de máximos a partir de un rango de elementos. (plantilla de función)
push_heap	Agrega un elemento a un montículo de máximos. (plantilla de función)
pop_heap	Elimina el elemento más grande de un montículo de máximos. (plantilla de función)
sort_heap	Resulta un montón en una gama de elementos ordenados Original: turns a heap into a sorted range of elements The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
Operaciones de mínimo/máximo
clamp (C++17)	Restringe un valor entre un par de valores limitantes (plantilla de función)
max	Devuelve el mayor de dos elementos (plantilla de función)
max_element	Devuelve el elemento más grande en un rango. (plantilla de función)
min	Devuelve el menor de los elementos (plantilla de función)
min_element	Devuelve el elemento más pequeño de un rango. (plantilla de función)
minmax (C++11)	Devuelve el menor y el mayor de dos elementos. (plantilla de función)
minmax_element (C++11)	Devuelve el elemento más pequeño y el más grande de un rango. (plantilla de función)
lexicographical_compare	Devuelve true si un rango es lexicográficamente menor que otro. (plantilla de función)
is_permutation (C++11)	Determina si una secuencia es una permutación de otra secuencia. (plantilla de función)
next_permutation	Genera la siguiente permutación lexicográfica mayor de un rango de elementos. (plantilla de función)
prev_permutation	genera la siguiente permutación lexicográfica menor de un rango de elementos. (plantilla de función)

Sinopsis

#include <initializer_list>
namespace std
{
    // operaciones no modificadoras sobre secuencias:
    template <class InputIterator, class Predicado>
        bool all_of(InputIterator primero, InputIterator ultimo, Predicado pred);
    template <class InputIterator, class Predicado>
        bool any_of(InputIterator primero, InputIterator ultimo, Predicado pred);
    template <class InputIterator, class Predicado>
        bool none_of(InputIterator primero, InputIterator ultimo, Predicado pred);
        
    template<class InputIterator, class Funcion>
        Funcion for_each(InputIterator primero, InputIterator ultimo, Funcion f);
        
    template<class InputIterator, class T>
        InputIterator find(InputIterator primero, InputIterator ultimo,
                           const T& value);
    template<class InputIterator, class Predicado>
        InputIterator find_if(InputIterator primero, InputIterator ultimo,
                              Predicado pred);
    template<class InputIterator, class Predicado>
        InputIterator find_if_not(InputIterator primero, InputIterator ultimo,
                                  Predicado pred);
                                  
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1
        find_end(ForwardIterator1 primero1, ForwardIterator1 ultimo1,
                 ForwardIterator2 primero2, ForwardIterator2 ultimo2);
    template<class ForwardIterator1, class ForwardIterator2,
             class PredicadoBinario>
        ForwardIterator1
        find_end(ForwardIterator1 primero1, ForwardIterator1 ultimo1,
                 ForwardIterator2 primero2, ForwardIterator2 ultimo2,
                 PredicadoBinario pred);
                 
    template<class InputIterator, class ForwardIterator>
        InputIterator
        find_first_of(InputIterator primero1, InputIterator ultimo1,
                      ForwardIterator primero2, ForwardIterator ultimo2);
    template<class InputIterator, class ForwardIterator,
             class PredicadoBinario>
        InputIterator
        find_first_of(InputIterator primero1, InputIterator ultimo1,
                      ForwardIterator primero2, ForwardIterator ultimo2,
                      PredicadoBinario pred);
                      
    template<class ForwardIterator>
        ForwardIterator adjacent_find(ForwardIterator primero,
                                      ForwardIterator ultimo);
    template<class ForwardIterator, class PredicadoBinario>
        ForwardIterator adjacent_find(ForwardIterator primero,
                                      ForwardIterator ultimo,
                                      PredicadoBinario pred);
    template<class InputIterator, class T>
        typename iterator_traits<InputIterator>::difference_type
        count(InputIterator primero, InputIterator ultimo, const T& value);
    template<class InputIterator, class Predicado>
        typename iterator_traits<InputIterator>::difference_type
        count_if(InputIterator primero, InputIterator ultimo, Predicado pred);
        
    template<class InputIterator1, class InputIterator2>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 primero1, InputIterator1 ultimo1,
                 InputIterator2 primero2);
    template<class InputIterator1, class InputIterator2, class PredicadoBinario>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 primero1, InputIterator1 ultimo1,
                 InputIterator2 primero2, PredicadoBinario pred);
                 
    template<class InputIterator1, class InputIterator2>
        bool equal(InputIterator1 primero1, InputIterator1 ultimo1,
                   InputIterator2 primero2);
    template<class InputIterator1, class InputIterator2, class PredicadoBinario>
        bool equal(InputIterator1 primero1, InputIterator1 ultimo1,
                   InputIterator2 primero2, PredicadoBinario pred);
                   
    template<class ForwardIterator1, class ForwardIterator2>
        bool is_permutation(ForwardIterator1 primero1, ForwardIterator1 ultimo1,
                            ForwardIterator2 primero2);
    template<class ForwardIterator1, class ForwardIterator2,
    class PredicadoBinario>
        bool is_permutation(ForwardIterator1 primero1, ForwardIterator1 ultimo1,
                            ForwardIterator2 primero2, PredicadoBinario pred);
                            
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 search(
            ForwardIterator1 primero1, ForwardIterator1 ultimo1,
            ForwardIterator2 primero2, ForwardIterator2 ultimo2);
    template<class ForwardIterator1, class ForwardIterator2,
             class PredicadoBinario>
        ForwardIterator1 search(
            ForwardIterator1 primero1, ForwardIterator1 ultimo1,
            ForwardIterator2 primero2, ForwardIterator2 ultimo2,
            PredicadoBinario pred);
            
    template<class ForwardIterator, class Size, class T>
        ForwardIterator search_n(ForwardIterator primero, ForwardIterator ultimo,
                                 Size count, const T& value);
    template<class ForwardIterator, class Size, class T, class PredicadoBinario>
        ForwardIterator1 search_n(ForwardIterator primero, ForwardIterator ultimo,
                                  Size count, const T& value,
                                  PredicadoBinario pred);
                                  
    // operaciones modificadoras sobre secuencias:
    
    // copia:
    template<class InputIterator, class OutputIterator>
        OutputIterator copy(InputIterator primero, InputIterator ultimo,
                            OutputIterator result);
    template<class InputIterator, class Size, class OutputIterator>
        OutputIterator copy_n(InputIterator primero, Size n,
                              OutputIterator result);
    template<class InputIterator, class OutputIterator, class Predicado>
        OutputIterator copy_if(InputIterator primero, InputIterator ultimo,
                               OutputIterator result, Predicado pred);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 copy_backward(
            BidirectionalIterator1 primero, BidirectionalIterator1 ultimo,
            BidirectionalIterator2 result);
            
    // mocimiento:
    template<class InputIterator, class OutputIterator>
        OutputIterator move(InputIterator primero, InputIterator ultimo,
                            OutputIterator result);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 move_backward(
            BidirectionalIterator1 primero, BidirectionalIterator1 ultimo,
            BidirectionalIterator2 result);
            
    // intercambio:
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator2 swap_ranges(ForwardIterator1 primero1,
                                     ForwardIterator1 ultimo1, ForwardIterator2 primero2);
    template<class ForwardIterator1, class ForwardIterator2>
        void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
    template<class InputIterator, class OutputIterator, class UnaryOperation>
        OutputIterator transform(InputIterator primero, InputIterator ultimo,
                                 OutputIterator result, UnaryOperation op);
                                 
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class BinaryOperation>
        OutputIterator transform(InputIterator1 primero1, InputIterator1 ultimo1,
                                 InputIterator2 primero2, OutputIterator result,
                                 BinaryOperation binary_op);
                                 
    template<class ForwardIterator, class T>
        void replace(ForwardIterator primero, ForwardIterator ultimo,
                     const T& old_value, const T& new_value);
    template<class ForwardIterator, class Predicado, class T>
        void replace_if(ForwardIterator primero, ForwardIterator ultimo,
                        Predicado pred, const T& new_value);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator replace_copy(InputIterator primero, InputIterator ultimo,
                                    OutputIterator result,
                                    const T& old_value, const T& new_value);
    template<class InputIterator, class OutputIterator, class Predicado, class T>
        OutputIterator replace_copy_if(InputIterator primero, InputIterator ultimo,
                                       OutputIterator result,
                                       Predicado pred, const T& new_value);
                                       
    template<class ForwardIterator, class T>
        void fill(ForwardIterator primero, ForwardIterator ultimo, const T& value);
    template<class OutputIterator, class Size, class T>
        OutputIterator fill_n(OutputIterator primero, Size n, const T& value);
    template<class ForwardIterator, class Generator>
        void generate(ForwardIterator primero, ForwardIterator ultimo,
                      Generator gen);
    template<class OutputIterator, class Size, class Generator>
        OutputIterator generate_n(OutputIterator primero, Size n, Generator gen);
        
    template<class ForwardIterator, class T>
        ForwardIterator remove(ForwardIterator primero, ForwardIterator ultimo,
                               const T& value);
    template<class ForwardIterator, class Predicado>
        ForwardIterator remove_if(ForwardIterator primero, ForwardIterator ultimo,
                                  Predicado pred);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator remove_copy(InputIterator primero, InputIterator ultimo,
                                   OutputIterator result, const T& value);
    template<class InputIterator, class OutputIterator, class Predicado>
        OutputIterator remove_copy_if(InputIterator primero, InputIterator ultimo,
                                      OutputIterator result, Predicado pred);
                                      
    template<class ForwardIterator>
        ForwardIterator unique(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class PredicadoBinario>
        ForwardIterator unique(ForwardIterator primero, ForwardIterator ultimo,
                               PredicadoBinario pred);
    template<class InputIterator, class OutputIterator>
        OutputIterator unique_copy(InputIterator primero, InputIterator ultimo,
                                   OutputIterator result);
    template<class InputIterator, class OutputIterator, class PredicadoBinario>
        OutputIterator unique_copy(InputIterator primero, InputIterator ultimo,
                                   OutputIterator result, PredicadoBinario pred);
                                   
    template<class BidirectionalIterator>
        void reverse(BidirectionalIterator primero, BidirectionalIterator ultimo);
    template<class BidirectionalIterator, class OutputIterator>
        OutputIterator reverse_copy(BidirectionalIterator primero,
                                    BidirectionalIterator ultimo,
                                    OutputIterator result);
                                    
    template<class ForwardIterator>
        ForwardIterator rotate(ForwardIterator primero, ForwardIterator middle,
                               ForwardIterator ultimo);
    template<class ForwardIterator, class OutputIterator>
        OutputIterator rotate_copy(
            ForwardIterator primero, ForwardIterator middle,
            ForwardIterator ultimo, OutputIterator result);
            
    template<class RandomAccessIterator>
        void random_shuffle(RandomAccessIterator primero,
                            RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class RandomNumberGenerator>
        void random_shuffle(RandomAccessIterator primero,
                            RandomAccessIterator ultimo,
                            RandomNumberGenerator&& rand);
    template<class RandomAccessIterator, class UniformRandomNumberGenerator>
        void shuffle(RandomAccessIterator primero,
                     RandomAccessIterator ultimo,
                     UniformRandomNumberGenerator&& rand);
                     
    // particiones:
    template <class InputIterator, class Predicado>
        bool is_partitioned(InputIterator primero, InputIterator ultimo, Predicado pred);
        
    template<class ForwardIterator, class Predicado>
        ForwardIterator partition(ForwardIterator primero,
                                  ForwardIterator ultimo,
                                  Predicado pred);
                                  
    template<class BidirectionalIterator, class Predicado>
        BidirectionalIterator stable_partition(BidirectionalIterator primero,
                                               BidirectionalIterator ultimo,
                                               Predicado pred);
                                               
    template <class InputIterator, class OutputIterator1,
              class OutputIterator2, class Predicado>
        pair<OutputIterator1, OutputIterator2>
        partition_copy(InputIterator primero, InputIterator ultimo,
                       OutputIterator1 out_true, OutputIterator2 out_false,
                       Predicado pred);
                       
    template<class ForwardIterator, class Predicado>
        ForwardIterator partition_point(ForwardIterator primero,
                                        ForwardIterator ultimo,
                                        Predicado pred);
                                        
    // operaciones de ordenación y relacionados:
    
    // sorting:
    template<class RandomAccessIterator>
        void sort(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void sort(RandomAccessIterator primero, RandomAccessIterator ultimo,
                  Comparar comp);
                  
    template<class RandomAccessIterator>
        void stable_sort(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void stable_sort(RandomAccessIterator primero, RandomAccessIterator ultimo,
                         Comparar comp);
                         
    template<class RandomAccessIterator>
        void partial_sort(RandomAccessIterator primero,
                          RandomAccessIterator middle,
                          RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void partial_sort(RandomAccessIterator primero,
                          RandomAccessIterator middle,
                          RandomAccessIterator ultimo, Comparar comp);
    template<class InputIterator, class RandomAccessIterator>
        RandomAccessIterator partial_sort_copy(
            InputIterator primero, InputIterator ultimo,
            RandomAccessIterator result_primero,
            RandomAccessIterator result_ultimo);
    template<class InputIterator, class RandomAccessIterator, class Comparar>
        RandomAccessIterator partial_sort_copy(
            InputIterator primero, InputIterator ultimo,
            RandomAccessIterator result_primero,
            RandomAccessIterator result_ultimo,
            Comparar comp);
            
    template<class ForwardIterator>
        bool is_sorted(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class Comparar>
        bool is_sorted(ForwardIterator primero, ForwardIterator ultimo,
                       Comparar comp);
    template<class ForwardIterator>
        ForwardIterator is_sorted_until(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class Comparar>
        ForwardIterator is_sorted_until(ForwardIterator primero, ForwardIterator ultimo,
                                        Comparar comp);
                                        
    template<class RandomAccessIterator>
        void nth_element(RandomAccessIterator primero, RandomAccessIterator nth,
                         RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void nth_element(RandomAccessIterator primero, RandomAccessIterator nth,
                         RandomAccessIterator ultimo, Comparar comp);
    // búsqueda binaria:
    template<class ForwardIterator, class T>
        ForwardIterator lower_bound(ForwardIterator primero, ForwardIterator ultimo,
                                    const T& value);
    template<class ForwardIterator, class T, class Comparar>
        ForwardIterator lower_bound(ForwardIterator primero, ForwardIterator ultimo,
                                    const T& value, Comparar comp);
                                    
    template<class ForwardIterator, class T>
        ForwardIterator upper_bound(ForwardIterator primero, ForwardIterator ultimo,
                                    const T& value);
    template<class ForwardIterator, class T, class Comparar>
        ForwardIterator upper_bound(ForwardIterator primero, ForwardIterator ultimo,
                                    const T& value, Comparar comp);
                                    
    template<class ForwardIterator, class T>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator primero, ForwardIterator ultimo,
                    const T& value);
    template<class ForwardIterator, class T, class Comparar>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator primero, ForwardIterator ultimo,
                    const T& value, Comparar comp);
                    
    template<class ForwardIterator, class T>
        bool binary_search(ForwardIterator primero, ForwardIterator ultimo,
                           const T& value);
    template<class ForwardIterator, class T, class Comparar>
        bool binary_search(ForwardIterator primero, ForwardIterator ultimo,
                           const T& value, Comparar comp);
                       
    // unión:
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator merge(InputIterator1 primero1, InputIterator1 ultimo1,
                             InputIterator2 primero2, InputIterator2 ultimo2,
                             OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
            class Comparar>
        OutputIterator merge(InputIterator1 primero1, InputIterator1 ultimo1,
                             InputIterator2 primero2, InputIterator2 ultimo2,
                             OutputIterator result, Comparar comp);
                             
    template<class BidirectionalIterator>
        void inplace_merge(BidirectionalIterator primero,
                           BidirectionalIterator middle,
                           BidirectionalIterator ultimo);
    template<class BidirectionalIterator, class Comparar>
        void inplace_merge(BidirectionalIterator primero,
                           BidirectionalIterator middle,
                           BidirectionalIterator ultimo, Comparar comp);
                       
    // operaciones de set:
    template<class InputIterator1, class InputIterator2>
        bool includes(InputIterator1 primero1, InputIterator1 ultimo1,
                      InputIterator2 primero2, InputIterator2 ultimo2);
    template<class InputIterator1, class InputIterator2, class Comparar>
        bool includes(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2, Comparar comp);
            
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_union(InputIterator1 primero1, InputIterator1 ultimo1,
                                 InputIterator2 primero2, InputIterator2 ultimo2,
                                 OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Comparar>
        OutputIterator set_union(InputIterator1 primero1, InputIterator1 ultimo1,
                                 InputIterator2 primero2, InputIterator2 ultimo2,
                                 OutputIterator result, Comparar comp);
                                 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_intersection(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Comparar>
        OutputIterator set_intersection(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result, Comparar comp);
            
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_difference(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Comparar>
        OutputIterator set_difference(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result, Comparar comp);
            
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_symmetric_difference(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Comparar>
        OutputIterator set_symmetric_difference(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            OutputIterator result, Comparar comp);
        
    // operaciones de pila:
    template<class RandomAccessIterator>
        void push_heap(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void push_heap(RandomAccessIterator primero, RandomAccessIterator ultimo,
                       Comparar comp);
    template<class RandomAccessIterator>
        void pop_heap(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void pop_heap(RandomAccessIterator primero, RandomAccessIterator ultimo,
                      Comparar comp);
                  
    template<class RandomAccessIterator>
        void make_heap(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void make_heap(RandomAccessIterator primero, RandomAccessIterator ultimo,
                       Comparar comp);
                   
    template<class RandomAccessIterator>
        void sort_heap(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        void sort_heap(RandomAccessIterator primero, RandomAccessIterator ultimo,
                       Comparar comp);
                   
    template<class RandomAccessIterator>
        bool is_heap(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        bool is_heap(RandomAccessIterator primero, RandomAccessIterator ultimo, Comparar comp);
    template<class RandomAccessIterator>
        RandomAccessIterator 
            is_heap_until(RandomAccessIterator primero, RandomAccessIterator ultimo);
    template<class RandomAccessIterator, class Comparar>
        RandomAccessIterator 
            is_heap_until(RandomAccessIterator primero, RandomAccessIterator ultimo,
                                           Comparar comp);
    // minimo y maximo:
    template<class T> const T& min(const T& a, const T& b);
    template<class T, class Comparar>
        const T& min(const T& a, const T& b, Comparar comp);
    template<class T>
        T min(initializer_list<T> t);
    template<class T, class Comparar>
        T min(initializer_list<T> t, Comparar comp);
        
    template<class T> const T& max(const T& a, const T& b);
    template<class T, class Comparar>
        const T& max(const T& a, const T& b, Comparar comp);
    template<class T>
        T max(initializer_list<T> t);
    template<class T, class Comparar>
        T max(initializer_list<T> t, Comparar comp);
        
    template<class T> pair<const T&, const T&> minmax(const T& a, const T& b);
    template<class T, class Comparar>
        pair<const T&, const T&> minmax(const T& a, const T& b, Comparar comp);
    template<class T>
        pair<T, T> minmax(initializer_list<T> t);
    template<class T, class Comparar>
        pair<T, T> minmax(initializer_list<T> t, Comparar comp);
        
    template<class ForwardIterator>
        ForwardIterator min_element(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class Comparar>
        ForwardIterator min_element(ForwardIterator primero, ForwardIterator ultimo,
                                    Comparar comp);
                                    
    template<class ForwardIterator>
        ForwardIterator max_element(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class Comparar>
        ForwardIterator max_element(ForwardIterator primero, ForwardIterator ultimo,
                                    Comparar comp);
                                    
    template<class ForwardIterator>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator primero, ForwardIterator ultimo);
    template<class ForwardIterator, class Comparar>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator primero, ForwardIterator ultimo, Comparar comp);
        
    template<class InputIterator1, class InputIterator2>
        bool lexicographical_compare(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2);
    template<class InputIterator1, class InputIterator2, class Comparar>
        bool lexicographical_compare(
            InputIterator1 primero1, InputIterator1 ultimo1,
            InputIterator2 primero2, InputIterator2 ultimo2,
            Comparar comp);
        
    // permutaciones:
    template<class BidirectionalIterator>
        bool next_permutation(BidirectionalIterator primero,
                              BidirectionalIterator ultimo);
    template<class BidirectionalIterator, class Comparar>
        bool next_permutation(BidirectionalIterator primero,
                              BidirectionalIterator ultimo, Comparar comp);
                              
    template<class BidirectionalIterator>
        bool prev_permutation(BidirectionalIterator primero,
                              BidirectionalIterator ultimo);
    template<class BidirectionalIterator, class Comparar>
        bool prev_permutation(BidirectionalIterator primero,
                              BidirectionalIterator ultimo, Comparar comp);
}