Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

<algorithm>

Define las funciones estándar de la plantilla (STL) de contenedor de la biblioteca de plantillas que realizan algoritmos.

namespace std {
template<class InputIterator, class Predicate>
    bool all_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool any_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    bool none_of (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    );
template<class InputIterator, class Function>
    Fn1 for_each (
        InputIterator _First, 
        InputIterator _Last, 
        Function _Func
    );
template<class InputIterator, class Type>
    InputIterator find (
        InputIterator _First, 
        InputIterator _Last, 
        const Type& _Val
    );
template<class InputIterator, class Predicate>
    InputIterator find_if (
        InputIterator _First, 
        InputIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Predicate>
    InputIterator find_if_not (
        InputIterator _First, 
        InputIterator _Last,
        Predicate _Pred
    ); 
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 find_end (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class InputIterator, class ForwardIterator>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2
    );
template<class InputIterator, class ForwardIterator, 
         class Predicate>
    InputIterator1 find_first_of (
        InputIterator _First1, 
        InputIterator _Last1,
        ForwardIterator _First2, 
        ForwardIterator _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last
    );
template<class ForwardIterator, class Predicate>
    ForwardIterator adjacent_find (
        ForwardIterator _First, 
        ForwardIterator _Last, 
        Predicate _Pred
    );
template<class InputIterator, class Type>
    typename iterator_traits<InputIterator>::difference_type
        count (
            InputIterator _First, 
            InputIterator _Last,
            const Type& _Val
        );
template<class InputIterator, class Predicate>
    typename iterator_traits<InputIterator>::difference_type
        count_if (
            InputIterator _First, 
            InputIterator _Last,
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2
        );
template<class InputIterator1, class InputIterator2, class Predicate>
    pair<InputIterator1, InputIterator2> 
        mismatch (
            InputIterator1 _First1, 
            InputIterator1 _Last1,
            InputIterator2 _First2, 
            Predicate _Pred
        );
template<class InputIterator1, class InputIterator2>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2
    );
template<class InputIterator1, class InputIterator2, class Predicate>
    bool equal (
        InputIterator1 _First1, 
        InputIterator1 _Last1, 
        InputIterator2 _First2, 
        Predicate _Pred
    );
template<class ForwardIterator1, class ForwardIterator2>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2
    );
template<class ForwardIterator1, class ForwardIterator2, 
         class Predicate>
    ForwardIterator1 search (
        ForwardIterator1 _First1, 
        ForwardIterator1 _Last1,
        ForwardIterator2 _First2, 
        ForwardIterator2 _Last2, 
        Predicate _Pred
    );
template<class ForwardIterator, class Size, class Type>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val
    );
template<class ForwardIterator, class Size, class Type, 
         class Predicate>
    ForwardIterator search_n (
        ForwardIterator _First, 
        ForwardIterator _Last,
        Size _Count, 
        const Type& _Val, 
        Predicate _Pred
    );

Los algoritmos de STL son genéricos porque pueden funcionar en una variedad de estructuras de datos. Las estructuras de datos que pueden funcionar en incluyen no solo de las clases de contenedor de STL como vector y list, pero también estructuras de datos y matrices de programas específicos de los elementos que cumplen los requisitos de un algoritmo determinado. Los algoritmos de STL logran este nivel de generalidad obtener acceso y recorriendo a los elementos de un contenedor a iteradores.

Los algoritmos de STL procesan los intervalos de iterador que se especifican normalmente por sus posiciones inicial o de cierre. Intervalos referidos deben ser válidos en el sentido de que todos los punteros a intervalos deben ser dereferenceable y, dentro de las secuencias de cada intervalo, la posición última debe ser accesible de primera por el aumento.

Los algoritmos de STL extienden acciones admitidos por las operaciones y las funciones miembro de cada contenedor de STL y permiten trabajar, por ejemplo, con diferentes tipos de objetos contenedor al mismo tiempo. Dos sufijos se han utilizado para transmitir la información sobre el propósito de los algoritmos.

  • Si el sufijo indica que el algoritmo se usa con objetos de función que funcionan en los valores de los elementos en lugar de en los valores de los propios elementos. El algoritmo de find_if busca los elementos cuyos valores satisfacen el criterio especificado por un objeto de función, y el algoritmo de find busca un valor determinado.

  • El sufijo _copy indica que el algoritmo no sólo manipular los valores de los elementos pero también copia los valores modificados en un rango de destino. El algoritmo de reverse invierte el orden de los elementos dentro de un intervalo, y el algoritmo de reverse_copy también copia el resultado en un rango de destino.

Los algoritmos de STL se ordenan en grupos que indican algo sobre su propósito o requisitos. Incluyen los algoritmos de modificación que cambie el valor de elementos con respecto a los algoritmos nonmodifying que no lo hagan. Los algoritmos que se transforman cambie el orden de los elementos, pero no los valores de sus elementos. quitar algoritmos puede eliminar elementos de un intervalo o de una copia de un intervalo. Los algoritmos de ordenación reordenan los elementos en un intervalo de varias maneras y algoritmos ordenados de intervalo sólo actúan en los algoritmos cuyos elementos se han ordenado de una manera determinada.

Los algoritmos numéricos STL que se proporcionan para el procesamiento numérico tienen su propio archivo de encabezado <numérico> , y funcionan los objetos y los adaptadores son definidas en los objetos de función de <funcional> de encabezado que los valores booleanos return se conocen como predicados. el predicado binario predeterminado es la comparación operator<. Normalmente los elementos que son necesidad ordenada de ser menor que comparables para, con los dos elementos, poder determinar cualquiera que es equivalente (en el sentido de que ninguno es menor que otro) o que uno sea menor que el otro. Esto produce el orden entre los elementos distintos.

yah1y2x8.collapse_all(es-es,VS.110).gifFunciones

adjacent_find

Buscar dos elementos adyacentes que son iguales o cumplen una condición especificada.

all_of

Devuelve true cuando una condición está presente en cada elemento del intervalo especificado.

any_of

Devuelve true cuando una condición se muestre al menos una vez en el rango especificado de elementos.

binary_search

Comprueba si hay un elemento en un intervalo ordenado que sea igual a un valor especificado o que es equivalente a en cierto modo especificado por un predicado binario.

Copiar

Asigna los valores de elementos de un intervalo de origen a un rango de destino, iterando con la secuencia de origen de elementos y asignándoles nuevas posiciones hacia delante.

copy_backward

Asigna los valores de elementos de un intervalo de origen a un rango de destino, iterando con la secuencia de origen de elementos y asignándoles nuevas posiciones en una dirección inversa.

copy_if

Copie todos los elementos en un intervalo dado que no true para una condición especificada

copy_n

copia un número especificado de elementos.

count

devuelve el número de elementos en un intervalo cuya coincidencia de los valores un valor especificado.

count_if

devuelve el número de elementos en un intervalo cuya coincidencia de los valores una condición especificada.

Igual

Compara el elemento de dos intervalos para el elemento de igualdad o la equivalencia en cierto modo especificada por un predicado binario.

equal_range

Encuentra un par de posiciones en un intervalo petición, el primer o menor que el equivalente a la posición de un elemento especificado y el segundo mayor que la posición del elemento, donde el sentido de equivalencia o de ordenación utilizado para establecer las posiciones de la secuencia se puede especificar por un predicado binario.

fill

Asigna el mismo valor nuevo a cada elemento del intervalo especificado.

fill_n

Asigna un nuevo valor en un número especificado de elementos de un intervalo que comienza con un elemento determinado.

Buscar

Busque la posición de la primera aparición de un elemento en un intervalo con un valor especificado.

find_end

Busca en un intervalo para el subsequence último que es idéntico a una secuencia especificada o que es equivalente en cierto modo especificado por un predicado binario.

find_first_of

Buscar la primera aparición de varios valores dentro de un intervalo de destino o para la primera aparición de varios elementos que son equivalentes en cierto modo especificados por un predicado binario un conjunto especificado de los elementos.

find_if

Busque la posición de la primera aparición de un elemento de un intervalo que cumple una condición especificada.

find_if_not

Devuelve el primer elemento del intervalo indicado que no satisfacen una condición.

for_each

Se aplica un objeto especificado de la función a cada elemento en un orden frontal dentro de un intervalo y devuelve el objeto function.

genere

Asigna los valores generados por un objeto de función a cada elemento en un rango.

generate_n

Asigna los valores generados por un objeto de función a un número especificado de elemento es un intervalo y vuelve a la posición una más allá del valor asignado pasado.

incluye

Prueba si un intervalo ordenados contiene todos los elementos contenidos en un intervalo ordenados segundo, donde el orden o el criterio de equivalencia entre los elementos se pueden especificar mediante un predicado binario.

inplace_merge

Combina los elementos de dos intervalos ordenados consecutivos en un único intervalo ordenados, donde el criterio de ordenación se puede especificar por un predicado binario.

is_heap

Devuelve true si los elementos del intervalo especificado forman una pila.

is_heap_until

Devuelve true si el intervalo especificado forma una pila hasta el último elemento.

is_partitioned

Devuelve true si todos los elementos del intervalo especificado qué true para una condición proceden antes de cualquier elemento que pruebe false.

is_sorted

Devuelve true si los elementos del intervalo especificado están ordenados.

is_sorted_until

Devuelve true si los elementos del intervalo especificado están ordenados.

iter_swap

Intercambia dos valores referidos por un par de iteradores especificados.

lexicographical_compare

Compara el elemento por elemento entre dos secuencias para determinar qué es menor de los dos.

lower_bound

Encuentra la posición del primer elemento de un intervalo pedido que tiene un valor mayor o igual a un valor especificado, donde el criterio de ordenación se puede especificar por un predicado binario.

make_checked_array_iterator

Crea checked_array_iterator que puede ser utilizada por otros algoritmos.

make_heap

Convierte los elementos de un intervalo especificado en una pila del primer elemento es el mayor y para el que se puede especificar un criterio de ordenación con un predicado binario.

max

Compara dos objetos y devuelve el mayor de los dos, donde el criterio de ordenación se puede especificar por un predicado binario.

max_element

Encuentra la primera aparición del elemento más grande en un intervalo especificado donde el criterio de ordenación se puede especificar por un predicado binario.

combinar

Combina todos los elementos de dos intervalos de origen ordenados en un rango de destino único, ordenados, donde el criterio de ordenación se puede especificar por un predicado binario.

min

Compara dos objetos y devuelve el menor de los dos, donde el criterio de ordenación se puede especificar por un predicado binario.

min_element

Encuentra la primera aparición del elemento más pequeño en un intervalo especificado donde el criterio de ordenación se puede especificar por un predicado binario.

minmax

Compara dos parámetros de entrada y los devuelve como un par, en orden de al menos al máximo.

minmax_element

realiza el trabajo realizado por min_element y max_element en una llamada.

no

Compara el elemento de dos intervalos para el elemento de igualdad o su equivalente en cierto modo especificado por un predicado binario y busque la primera posición donde una diferencia aparece.

<alg> move

Elementos de movimiento asociado con un intervalo especificado.

move_backward

Mover los elementos de un iterador a otro. El movimiento comienza con el último elemento en un intervalo especificado, y finaliza con el primer elemento en ese intervalo.

next_permutation

Reorganiza los elementos en un intervalo de modo que el orden original se reemplaza por la mayor permutación lexicográficamente siguiente si existe, donde el sentido para el próximo pueden se especifica con un predicado binario.

none_of

Devuelve true cuando una condición nunca está presente entre elementos del intervalo especificado.

nth_element

Las particiones un intervalo de elementos, correctamente situando el enésimoelemento de la secuencia en el intervalo de modo que todos los elementos delante de menor o igual que él y todos los elementos que lo siguen en la secuencia se mayor o igual que.

partial_sort

Organiza un número especificado de elementos más pequeños de un intervalo en nondescending petición o según un criterio de ordenación especificado por un predicado binario.

partial_sort_copy

Copia los elementos de un intervalo de origen en un intervalo de destino donde los elementos de origen se ordenan por menos que u otro predicado binario especificado.

partición

Ordena elementos en un intervalo en dos conjuntos disjuntos, con los elementos satisfaciendo un predicado unario que precede a los que no puedan para satisfacerlo.

partition_copy

Copia los elementos para los que una condición es true a un destino, y para qué es false la condición a otro. Los elementos deben proceder de un intervalo especificado.

partition_point

Devuelve el primer elemento del intervalo especificado no cumple la condición. Se ordenan los elementos para que los que cumplen la condición vengan antes de los que no lo hacen.

pop_heap

Quita el elemento mayor de delante de una pila el siguiente - posición a-pasada en el intervalo y después forma una nueva pila de los elementos restantes.

prev_permutation

Reorganiza los elementos en un intervalo de modo que el orden original se reemplaza por la mayor permutación lexicográficamente siguiente si existe, donde el sentido para el próximo pueden se especifica con un predicado binario.

push_heap

Agrega un elemento que está al final de un intervalo una pila existente que se compone de los elementos anteriores en el intervalo.

random_shuffle

¡Reorganiza una secuencia de elementos n de un intervalo de n! organizaciones posibles seleccionado al azar.

remove

Elimina un valor especificado de un intervalo determinado sin perturbar el orden de los elementos restantes y devolver el final de un nuevo intervalo libre value especificado.

remove_copy

Copia los elementos de un intervalo de origen a un rango de destino, excepto en que los elementos del valor especificado no se copian, sin perturbar el orden de los elementos restantes y devolver el final de un nuevo intervalo de destino.

remove_copy_if

Copia los elementos de un intervalo de origen a un rango de destino, salvo que satisfaciendo un predicado no se copian, sin perturbar el orden de los elementos restantes y devolver el final de un nuevo intervalo de destino.

remove_if

Elimina los elementos que cumplen un predicado de un intervalo determinado sin perturbar el orden de los elementos restantes y devolver el final de un nuevo intervalo libre value especificado.

reemplace

Examina cada elemento en un intervalo y reemplácela si coincide con un valor especificado.

replace_copy

Examina cada elemento en un intervalo de origen y reemplácela si coincide con un valor especificado al copiar el resultado en un nuevo intervalo de destino.

replace_copy_if

Examina cada elemento en un intervalo de origen y reemplácela si satisface un predicado especificado al copiar el resultado en un nuevo intervalo de destino.

replace_if

Examina cada elemento en un intervalo y reemplácela si satisface el predicado especificado.

reverse

Invierte el orden de los elementos dentro de un intervalo.

reverse_copy

Invierte el orden de los elementos dentro de un intervalo de origen mientras la copia en un intervalo de destino

active

Cambie los elementos en dos intervalos adyacentes.

rotate_copy

Cambie los elementos en dos intervalos adyacentes dentro de un intervalo de origen y copia el resultado a un rango de destino.

búsqueda

Buscar la primera aparición de una secuencia dentro de un intervalo de destino cuyos elementos son iguales a los de una secuencia determinada de elementos o cuyos elementos son equivalentes en cierto modo especificados por un predicado binario a los elementos de la secuencia especificada.

search_n

Buscar el primer subsequence de un intervalo que de un número especificado de elementos que tienen un valor determinado o una relación a ese valor según lo especificado por un predicado binario.

set_difference

Une todos los elementos que pertenecen a un intervalo de origen ordenada, pero no a un segundo tamaño el intervalo de origen, en un rango de destino único, ordenados, donde el criterio de ordenación se puede especificar por un predicado binario.

set_intersection

Une todos los elementos que pertenecen a los dos intervalos de origen ordenados en un rango de destino único, ordenados, donde el criterio de ordenación se puede especificar por un predicado binario.

set_symmetric_difference

Une todos los elementos que pertenecen a uno, pero no ambos, intervalos de origen ordenados en un único, ajusta el intervalo de destino, donde el criterio de ordenación se puede especificar por un predicado binario.

set_union

Une todos los elementos que pertenecen al menos uno de dos intervalos de origen ordenados en un rango de destino único, ordenados, donde el criterio de ordenación se puede especificar por un predicado binario.

sort

Organiza los elementos en un intervalo especificado en nondescending petición o según un criterio de ordenación especificado por un predicado binario.

sort_heap

Convierte un montón en un intervalo ordenados.

stable_partition

Ordena elementos en un intervalo en dos conjuntos disjuntos, con los elementos satisfaciendo un predicado unario que precede a los que no puedan para satisfacerlo, conservando el orden relativo de elementos equivalentes.

stable_sort

Organiza los elementos en un intervalo especificado en nondescending petición o según un criterio de ordenación especificado por un predicado binario y conserva el orden relativo de elementos equivalentes.

intercambio

Cambie los valores de los elementos entre dos tipos de objetos, asignando el contenido del primer objeto el segundo objeto y el contenido de segundos al primer.

swap_ranges

Cambie los elementos de un intervalo con elementos de otro, como - intervalo ordenados.

transformación

Se aplica un objeto especificado de la función a cada elemento de un intervalo de origen o un par de elementos de dos intervalos de origen y copia los valores devueltos del objeto function en un rango de destino.

único

Quita los elementos duplicados que se adyacente a uno para en un intervalo especificado.

unique_copy

Copia los elementos de un intervalo de origen en un rango de destino salvo los elementos duplicados que se adyacente a sí.

upper_bound

Encuentra la posición del primer elemento de un intervalo pedido que tiene un valor mayor que un valor especificado, donde el criterio de ordenación se puede especificar por un predicado binario.

Adiciones de comunidad

AGREGAR
Mostrar: