Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::partial_sort_copy

      From cppreference.com
      <cpp‎ |algorithm
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      Operations on uninitialized memory
       
      Defined in header<algorithm>
      template<class InputIt,class RandomIt>

      RandomIt partial_sort_copy( InputIt first, InputIt last,

                                  RandomIt d_first, RandomIt d_last);
      (1)(constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt,class RandomIt>
      RandomIt partial_sort_copy( ExecutionPolicy&& policy,
                                  ForwardIt first, ForwardIt last,

                                  RandomIt d_first, RandomIt d_last);
      (2)(since C++17)
      template<class InputIt,class RandomIt,class Compare>

      RandomIt partial_sort_copy( InputIt first, InputIt last,
                                  RandomIt d_first, RandomIt d_last,

                                  Compare comp);
      (3)(constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt,class RandomIt,class Compare>
      RandomIt partial_sort_copy( ExecutionPolicy&& policy,
                                  ForwardIt first, ForwardIt last,
                                  RandomIt d_first, RandomIt d_last,

                                  Compare comp);
      (4)(since C++17)

      Sorts some of the elements in the range[firstlast) in ascending order, storing the result in the range[d_firstd_last).

      At mostd_last- d_first of the elements are placed sorted to the range[d_firstd_first+ n).n is the number of elements to sort (std::min(std::distance(first, last), d_last- d_first)). The order of equal elements is not guaranteed to be preserved.

      1) Elements aresorted with respect tooperator<(until C++20)std::less{}(since C++20).
      3) Elements are sorted with respect tocomp.
      2,4) Same as(1,3), but executed according topolicy.
      These overloads participate in overload resolution only if all following conditions are satisfied:

      std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> istrue.

      (until C++20)

      std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> istrue.

      (since C++20)

      If*first is notwritable tod_first, the program is ill-formed.

      If any of the following conditions is satisfied, the behavior is undefined:

      (until C++11)
      (since C++11)

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to sort
      d_first, d_last - the pair of iterators defining therange of elements to which the sorted data will be assigned
      policy - theexecution policy to use
      comp - comparison function object (i.e. an object that satisfies the requirements ofCompare) which returns ​true if the first argument isless than (i.e. is orderedbefore) the second.

      The signature of the comparison function should be equivalent to the following:

      bool cmp(const Type1& a,const Type2& b);

      While the signature does not need to haveconst&, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const)Type1 andType2 regardless ofvalue category (thus,Type1& is not allowed, nor isType1 unless forType1 a move is equivalent to a copy(since C++11)).
      The typesType1 andType2 must be such that an object of typeRandomIt can be dereferenced and then implicitly converted to both of them.​

      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.
      -
      ForwardIt must meet the requirements ofLegacyForwardIterator.
      -
      RandomIt must meet the requirements ofLegacyRandomAccessIterator.
      -
      Compare must meet the requirements ofCompare.

      [edit]Return value

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

      [edit]Complexity

      Given\(\scriptsize N\)N asstd::distance(first, last),\(\scriptsize D\)D asd_last- d_first:

      1,2) Approximately\(\scriptsize N \cdot \log(\min(N,D))\)N·log(min(N,D)) comparisons usingoperator<(until C++20)std::less{}(since C++20).
      3,4) Approximately\(\scriptsize N \cdot \log(\min(N,D))\)N·log(min(N,D)) applications of the comparatorcomp.

      [edit]Exceptions

      The overloads with a template parameter namedExecutionPolicy report errors as follows:

      • If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory,std::bad_alloc is thrown.

      [edit]Possible implementation

      See also the implementations inlibstdc++ andlibc++.

      [edit]Example

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

      Run this code
      #include <algorithm>#include <functional>#include <iostream>#include <string_view>#include <type_traits>#include <vector> void println(std::string_view rem,constauto& v){std::cout<< rem;ifconstexpr(std::is_scalar_v<std::decay_t<decltype(v)>>)std::cout<< v;elsefor(int e: v)std::cout<< e<<' ';std::cout<<'\n';} int main(){constauto 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());    println("Writing to the smaller vector in ascending order gives: ", v1); if(it== v1.end())        println("The return value is the end iterator",' ');     it= std::partial_sort_copy(v0.begin(), v0.end(), v2.begin(), v2.end(),std::greater<int>());     println("Writing to the larger vector in descending order gives: ", v2);    println("The return value is the iterator to ",*it);}

      Output:

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

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      P0896R4C++98*first was not required to be writable tod_firstthe program is ill-formed if not writable

      [edit]See also

      sorts the first N elements of a range
      (function template)[edit]
      sorts a range into ascending order
      (function template)[edit]
      sorts a range of elements while preserving order between equal elements
      (function template)[edit]
      copies and partially sorts a range of elements
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/partial_sort_copy&oldid=180396"

      [8]ページ先頭

      ©2009-2025 Movatter.jp