WikiDer > K-способ слияния

В kЗадача -way слияния состоит в объединении k отсортированных массивов для создания единого отсортированного массива с теми же элементами. Обозначьте n общее количество элементов. n равно размеру выходного массива и сумме размеров входного k Для простоты мы предполагаем, что ни один из входных массивов не является пустым. ${ Displaystyle к <п}$, что упрощает сообщаемое время работы. Проблема может быть решена в ${ Displaystyle { mathcal {O}} (п cdot log (k))}$ время работы с ${ Displaystyle { mathcal {O}} (п)}$ Существует несколько алгоритмов, позволяющих достичь этого времени работы.

Итеративное двухстороннее слияние

Проблема может быть решена путем итеративного слияния двух из k массивов с использованием двухстороннего слияния, пока не останется только один массив. Если массивы объединяются в произвольном порядке, то результирующее время работы составляет всего O (kn). Это неоптимально.

Время работы можно улучшить, итеративно объединяя первое со вторым, третье с четвертым и так далее. Поскольку количество массивов уменьшается вдвое на каждой итерации, существует только Θ (log k) итераций. На каждой итерации каждый элемент перемещается ровно один раз. Таким образом, время выполнения на итерацию выражается в Θ (n), поскольку n - количество элементов. Таким образом, общее время работы выражается в Θ (n log k).

Мы можем дополнительно улучшить этот алгоритм, итеративно объединяя два самых коротких массива. Понятно, что это минимизирует время работы и поэтому не может быть хуже стратегии, описанной в предыдущем абзаце. Таким образом, время работы составляет O (n log k). К счастью, в пограничных случаях время работы может быть лучше. Рассмотрим, например, вырожденный случай, когда все массивы, кроме одного, содержат только один элемент. Стратегия, описанная в предыдущем абзаце, требует времени выполнения n (n log k), в то время как улучшенная стратегия требует только времени работы (n).

Прямой k-way слияние

В этом случае мы одновременно объединим k-пробеги вместе.

Простая реализация просканирует все k массивов для определения минимума. Эта простая реализация приводит к времени работы (kn). Обратите внимание, что это упоминается только как возможность для обсуждения. Хотя это сработает, это неэффективно.

Мы можем улучшить это, вычислив наименьший элемент быстрее. кучи, турнирные деревья или растопыренные деревья, наименьший элемент может быть определен за время O (log k), поэтому результирующее время работы составляет O (n log k).

Чаще используется куча, хотя на практике турнирное дерево работает быстрее. Куча использует приблизительно 2 * log (k) сравнений на каждом шаге, потому что она обрабатывает дерево от корня до низа и требует сравнения обоих дочерних элементов каждого узла. Между тем, дереву турниров нужны только сравнения log (k), потому что оно начинается в нижней части дерева и работает до корня, делая только одно сравнение на каждом уровне. Следовательно, турнирное дерево должно быть предпочтительной реализацией.

Куча

Идея состоит в том, чтобы поддерживать минимальную кучу из k списков, каждый из которых имеет свой наименьший текущий элемент. Простой алгоритм строит выходной буфер с узлами из кучи. Начните с создания минимальной кучи узлов, где каждый узел состоит из головного элемента списка и остальной части (или хвоста) списка. Поскольку списки изначально сортируются, заголовок является наименьшим элементом каждого списка; свойство heap гарантирует, что корень содержит минимальный элемент по всем спискам. Извлеките корневой узел из кучи, добавьте элемент head в выходной буфер, создайте новый узел из хвоста и вставьте его в кучу. Повторяйте до тех пор, пока в куче не останется только один узел, после чего просто добавьте этот оставшийся список (заголовок и конец) в выходной буфер.

Использование указателей, алгоритм кучи на месте ^[2]выделяет минимальную кучу указателей во входные массивы. Первоначально эти указатели указывают на самые маленькие элементы входного массива. Указатели сортируются по значению, на которое они указывают. На этапе предварительной обработки O (k) куча создается с использованием стандартная процедура heapify. После этого алгоритм итеративно передает элемент, на который указывает корневой указатель, увеличивает этот указатель и выполняет стандартную процедуру уменьшения ключа на корневом элементе. Время работы процедуры увеличения ключа ограничено O (log k Поскольку имеется n элементов, общее время работы составляет O (n log k).

Обратите внимание, что операция замены ключа и итеративного выполнения уменьшения или отсеивания не поддерживается многими библиотеками Priority Queue, такими как C ++ stl и Java. Выполнение функции extract-min и insert менее эффективно.

Дерево турниров

Дерево турниров

Дерево турниров ^[3] основан на отборочном турнире, как и в спорте. В каждой игре соревнуются два элемента ввода. Победитель переходит в следующий раунд. Таким образом, мы получаем двоичное дерево игр. Список отсортирован в порядке возрастания, поэтому победителем в игре считается меньший из обоих элементов.

Дерево неудачников

Для k-way слияния более эффективно хранить только проигравшего в каждой игре (см. Изображение). Поэтому структура данных называется деревом неудачников. При построении дерева или замене элемента на следующий из его списка мы по-прежнему продвигаем победителя игры на вершину. Дерево заполняется, как при спортивном матче, но в узлах сохраняется только проигравший. Обычно над корнем добавляется дополнительный узел, который представляет общего победителя. Каждый лист хранит указатель на один из входных массивов. Каждый внутренний узел хранит значение и индекс. Индекс внутреннего узла указывает, из какого входного массива берется значение. Значение содержит копию первого элемента соответствующего входного массива.

Алгоритм итеративно добавляет минимальный элемент к результату, а затем удаляет элемент из соответствующего входного списка. Он обновляет узлы на пути от обновленного листа до корня (выбор замены). Удаленный элемент является абсолютным победителем. Следовательно, он выигрывал каждую игру на пути от входного массива к корню. При выборе нового элемента из входного массива элемент должен конкурировать с предыдущими проигравшими на пути к корню. При использовании дерева проигравших партнер для воспроизведения игр уже сохраняется в узлах. Проигравший в каждой воспроизведенной игре записывается в узел, а победитель итеративно поднимается на вершину. Когда корень достигнут, новый общий победитель найден и может быть использован в следующем раунде слияния.

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

Алгоритм

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

Когда один из листьев обновляется, все игры от листа до корня воспроизводятся. В следующих псевдокод, объектно-ориентированное дерево используется вместо массива, потому что его легче понять. Кроме того, предполагается, что количество объединяемых списков является степенью двойки.

функция merge (L1,…, Ln) buildTree (главы L1,…, Ln) пока В дереве есть элементы победитель: = tree.winner вывод победитель.значение new: = победитель.index.next replayGames (победитель, новый) // Выбор замены

функция replayGames (узел, новый) проигравший, победитель: = playGame (узел, новый) node.value: = loser.value node.index: = loser.index если узел! = root replayGames (node.parent, победитель)

функция buildTree (элементы) nextLayer: = новый массив () пока элементы не пустые el1: = elements.take () el2: = elements.take () проигравший, победитель: = playGame (el1, el2) parent: = new Node (el1, el2, loser) nextLayer.add (parent) если nextLayer.size == 1 возвращаться nextLayer // только корень еще        возвращаться buildTree (следующий слой)

Продолжительность

Вначале дерево сначала создается за время Θ (k). На каждом этапе слияния нужно воспроизводить только игры на пути от нового элемента к корню. В каждом слое нужно только одно сравнение. Поскольку дерево сбалансировано, путь от одного из входных массивов до корня содержит только Θ (log k) элементов. Всего нужно передать n элементов. Таким образом, итоговое общее время работы составляет Θ (n log k). ^[3]

Пример

В следующем разделе содержится подробный пример шага выбора замены и один пример полного слияния, содержащего несколько вариантов выбора замены.

Выбор замены

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

Пример выбора замены

Объединить

Для выполнения самого слияния самый маленький элемент многократно заменяется следующим входным элементом. После этого переигрываются игры до топа.

В этом примере в качестве входных данных используются четыре отсортированных массива.

{2, 7, 16}{5, 10, 20}{3, 6, 21}{4, 8, 9}

Алгоритм запускается с заголовков каждого входного списка. Используя эти элементы, строится двоичное дерево проигравших. Для слияния нижний элемент списка 2 определяется путем просмотра общего минимального элемента в верхней части дерева. Затем это значение извлекается, а его лист заполняется цифрой 7, следующим значением в списке ввода. Игры на пути к вершине повторяются, как и в предыдущем разделе о выборе замены. Следующий удаляемый элемент - 3. Начиная со следующего значения в списке, 6, игры воспроизводятся до корня. Это повторяется до тех пор, пока минимум дерева не станет бесконечным.

Визуализация всего алгоритма

Более низкий предел времени работы

Можно показать, что никакие сравнительные kАлгоритм -way слияния существует со временем выполнения в O (nf (k)), где f растет асимптотически медленнее, чем логарифм. (Исключая данные с желаемыми распределениями, такими как непересекающиеся диапазоны.) Доказательство - это прямое сокращение от сортировки на основе сравнения. Предположим, что такой алгоритм существует, тогда мы могли бы построить алгоритм сортировки на основе сравнения со временем работы O (nf (n)) следующим образом: Разбить входной массив на n массивов размера 1. Объединить эти n массивов с kалгоритм слияния. Результирующий массив сортируется, и время выполнения алгоритма равно O (nf (n)). Это противоречит хорошо известному результату, что нет алгоритма сортировки на основе сравнения с временем выполнения наихудшего случая ниже O (n log n) существует.

Внешняя сортировка

k-ходовые слияния используются во внешних процедурах сортировки.^[4] Алгоритмы внешней сортировки представляют собой класс алгоритмов сортировки, которые могут обрабатывать большие объемы данных. Внешняя сортировка требуется, когда сортируемые данные не помещаются в основную память вычислительного устройства (обычно ОЗУ), а вместо этого они должны находиться в более медленной внешней памяти (обычно на жестком диске). kАлгоритмы последовательного слияния обычно выполняются на втором этапе алгоритмов внешней сортировки, как и при сортировке слиянием.

Многостороннее слияние позволяет объединять файлы вне памяти за меньшее количество проходов, чем при двоичном слиянии. Если есть 6 прогонов, которые необходимо объединить, то для двоичного слияния потребуется 3 прохода слияния, в отличие от одного прохода слияния при 6-стороннем слиянии. Это сокращение проходов слияния особенно важно, учитывая большой объем информации, которая обычно сортируется в первую очередь, что позволяет увеличить скорость, а также сократить количество обращений к более медленной памяти.

Рекомендации