Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::nth_element

      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
      (C++11)
      nth_element

      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 RandomIt>
      void nth_element( RandomIt first, RandomIt nth, RandomIt last);
      (1)(constexpr since C++20)
      template<class ExecutionPolicy,class RandomIt>

      void nth_element( ExecutionPolicy&& policy,

                        RandomIt first, RandomIt nth, RandomIt last);
      (2)(since C++17)
      template<class RandomIt,class Compare>

      void nth_element( RandomIt first, RandomIt nth, RandomIt last,

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

      void nth_element( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt nth, RandomIt last,

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

      nth_element rearranges elements in[firstlast) such that after the rearrangement:

      • The element pointed at bynth is changed to whatever element would occur in that position if[firstlast) were sorted.
      • For every iteratori in[firstnth) and every iteratorj in[nthlast), the following condition is met:
      1,2)bool(*j<*i)(until C++20)std::less{}(*j,*i)(since C++20) isfalse.
      3,4)bool(comp(*j,*i)) isfalse.


      1) Elements are hypotheticallysorted with respect tooperator<(until C++20)std::less{}(since C++20).
      3) Elements are hypothetically 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 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 for partial sorting
      nth - random access iterator defining the sort partition point
      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
      -
      RandomIt must meet the requirements ofLegacyRandomAccessIterator.
      -
      Compare must meet the requirements ofCompare.

      [edit]Complexity

      Given\(\scriptsize N\)N aslast- first:

      1)\(\scriptsize O(N)\)O(N) comparisons usingoperator<(until C++20)std::less{}(since C++20) on average.
      2)\(\scriptsize O(N)\)O(N) comparisons usingoperator<(until C++20)std::less{}(since C++20), and\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) swaps.
      3)\(\scriptsize O(N)\)O(N) applications of the comparatorcomp on average.
      4)\(\scriptsize O(N)\)O(N) applications of the comparatorcomp, and\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) swaps.

      [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++,libc++, andMSVC STL.

      [edit]Notes

      The algorithm used is typicallyIntroselect although otherSelection algorithm with suitable average-case complexity are allowed.

      [edit]Example

      Run this code
      #include <algorithm>#include <cassert>#include <functional>#include <iostream>#include <numeric>#include <vector> void printVec(conststd::vector<int>& vec){std::cout<<"v = {";for(char sep[]{0,' ',0};constint i: vec)std::cout<< sep<< i, sep[0]=',';std::cout<<"};\n";} int main(){std::vector<int> v{5,10,6,4,3,2,6,7,9,3};    printVec(v); auto m= v.begin()+ v.size()/2;    std::nth_element(v.begin(), m, v.end());std::cout<<"\nThe median is "<< v[v.size()/2]<<'\n';// The consequence of the inequality of elements before/after the Nth one:assert(std::accumulate(v.begin(), m,0)<std::accumulate(m, v.end(),0));    printVec(v); // Note: comp function changed    std::nth_element(v.begin(), v.begin()+1, v.end(),std::greater{});std::cout<<"\nThe second largest element is "<< v[1]<<'\n';std::cout<<"The largest element is "<< v[0]<<'\n';    printVec(v);}

      Possible output:

      v = {5, 10, 6, 4, 3, 2, 6, 7, 9, 3}; The median is 6v = {3, 2, 3, 4, 5, 6, 10, 7, 9, 6}; The second largest element is 9The largest element is 10v = {10, 9, 6, 7, 6, 3, 5, 4, 3, 2};

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2150C++98after the rearrangement, only one element beforenth
      was required to be not greater than one element afternth
      corrected the
      requirement
      LWG 2163C++98overload(1) usedoperator> to compare the elementschanged tooperator<
      P0896R4C++98[firstnth) and[nthlast)
      were not required to be valid ranges
      the behavior is undefined
      if any of them is invalid

      [edit]See also

      returns the largest element in a range
      (function template)[edit]
      returns the smallest element in a range
      (function template)[edit]
      copies and partially sorts a range of elements
      (function template)[edit]
      sorts a range of elements while preserving order between equal elements
      (function template)[edit]
      sorts a range into ascending order
      (function template)[edit]
      partially sorts the given range making sure that it is partitioned by the given element
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/nth_element&oldid=180400"

      [8]ページ先頭

      ©2009-2025 Movatter.jp