std::partial_sort_copy - cppreference.com

De cppreference.com

Definido no cabeçalho `<algorithm>`

`template< class InputIt, class RandomIt > RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last );`	(1)

`template< class InputIt, class RandomIt, class Compare > RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last, Compare comp );`	(2)

Classifica alguns dos elementos no intervalo [first, last) em ordem ascendente. No máximo d_first - d_last dos elementos são movidos para o [d_first, d_first + n) intervalo e classificados. n é o número de elementos para classificar (n = min(last - first, d_last - d_first)). A ordem dos elementos iguais não é garantido para ser preservado. A primeira versão utiliza operator< para comparar os elementos, a segunda versão utiliza a função de comparação dada comp.

Original:

Sorts some of the elements in the range [first, last) in ascending order. At most d_first - d_last of the elements are moved to the range [d_first, d_first + n) and then sorted. n is the number of elements to sort (n = min(last - first, d_last - d_first)). The order of equal elements is not guaranteed to be preserved. The first version uses operator< to compare the elements, the second version uses the given comparison function comp.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parâmetros

first, last	-	a gama de elementos para classificar Original: the range of elements to sort The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
d_first, d_last	-	aleatórios iteradores de acesso que definem o intervalo de destino Original: random access iterators defining the destination range The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
comp	-	comparison function which returns `true` if the first argument is less than the second. The signature of the comparison function should be equivalent to the following: `bool cmp(const Type1 &a, const Type2 &b);` The signature does not need to have `const &`, but the function must not modify the objects passed to it. The types `Type1` and `Type2` must be such that an object of type `RandomIt` can be dereferenced and then implicitly converted to both of them.
Type requirements
-`InputIt` must meet the requirements of `InputIterator`.
-`RandomIt` must meet the requirements of `ValueSwappable` and `RandomAccessIterator`.
-The type of dereferenced `RandomIt` must meet the requirements of `MoveAssignable` and `MoveConstructible`.

Valor de retorno

um iterador para o elemento que define o limite superior do intervalo de ordenadas, ou seja d_first + min(last - first, d_last - d_first).

Original:

an iterator to the element defining the upper boundary of the sorted range, i.e. d_first + min(last - first, d_last - d_first).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Complexidade

O(N·log(min(D,N)), onde N = std::distance(first, last), D = std::distance(d_first, d_last) aplicações de cmp.

Original:

O(N·log(min(D,N)), where N = std::distance(first, last), D = std::distance(d_first, d_last) applications of cmp.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Exemplo

Os tipos de código a seguir um vetor de números inteiros e copiá-los em um menor e um maior vetor .

Original:

The following code sorts an vector of integers and copies them into a smaller and a larger vector.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <algorithm>
#include <vector>
#include <functional>
#include <iostream>

int main()
{
    std::vector<int> v0{4, 2, 5, 1, 3};
    std::vector<int> v1{10, 11, 12};
    std::vector<int> v2{10, 11, 12, 13, 14, 15, 16};
    std::vector<int>::iterator it;

    it = std::partial_sort_copy(v0.begin(), v0.end(), v1.begin(), v1.end());

    std::cout << "Writing to the smaller vector in ascending order gives: ";
    for (int a : v1) {
        std::cout << a << " ";
    }
    std::cout << '\n';
    if(it == v1.end())
        std::cout << "The return value is the end iterator\n";

    it = std::partial_sort_copy(v0.begin(), v0.end(), v2.begin(), v2.end(), 
                                std::greater<int>());

    std::cout << "Writing to the larger vector in descending order gives: ";
    for (int a : v2) {
        std::cout << a << " ";
    }
    std::cout << '\n' << "The return value is the iterator to " << *it << '\n';
}

Saída:

Writing to the smaller vector in ascending order gives: 1 2 3
The return value is the end iterator
Writing to the larger vector in descending order gives: 5 4 3 2 1 15 16
The return value is the iterator to 15

Veja também


partial_sort	classifica os elementos N primeiros de uma série 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. (modelo de função) [edit]

sort	tipo um intervalo em ordem crescente 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. (modelo de função) [edit]

stable_sort	Classifica um intervalo de elementos preservando ordem entre elementos iguais 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. (modelo de função) [edit]