Espacios de nombres
Variantes
Acciones

std::partition

De cppreference.com
< cpp‎ | algorithm

 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
(C++11)(C++11)(C++11)
(C++17)
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
partition
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en la cabecera <algorithm>
template< class BidirIt, class UnaryPredicate >

BidirectionalIterator partition( BidirIt first, BidirIt last,
                                 UnaryPredicate p );
template< class ForwardIt, class UnaryPredicate >
ForwardIt partition( ForwardIt first, ForwardIt last,

                     UnaryPredicate p );
(hasta C++11)

(desde C++11)
Reordena los elementos de la [first, last) rango de tal manera que todos los elementos para los que el predicado p vuelve true preceder a los elementos para los que predicado p vuelve false. Orden relativo de los elementos no se conserva .
Original:
Reorders the elements in the range [first, last) in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false. Relative order of the elements is not preserved.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Contenido

[editar] Parámetros

first, last -
la gama de elementos a ordenar
Original:
the range of elements to reorder
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
p - predicado unario que devuelve ​true
si el elemento debe pedirse antes de otros elementos
Original:
if the element should be ordered before other elements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
.

La firma de la función predicado debe ser equivalente a:

 bool pred(const Type &a);

La forma no necesita tener const &, pero la función no debe modificar el objeto que ha sido pasado.
El tipo Type debe ser tal que un objeto del tipo ForwardIt puede ser derreferenciado y entonces convertido implícitamente a Type. ​

Requerimientos de tipo
-
BidirIt debe reunir los requerimientos de BidirectionalIterator.
-
ForwardIt debe reunir los requerimientos de ValueSwappable y ForwardIterator. However, the operation is more efficient if ForwardIt also satisfies the requirements of BidirectionalIterator

[editar] Valor de retorno

Iterador al primer elemento del segundo grupo .
Original:
Iterator to the first element of the second group.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complejidad

Exactamente last-first aplicaciones del predicado y en la mayoría de los swaps last-first. Si ForwardIt cumple los requisitos de BidirectionalIterator en la mayoría de los swaps (last-first)/2 se hacen .
Original:
Exactly last-first applications of the predicate and at most last-first swaps. If ForwardIt meets the requirements of BidirectionalIterator at most (last-first)/2 swaps are done.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Posible implementación

template<class BidirIt, class UnaryPredicate>
BidirIt partition(BidirIt first, BidirIt last, UnaryPredicate p)
{
    while (1) {
        while ((first != last) && p(*first)) {
            ++first;
        }
        if (first == last--) break;
        while ((first != last) && !p(*last)) {
            --last;
        }
        if (first == last) break;
        std::swap(*first++, *last);
    }
    return first;
}

[editar] Ejemplo

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
 
bool is_even(int i) { return i % 2 == 0; }
 
int main()
{
    std::vector<int> v;
    for (int i = 0; i < 10; ++i) v.push_back(i);
 
    std::cout << "Original vector:\n    ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
 
    // Partition the vector
    std::vector<int>::iterator p =
        std::partition(v.begin(), v.end(), std::ptr_fun(is_even));
 
    std::cout << "\nPartitioned vector:\n    ";
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nBefore partition:\n    ";
    std::copy(v.begin(), p,       std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\nAfter partition:\n    ";
    std::copy(p,         v.end(), std::ostream_iterator<int>(std::cout, " "));
}

Posible salida:

Original vector:
    0 1 2 3 4 5 6 7 8 9 
Partitioned vector:
    0 8 2 6 4 5 3 7 1 9 
Before partition:
    0 8 2 6 4 
After partition:
    5 3 7 1 9

[editar] Ver también

determina si el intervalo está dividido por el predicado dado
Original:
determines if the range is partitioned by the given predicate
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) [editar]
elementos divide en dos grupos, preservando su orden relativo
Original:
divides elements into two groups while preserving their relative 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) [editar]