Archivo de encabezado de la biblioteca estándar <algorithm>
De cppreference.com
Esta cabecera es parte de la librería algorithm.
[editar] Functions
Operaciones no modificadoras sobre secuencias | |
| (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) |
| Aplica una función a un rango de elementos. (plantilla de función) | |
| Devuelve el número de elementos que cumplan con un criterio específico. (plantilla de función) | |
| Encuentra la primera posición donde dos rangos difieren. (plantilla de función) | |
| Determina si dos conjuntos de elementos son iguales. (plantilla de función) | |
| (C++11) |
Encuentra el primer elemento que satisfaga un criterio específico. (plantilla de función) |
| Encuentra la última secuencia de elementos en un cierto rango. (plantilla de función) | |
| Busca por cualquiera de un conjunto de elementos. (plantilla de función) | |
| Encuentra dos elementos contiguos idénticos (o que satisfagan un predicado dado). (plantilla de función) | |
| Busca una subsecuencia de elementos. (plantilla de función) | |
| Busca un número de copias consecutivas de un elemento en un rango. (plantilla de función) | |
Operaciones modificadoras sobre secuencias | |
| (C++11) |
Copia un rango de elementos a una nueva ubicación. (plantilla de función) |
| (C++11) |
Copia un número de elementos a una nueva ubicación. (plantilla de función) |
| Copia un rango de elementos en orden inverso. (plantilla de función) | |
| (C++11) |
Mueve una serie de elementos a una nueva ubicación. (plantilla de función) |
| (C++11) |
Mueve una serie de elementos a una nueva ubicación en orden inverso. (plantilla de función) |
| Asigna por copia el valor dado a todos los elementos de un rango. (plantilla de función) | |
| Asigna por copia el valor dado a todos los elementos de un rango. (plantilla de función) | |
| Aplica una función a un rango de elementos (plantilla de función) | |
| Asigna el resultado de las llamadas sucesivas de una función a todos los elementos de un rango. (plantilla de función) | |
| Asigna el resultado de las llamadas sucesivas de una función a n elementos de un rango. (plantilla de función) | |
| Elimina elementos que satisfacen un criterio específico. (plantilla de función) | |
| Copia un rango de elementos omitiendo los que satisfacen un criterio específico (plantilla de función) | |
| Reemplaza todos los valores que satisfacen criterios específicos con otro valor. (plantilla de función) | |
| 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) | |
| Intercambia los valores de dos objetos (plantilla de función) | |
| Intercambia dos rangos de elementos. (plantilla de función) | |
| Intercambia los elementos a los que apuntan dos iteradores (plantilla de función) | |
| Invierte el orden de los elementos en un rango. (plantilla de función) | |
| Crea una copia de un rango que está invertida (plantilla de función) | |
| Rota el orden de los elementos en un rango. (plantilla de función) | |
| Copia y rota un rango de elementos. (plantilla de función) | |
| (hasta C++17)(C++11) |
Reordena aleatoriamente elementos en un rango. (plantilla de función) |
| Elimina elementos duplicados consecutivos en un rango. (plantilla de función) | |
| Crea una copia de un rango de elementos que no contiene duplicados consecutivos. (plantilla de función) | |
Operaciones de partición | |
| (C++11) |
Determina si el rango está particionado por el predicado dado. (plantilla de función) |
| Divide un rango de elementos en dos grupos. (plantilla de función) | |
| (C++11) |
Copia un rango dividiendo los elementos en dos grupos. (plantilla de función) |
| Divide elementos en dos grupos, conservando su orden relativo. (plantilla de función) | |
| (C++11) |
Ubica el punto de partición de un rango particionado. (plantilla de función) |
Operaciones de ordenación | |
| (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) |
| (C++11) |
Encuentra el subrango ordenado más grande. (plantilla de función) |
| 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) | |
| 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) | |
| Copia y ordena parcialmente un rango de elementos. (plantilla de función) | |
| 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) | |
| 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) | |
| Devuelve un iterador al primer elemento no menor que el valor dado. (plantilla de función) | |
| Devuelve un iterador al primer elemento mayor que un valor determinado. (plantilla de función) | |
| Determina si un elemento existe en un rango parcialmente ordenado. (plantilla de función) | |
| Devuelve el rango de los elementos que coinciden con una clave específica. (plantilla de función) | |
Operaciones de set (en rangos ordenados) | |
| Fusiona dos rangos ordenados. (plantilla de función) | |
| Fusiona dos rangos ordenados in situ. (plantilla de función) | |
| Devuelve true si una secuencia es una subsecuencia de otra. (plantilla de función) | |
| Calcula la diferencia entre dos conjuntos. (plantilla de función) | |
| Calcula la intersección de dos conjuntos. (plantilla de función) | |
| Calcula la diferencia simétrica entre dos conjuntos. (plantilla de función) | |
| Calcula la unión de dos conjuntos. (plantilla de función) | |
Operaciones de pila | |
| (C++11) |
Verifica si el rango dado es un montículo de máximos. (plantilla de función) |
| (C++11) |
Encuentra el subrango más grande que es un montículo de máximos. (plantilla de función) |
| Crea un montículo de máximos a partir de un rango de elementos. (plantilla de función) | |
| Agrega un elemento a un montículo de máximos. (plantilla de función) | |
| Elimina el elemento más grande de un montículo de máximos. (plantilla de función) | |
| 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 | |
| (C++17) |
Restringe un valor entre un par de valores limitantes (plantilla de función) |
| Devuelve el mayor de dos elementos (plantilla de función) | |
| Devuelve el elemento más grande en un rango. (plantilla de función) | |
| Devuelve el menor de los elementos (plantilla de función) | |
| Devuelve el elemento más pequeño de un rango. (plantilla de función) | |
| (C++11) |
Devuelve el menor y el mayor de dos elementos. (plantilla de función) |
| (C++11) |
Devuelve el elemento más pequeño y el más grande de un rango. (plantilla de función) |
| Devuelve true si un rango es lexicográficamente menor que otro. (plantilla de función) | |
| (C++11) |
Determina si una secuencia es una permutación de otra secuencia. (plantilla de función) |
| Genera la siguiente permutación lexicográfica mayor de un rango de elementos. (plantilla de función) | |
| genera la siguiente permutación lexicográfica menor de un rango de elementos. (plantilla de función) | |
[editar] 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); }
