Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::sort

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

      void sort( ExecutionPolicy&& policy,

                 RandomIt first, RandomIt last);
      (2)(since C++17)
      template<class RandomIt,class Compare>
      void sort( RandomIt first, RandomIt last, Compare comp);
      (3)(constexpr since C++20)
      template<class ExecutionPolicy,class RandomIt,class Compare>

      void sort( ExecutionPolicy&& policy,

                 RandomIt first, RandomIt last, Compare comp);
      (4)(since C++17)

      Sorts the elements in the range[firstlast) in non-descending order. 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 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
      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,2)\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) comparisons usingoperator<(until C++20)std::less{}(since C++20).
      3,4)\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) 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]Notes

      BeforeLWG713, the complexity requirement allowedsort() to be implemented using onlyQuicksort, which may need\(\scriptsize O(N^2)\)O(N2
      )
      comparisons in the worst case.

      Introsort can handle all cases with\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) comparisons (without incurring additional overhead in the average case), and thus is usually used for implementingsort().

      libc++ has not implemented the corrected time complexity requirementuntil LLVM 14.

      [edit]Example

      Run this code
      #include <algorithm>#include <array>#include <functional>#include <iostream>#include <string_view> int main(){std::array<int,10> s{5,7,4,2,8,6,1,9,0,3}; auto print=[&s](std::string_viewconst rem){for(auto a: s)std::cout<< a<<' ';std::cout<<": "<< rem<<'\n';};     std::sort(s.begin(), s.end());    print("sorted with the default operator<");     std::sort(s.begin(), s.end(),std::greater<int>());    print("sorted with the standard library compare function object"); struct{bool operator()(int a,int b)const{return a< b;}}    customLess;     std::sort(s.begin(), s.end(), customLess);    print("sorted with a custom function object");     std::sort(s.begin(), s.end(),[](int a,int b){return a> b;});    print("sorted with a lambda expression");}

      Output:

      0 1 2 3 4 5 6 7 8 9 : sorted with the default operator<9 8 7 6 5 4 3 2 1 0 : sorted with the standard library compare function object0 1 2 3 4 5 6 7 8 9 : sorted with a custom function object9 8 7 6 5 4 3 2 1 0 : sorted with a lambda expression

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 713C++98the\(\scriptsize O(N \cdot \log(N))\)O(N·log(N)) time complexity was only required on the averageit is required for the worst case

      [edit]See also

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

      [8]ページ先頭

      ©2009-2025 Movatter.jp