合并N，按向量c+排序+； 我有一个排序的C++类向量，它们有比较运算符。我需要排序对象的向量。是否有任何开源算法可以获取向量列表或向量向量并生成一个排序向量

对于n=2，这可以正常工作：

std::vector<Data> dst;
std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(dst));

std:：向量dst；
std:：merge（v1.begin（）、v1.end（）、v2.begin（）、v2.end（）、std:：back_插入器（dst））；

标准库包含，允许合并两个已排序向量（尤其是）

假设有k个序列，总长度为n。当然，您可以每次合并两个序列，直到只剩下一个序列，但这是一个错误

有两种选择：

• 按贪婪大小合并在该变体中，每次合并两个最短的序列。这[减少了最坏情况下的恢复时间]

• 与中的优先级队列合并时，优先级队列包含迭代器和序列索引对，当弹出最小元素时，将推送具有此索引的序列中的下一项。这有时间Θ（log（k）n），因为优先级队列每次最多有k项

下面是后者的一个实现（打开了完整的代码）。（我怀疑，虽然渐进性优于前者，但它的常数远高于前者。不过，贪婪算法的通用实现（至少对我来说）有点棘手。）

包括
#包括
#包括
模板<
类初始化，
typename OutIt，
类别Cmp=std:：less>
OutIt合并（const InIts&in_its，OutIt out_it，Cmp=Cmp（））
{
使用它\u t=typename InIts:：value\u type:：first\u type；
使用pair_t=std:：pair；
自动对\u cmp=[cmp]（常数对\u t&lhs，常数对\u t&rhs）{return！cmp（*lhs.first，*rhs.first）；}；
使用q_t=std:：priority_队列；
std：：矢量原点{in_its}；
q_t q{pair_cmp}；
对于（std:：size_t i=0；i

您可以按如下方式使用它：

int main()
{
    using vec_t = std::vector<int>;

    vec_t v0{1, 2, 3}; 
    vec_t v1{2, 3, 4}; 
    vec_t v2{4, 5, 6}; 

    using vec_it_t = vec_t::iterator;

    std::vector<std::pair<vec_it_t, vec_it_t>> its{
        std::make_pair(std::begin(v0), std::end(v0)),
        std::make_pair(std::begin(v1), std::end(v1)),
        std::make_pair(std::begin(v2), std::end(v2))};

    vec_t res;
    merge(its, std::back_inserter(res));
    for(auto &e: res)
        std::cout << e << std::endl;
}

intmain（）
{
使用vec_t=std:：vector；
向量v0{1,2,3}；
向量v1{2,3,4}；
向量v2{4,5,6}；
使用vec_it_t=vec_t:：迭代器；
向量its{
std:：make_对（std:：begin（v0），std:：end（v0）），
std:：make_pair（std:：begin（v1）、std:：end（v1）），
std:：make_pair（std:：begin（v2），std:：end（v2））；
向量；
合并（its，std：：back_插入器（res））；
用于（自动和电气：分辨率）
标准库包含，允许合并两个已排序的向量（特别是）

假设你有k个序列，总长度为n。当然，你可以每次合并2个序列，直到只剩下一个序列，但这是

有两种选择：


按贪婪大小合并在这种变体中，每次都合并两个最短的序列。这[将最坏情况下的时间缩短到

与中的优先级队列合并时，优先级队列包含迭代器和序列索引对，当弹出最小元素时，将推送具有此索引的序列中的下一项。这有时间Θ（log（k）n），因为优先级队列每次最多有k项


下面是后者的一个实现（打开了完整的代码）。（我怀疑，虽然渐进性优于前者，但它的常数远高于前者。不过，贪婪算法的通用实现（至少对我来说）有点棘手。）

包括
#包括
#包括
模板<
类初始化，
typename OutIt，
类别Cmp=std:：less>
OutIt合并（const InIts&in_its，OutIt out_it，Cmp=Cmp（））
{
使用它\u t=typename InIts:：value\u type:：first\u type；
使用pair_t=std:：pair；
自动对\u cmp=[cmp]（常数对\u t&lhs，常数对\u t&rhs）{return！cmp（*lhs.first，*rhs.first）；}；
使用q_t=std:：priority_队列；
std：：矢量原点{in_its}；
q_t q{pair_cmp}；
对于（std:：size_t i=0；i

您可以按如下方式使用它：

int main()
{
    using vec_t = std::vector<int>;

    vec_t v0{1, 2, 3}; 
    vec_t v1{2, 3, 4}; 
    vec_t v2{4, 5, 6}; 

    using vec_it_t = vec_t::iterator;

    std::vector<std::pair<vec_it_t, vec_it_t>> its{
        std::make_pair(std::begin(v0), std::end(v0)),
        std::make_pair(std::begin(v1), std::end(v1)),
        std::make_pair(std::begin(v2), std::end(v2))};

    vec_t res;
    merge(its, std::back_inserter(res));
    for(auto &e: res)
        std::cout << e << std::endl;
}

intmain（）
{
使用vec_t=std:：vector；
向量v0{1,2,3}；
向量v1{2,3,4}；
向量v2{4,5,6}；
使用vec_it_t=vec_t:：迭代器；
向量its{
std:：make_对（std:：begin（v0），std:：end（v0）），
std:：make_pair（std:：begin（v1）、std:：end（v1）），
std:：make_pair（std:：begin（v2），std:：end（v2））；
向量；
合并（its，std：：back_插入器（res））；
用于（自动和电气：分辨率）
如果你能合并2个向量，合并n个向量有什么问题？只需在
v[i]
和
v[i+1]
的循环中执行上面的操作，它不会工作吗？我有300个向量要合并，每个向量有50000个数据点。这将持续运行，我希望保持O（n）我想我可以在一个循环中合并如果你可以合并2个向量，合并n个向量有什么问题？只需在一个循环中使用
v[I]
和
v[I+1]
就可以了，不是吗？我有300个向量要合并，每个向量有50000个数据点。这将持续运行，我希望保持O（n）我想我可以在一个循环中合并优先级队列实现应该是O（n*logk），不是吗？@interjay非常感谢-你完全正确（正确