std::ranges::is_sorted_until

< cpp‎ | algorithm‎ | ranges
 
 
算法库
有制约算法及范围上的算法 (C++20)
有制约算法: std::ranges::copy, std::ranges::sort, ...
执行策略 (C++17)
不修改序列的操作
(C++11)(C++11)(C++11)
(C++17)
修改序列的操作
未初始化存储上的操作
划分操作
排序操作
(C++11)
二分搜索操作
集合操作(在已排序范围上)
堆操作
(C++11)
最小/最大操作
(C++11)
(C++17)

排列
数值运算
C 库
 
有制约算法
不修改序列的操作
修改序列的操作
未初始化存储上的操作
划分操作
排序操作
ranges::is_sorted_until
二分搜索操作
集合操作(在已排序范围上)
堆操作
最小/最大操作
排列
 
定义于头文件 <algorithm>
调用签名
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,

          std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less >

constexpr I is_sorted_until( I first, S last, Comp comp = {}, Proj proj = {} );
(1) (C++20 起)
template< std::forward_range R, class Proj = std::identity,

          std::indirect_strict_weak_order<
              std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less >
  constexpr ranges::borrowed_iterator_t<R>

is_sorted_until( R&& r, Comp comp = {}, Proj proj = {} );
(2) (C++20 起)

检验范围 [first, last) 并寻找始于 first 且元素按不降序排序的最大范围。

若对于任何指向序列的迭代器 it 与任何使得 it + n 为指向序列元素的合法迭代器的非负整数 nstd::invoke(comp, std::invoke(proj, *(it + n)), std::invoke(proj, *it)) 求值为 false ,则称序列相对于比较器 comp 已排序。

1) 用给定的二元比较函数 comp 比较元素。
2)(1) ,但以 r 为源范围,如同以 ranges::begin(r)first 并以 ranges::end(r)last

此页面上描述的仿函数实体是 niebloid ,即:

实际上,它们能以函数对象,或以某些特殊编译器扩展实现。

参数

first, last - 定义要寻找其已排序上界的范围的迭代器-哨位对
r - 要寻找其已排序上界的范围
comp - 应用到投影后元素的比较函数
proj - 应用到元素的投影

返回值

始于 first ,且元素按不降序排序的最大范围的上界。即使得范围 [first, it) 已排序的最末迭代器 it

复杂度

firstlast 间的距离成线性。

可能的实现

struct is_sorted_until_fn {
  template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
           std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less>
  constexpr I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
  {
      if (first == last) {
          return first;
      }
 
      auto next = first;
      while (++next != last) {
          if (std::invoke(comp, std::invoke(proj, *next), std::invoke(proj, *first))) {
              return next;
          }
          first = next;
      }
 
      return first;
  }
 
  template< ranges::forward_range R, class Proj = std::identity,
          std::indirect_strict_weak_order<
              std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less >
  constexpr ranges::borrowed_iterator_t<R>
  operator()( R&& r, Comp comp = {}, Proj proj = {} ) const
  {
      return (*this)(ranges::begin(r), ranges::end(r),
                     std::ref(comp), std::ref(proj));
  }
};
 
inline constexpr is_sorted_until_fn is_sorted_until;

注解

ranges::is_sorted_until 对空范围和长度为 1 的范围返回等于 last 的迭代器。

示例

#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
 
int main()
{
    std::random_device rd;
    std::mt19937 g{rd()};
    std::array nums {3, 1, 4, 1, 5, 9};
 
    constexpr int min_sorted_size = 4;
    int sorted_size = 0;
    do {
        std::ranges::shuffle(nums, g);
        const auto sorted_end = std::ranges::is_sorted_until(nums);
        sorted_size = std::ranges::distance(nums.begin(), sorted_end);
 
        std::ranges::copy(nums, std::ostream_iterator<int>(std::cout, " "));
        std::cout << " : " << sorted_size << " leading sorted element(s)\n";
    } while (sorted_size < min_sorted_size);
}

可能的输出:

4 1 9 5 1 3  : 1 leading sorted element(s)
4 5 9 3 1 1  : 3 leading sorted element(s)
9 3 1 4 5 1  : 1 leading sorted element(s)
1 3 5 4 1 9  : 3 leading sorted element(s)
5 9 1 1 3 4  : 2 leading sorted element(s)
4 9 1 5 1 3  : 2 leading sorted element(s)
1 1 4 9 5 3  : 4 leading sorted element(s)

参阅

检查范围是否以升序排序
(niebloid)
找出最大的已排序子范围
(函数模板)