Namespaces
Variants

    std::ranges::stable_partition

    来自 zh.cppreference.net
     
    C++
     
    算法库
    受约束算法与范围算法 (C++20)
    受约束算法，例如 ranges::copy, ranges::sort, ...
    排序与相关操作
    划分操作
    (C++11)    
    (C++11)

    排序操作
    二分搜索操作
    (在划分后的范围上)
    集合操作（在有序范围上）
    合并操作（在有序范围上）
    堆操作
    最小/最大操作
    (C++11)
    (C++17)
    字典序比较操作
    (C++20)
    排列操作


     
    受约束算法
    此菜单中的所有名称均属于命名空间 std::ranges
    不修改序列的操作
    修改序列的操作
    划分操作
    排序操作
    二分搜索操作（在有序范围上）
           
           
        
    集合操作（在有序范围上）
    堆操作
    最小/最大操作
           
           
    排列操作
    折叠操作
    数值操作
    (C++23)            
    未初始化存储上的操作
    返回类型
     
    定义于头文件 <algorithm>
    调用签名
    		 
    template< std::bidirectional_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
requires std::permutable<I>
ranges::subrange<I>
    stable_partition( I first, S last, Pred pred, Proj proj = {} );
    		(1) (C++20 起)
    (C++26 起 constexpr)    		 
    template< ranges::bidirectional_range R, class Proj = std::identity,
          std::indirect_unary_predicate<
              std::projected<ranges::iterator_t<R>, Proj>> Pred >
requires std::permutable<ranges::iterator_t<R>>
ranges::borrowed_subrange_t<R>
    stable_partition( R&& r, Pred pred, Proj proj = {} );
    		(2) (C++20 起)
    (C++26 起 constexpr)
    1) 重排范围 [first, last) 中的元素，使得谓词 proj 对其所有元素投影 pred 返回 true 的元素位于谓词 proj 对其投影 pred 返回 false 的元素之前。该算法是稳定的，即元素的相对顺序得以保持。
    2) 同 (1)，但使用 r 作为范围，如同以 ranges::begin(r) 作为 first 并以 ranges::end(r) 作为 last。

    本页描述的函数式实体是算法函数对象（非正式名称为niebloids），即：

    参数

    first, last - 定义待重排元素 范围 的迭代器-哨位对
    r - 待重排的元素范围
    pred - 应用于投影元素的谓词
    proj - 应用于元素的投影

    返回值

    1) 一个等于 { pivot, last } 的对象，其中 pivot 是指向第二组首个元素的迭代器。
    2) 与 (1) 相同，若 r 是左值或属于 borrowed_range 类型。否则返回 std::ranges::dangling 。

    复杂度

    给定 N = ranges:: distance ( first, last ) ，最坏情况下的复杂度为 N·log(N) 次交换，若使用额外内存缓冲区则仅需 𝓞(N) 次交换。谓词 pred 与投影 proj 均被精确调用 N 次。

    注释

    此函数尝试分配临时缓冲区。若分配失败，将选择效率较低的算法。

    功能测试 宏 值 标准 功能
    __cpp_lib_constexpr_algorithms 202306L (C++26) constexpr 稳定排序

    可能的实现

    此实现未使用额外的内存缓冲区，因此可能效率较低。另请参阅 MSVC STL 与 libstdc++ 中的实现。 

    struct stable_partition_fn
{
    template<std::bidirectional_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::permutable<I>
    constexpr ranges::subrange<I>
        operator()(I first, S last, Pred pred, Proj proj = {}) const
    {
        first = ranges::find_if_not(first, last, pred, proj);
        I mid = first;
        while (mid != last)
        {
            mid = ranges::find_if(mid, last, pred, proj);
            if (mid == last)
                break;
            I last2 = ranges::find_if_not(mid, last, pred, proj);
            ranges::rotate(first, mid, last2);
            first = ranges::next(first, ranges::distance(mid, last2));
            mid = last2;
        }
        return {std::move(first), std::move(mid)};
    }
    template<ranges::bidirectional_range R, class Proj = std::identity,
             std::indirect_unary_predicate<
                 std::projected<ranges::iterator_t<R>, Proj>> Pred>
    requires std::permutable<ranges::iterator_t<R>>
    constexpr ranges::borrowed_subrange_t<R>
        operator()(R&& r, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(pred), std::move(proj));
    }
};
inline constexpr stable_partition_fn stable_partition {};

    示例

    运行此代码 
    #include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
namespace rng = std::ranges;
template<std::permutable I, std::sentinel_for<I> S>
constexpr void stable_sort(I first, S last)
{
    if (first == last)
        return;
    auto pivot = *rng::next(first, rng::distance(first, last) / 2, last);
    auto left = [pivot](const auto& em) { return em < pivot; };
    auto tail1 = rng::stable_partition(first, last, left);
    auto right = [pivot](const auto& em) { return !(pivot < em); };
    auto tail2 = rng::stable_partition(tail1, right);
    stable_sort(first, tail1.begin());
    stable_sort(tail2.begin(), tail2.end());
}
void print(const auto rem, auto first, auto last, bool end = true)
{
    std::cout << rem;
    for (; first != last; ++first)
        std::cout << *first << ' ';
    std::cout << (end ? "\n" : "");
}
int main()
{
    const auto original = {9, 6, 5, 2, 3, 1, 7, 8};
    std::vector<int> vi {};
    auto even = [](int x) { return 0 == (x % 2); };
    print("Original vector:\t", original.begin(), original.end(), "\n");
    vi = original;
    const auto ret1 = rng::stable_partition(vi, even);
    print("Stable partitioned:\t", vi.begin(), ret1.begin(), 0);
    print("│ ", ret1.begin(), ret1.end());
    vi = original;
    const auto ret2 = rng::partition(vi, even);
    print("Partitioned:\t\t", vi.begin(), ret2.begin(), 0);
    print("│ ", ret2.begin(), ret2.end());
    vi = {16, 30, 44, 30, 15, 24, 10, 18, 12, 35};
    print("Unsorted vector: ", vi.begin(), vi.end());
    stable_sort(rng::begin(vi), rng::end(vi));
    print("Sorted vector:   ", vi.begin(), vi.end());
}

    可能的输出： 

    Original vector:        9 6 5 2 3 1 7 8
Stable partitioned:     6 2 8 │ 9 5 3 1 7
Partitioned:            8 6 2 │ 5 3 1 7 9
Unsorted vector: 16 30 44 30 15 24 10 18 12 35
Sorted vector:   10 12 15 16 18 24 30 30 35 44

    另见

    (C++20)
    		 将元素范围分为两组
    (算法函数对象)
    (C++20)
    		 复制一个范围并将元素分为两组
    (算法函数对象)
    (C++20)
    		 判断范围是否按给定谓词划分
    (算法函数对象)
    		将元素分为两组，同时保留每组内的相对顺序
    (函数模板)