C++ как объединить отсортированные векторы в отсортированный вектор / pop наименьший элемент из всех них?

первое, что приходит на ум, - это сделать структуру кучи, содержащую итераторы для каждого вектора, упорядоченную по значению, на которое они в настоящее время указывают. (каждая запись также должна содержать конечный итератор)

текущий элемент находится в корне кучи, и для продвижения, вы просто либо поп его, либо увеличить его ключ. (последнее может быть сделано путем выскакивания, увеличения, а затем нажатия)

Я считаю, что это должно иметь асимптотическую сложность O(E log M) где E - общее количество элементов, и M - количество векторов.

если вы действительно выталкиваете все из векторов, вы можете сделать кучу указателей на свои векторы, вы можете рассматривать их как кучи, чтобы избежать штрафа за производительность стирания из передней части вектора. (или, вы можете скопировать все в deques первый)

объединение их всех вместе путем объединения пар за раз имеет одинаковую асимптотическую сложность, если ты осторожен с заказом. Если вы расположите все векторы в полном, сбалансированном двоичном дереве, а затем попарно слить, как вы идете вверх по дереву, то каждый элемент будет скопирован log M раз, также приводит к .

для дополнительной фактической эффективности вместо дерева вы должны повторно объединить наименьшие два вектора, пока у вас не останется только один. (опять же, размещение указателей на векторы в куче-это путь, но на этот раз упорядоченный длина)

(действительно, Вы хотите заказать "стоимость копирования" вместо длины. Дополнительная вещь для оптимизации для определенных типов значений)

если бы мне пришлось угадать, самым быстрым способом было бы использовать вторую идею, но с слиянием N-ary вместо попарного слияния для некоторого подходящего N (который, как я предполагаю, будет либо небольшой константой, либо примерно квадратным корнем из числа векторов), и выполнить слияние N-ary, используя первый алгоритм выше для перечисления содержимое N векторов сразу.

я использовал алгоритм, приведенный здесь, и сделал небольшую абстракцию; преобразование в шаблоны. Я закодировал эту версию в VS2010 и использовал лямбда-функцию вместо функтора. Я не знаю, в каком смысле это "лучше", чем предыдущая версия, но, может быть, это будет кому-то полезно?

#include <queue>
#include <vector>

namespace priority_queue_sort
{
    using std::priority_queue;
    using std::pair;
    using std::make_pair;
    using std::vector;

    template<typename T>
    void value_vectors(const vector< vector <T> * >& input_sorted_vectors, vector<T> &output_vector)
    {
        typedef vector<T>::iterator iter;
        typedef pair<iter, iter>    iter_pair;

        static auto greater_than_lambda = [](const iter_pair& p1, const iter_pair& p2) -> bool { return *(p1.first) >  *(p2.first); };

        priority_queue<iter_pair, std::vector<iter_pair>, decltype(greater_than_lambda) > cluster_feeder(greater_than_lambda);

        size_t total_size(0);

        for (auto k = input_sorted_vectors.begin(); k != input_sorted_vectors.end(); ++k)
        {
            cluster_feeder.push( make_pair( (*k)->begin(), (*k)->end() ) );
            total_size += (*k)->size();
        }

        output_vector.resize(total_size);
        total_size = 0;
        iter_pair c_lead;
        while (cluster_feeder.empty() != true)
        {
            c_lead = cluster_feeder.top();
            cluster_feeder.pop();
            output_vector[total_size++] = *(c_lead.first);
            c_lead.first++;
            if (c_lead.first != c_lead.second) cluster_feeder.push(c_lead);
        }
    }

    template<typename U, typename V>
    void pair_vectors(const vector< vector < pair<U, V> > * >& input_sorted_vectors, vector< pair<U, V> > &output_vector)
    {
        typedef vector< pair<U, V> >::iterator iter;
        typedef pair<iter, iter> iter_pair;

        static auto greater_than_lambda = [](const iter_pair& p1, const iter_pair& p2) -> bool { return *(p1.first) >  *(p2.first); };

        priority_queue<iter_pair, std::vector<iter_pair>, decltype(greater_than_lambda) > cluster_feeder(greater_than_lambda);

        size_t total_size(0);

        for (auto k = input_sorted_vectors.begin(); k != input_sorted_vectors.end(); ++k)
        {
            cluster_feeder.push( make_pair( (*k)->begin(), (*k)->end() ) );
            total_size += (*k)->size();
        }

        output_vector.resize(total_size);
        total_size = 0;
        iter_pair c_lead;

        while (cluster_feeder.empty() != true)
        {
            c_lead = cluster_feeder.top();
            cluster_feeder.pop();
            output_vector[total_size++] = *(c_lead.first);  
            c_lead.first++;
            if (c_lead.first != c_lead.second) cluster_feeder.push(c_lead);
        }
    }
}

алгоритм priority_queue_sort::value_vectors сортирует векторы, содержащие только значения; тогда как priority_queue_sort::pair_vectors сортирует векторы, содержащие пары данных в соответствии с первым элементом данных. Надеюсь, кто-то сможет используйте это когда-нибудь :-)