Сортировка слиянием (merge sort) считается весьма интересным алгоритмом. Она привлекательна своей простотой и наличием некоторых важных особенностей (например, она принадлежит к алгоритмам класса 0(п log(w)) и не имеет худших случаев), но если приступить к его реализации, можно натолкнуться на большую проблему. Тем не менее, сортировка слиянием очень широко используется при необходимости сортировки содержимого файлов, размер которых слишком велик, чтобы поместиться в памяти.

Мы будет рассматривать сортировку слиянием по шагам, начиная со слияния. Затем мы опишем, как использовать алгоритм для выполнения сортировки. В качестве примера мы не будем пользоваться картами - алгоритм легко понять и без карт.

Представьте себе, что имеется два уже отсортированных списка и необходимо сформировать один список, объединяющий все элементы исходных списков. План А состоит в том, чтобы скопировать оба списка в результирующий и выполнить его сортировку. Но в этом случае, к сожалению, мы не пользуемся тем, что исходные списки уже отсортированы. План Б предусматривает слияние. Смотрим на первые элементы в обоих списках. Элемент с меньшим значением переносим в результирующий список. Снова смотрим на первые элементы в обоих списках и снова переносим в результирующий список элемент с меньшим значением, удаляя его из исходного списка. Описанный процесс продолжается до тех пор, пока не исчерпаются элементы одного из списков. После этого в результирующий список можно перенести все оставшиеся в исходном списке элементы. Такой алгоритм формально известен под названием алгоритма двухпутевого слияния (two-way merge algorithm ).

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

Листинг 5.11. Слияние двух отсортированных массивов TList

procedure TDListMerge( aList 1, aList2, aTarget Li st : TList;
aCompare : TtdCompareFunc);
var
Inxl, Inx2, Inx3 : integers-begin
{подготовить результирующий список} aTargetList.Clear;
aTargetList .Capacity := aListl.Count + aList2 .Count;
{инициализировать счетчики) Inxl : = 0 ; 1пх2 := 0; 1пхЗ := 0;
{выполнять цикл до исчерпания элементов одного из списка...} while (Inxl <
aListl .Count) and (Inx2 <
aList2 .Count) do begin
{определить наименьшее значение из двух списков и скопировать его в результирующий список; увеличить значения индексов на единицу} if aCompare (aListl. ListА [ Inxl ], aList2. ListA [ Inx2 ]) <«= 0 then begin aTargetList.ListA[Inx3] : = aListl.ListA[Inxl]; inc(Inxl);
end
else begin
aTargetList.ListA[Inx3] : = aList2.ListA[Inx2]; inc(Inx2);
end;
inc(Inx3);
end;
{выполнение цикла прекращается при исчерпании элементов одного из списков; если в первом списке еще остались элементы, скопировать их в результирующий список}
if (Inxl <
aListl.Count) then Move(aListl.ListA[Inxl], aTargetList.ListA[Inx3], (aListl.Count - Inxl) * sizeof(pointer)) {в противном случае скопировать все элементы, оставшиеся во втором списке, в результирующий список} else
Move(aList2.ListA[Inx2], aTargetList.ListA[Inx3], (aList2.Count - Inx2) * sizeof(pointer));
end;

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

Время выполнения алгоритма двухпутевого слияния зависит от количества элементов в обоих исходных списках. Если в первом из них находится п элементов, а во втором - т, нетрудно прийти к выводу, что в худшем случае будет произведено (п + т) сравнений. Следовательно, алгоритм двухпутевого слияния принадлежит к классу 0(п).

Каким же образом алгоритм двухпутевого слияния помогает выполнить сортировку? Для его работы необходимо иметь два отсортированных списка меньшей длины, из которых создается один больший список. На основе такого описания можно прийти к рекурсивному определению сортировки слиянием: разделите исходный список на две половины, примените к каждой половине алгоритм сортировки слиянием, а затем с помощью алгоритма слияния объедините подсписки в один отсортированный список. Рекурсия заканчивается, когда под-под-подсписок, переданный алгоритму сортировки, содержит всего один элемент, поскольку он, очевидно, является отсортированным.

Сортировка слиянием обладает только одним недостатком - алгоритм слияния требует наличия третьего списка, в котором будут храниться результаты слияния.

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

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

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

Листинг 5.12. Стандартная сортировка слиянием

procedure MSS(aList : TList;
aFirst : integer;
aLast : integer;
aCoropare : TtdCompareFunc;
aTempList : PPointerList);
var
Mid : integer;
i, j : integer;
Tolnx : integer;
FirstCount : integer;
begin
{вычислить среднюю точку} Mid := (aFirst + aLast) div 2;
{выполнить рекурсивную сортировку слиянием первой и второй половин списка} if (aFirst <
Mid) then
MSS(aList, aFirst, Mid, aCompare, aTempList);
if (suce(Mid) <
aLast) then
MSS(aList, succ(Mid), aLast, aCompare, aTempList); {скопировать первую половину списка во вспомогательный список} FirstCount := suce(Mid - aFirst);
Move(aList.ListA[aFirst], aTempListA[0], FirstCount * sizeof(pointer));
{установить значения индексов: i - индекс для вспомогательного списка (т.е. первой половины списка), j - индекс для второй половины списка, Tolnx - индекс в результирующем списке, куда будут копироваться отсортированные элементы}
i := 0;
j := suce (Mid) ; Tolnx := aFirst;
{выполнить слияние двух списков}
{повторять до тех пор, пока один из списков не опустеет} while (i <
FirstCount) and (j <= aLast) do begin
{определить элемент с наименьшим значением из следующих элементов в обоих списках и скопировать его; увеличить значение соответствующего индекса} if (aCompare(aTempListА[i], aList.ListA[j]) <= 0) then begin aList.ListA[Tolnx] := aTempListA[i]; inc( i ) ; end
else begin
aList.ListA[Tolnx] := aList.ListA[j]; inc(j) ;
end;
{в объединенном списке есть еще один элемент} inc(Tolnx);
end;
{если в первом списке остались элементы, скопировать их} if (i <
FirstCount) then Move(aTempListA[i], aList.ListA[Tolnx], (FirstCount - i) * sizeof(pointer)); {если во втором списке остались элементы, то они уже находятся в нужных позициях, значит, сортировка завершено; если второй список пуст, сортировка также завершена} end;
procedure TDMergeSortStd(aList : TList;
aFirst : integer;
aLast : integer;
aCompare : TtdCompareFunc);
var
TempList : PPointerList;
ItemCount: integers-begin
TDValidateListRange(aList, aFirst, aLast, 'TDMergeSortStd'); {если есть хотя бы два элемента для сортировки} if (aFirst <
aLast) then begin
{создать временный список указателей}
ItemCount := suce(aLast - aFirst);
GetMem(TempList, (suce(ItemCount) div2) * sizeof(pointer)); try
MSS(aList, aFirst, aLast, aCompare, TempList);
finally
FreeMem(TempList, (suce(ItemCount) div2) * sizeof(pointer));
end;
endsend;

Если вы внимательно изучите код, приведенный в листинге 5.12, то обнаружите, что он содержит процедуру-драйвер, TDMergeSortStd, которая вызывается для выполнения сортировки списка, и отдельную вспомогательную процедуру, MSS, выполняющую рекурсивную сортировку. Прежде всего, процедура TDMergeSortStd проверяет попадание индекса в допустимые пределы и сам список, а затем - присутствуют ли в списке хотя бы два элемента, которые можно сортировать. После этого создается вспомогательный список указателей с размером, достаточным для хранения половины количества элементов исходного массива. Далее вызывается рекурсивная процедура MSS.

Процедура MSS рекурсивно вызывает сама себя для сортировки первой и второй половин переданной ей части массива. Затем она копирует первую половину во вспомогательный массив. Начиная с этого момента, код представляет собой стандартную реализацию сортировки слиянием, копируя две половины списка в исходный список. Если после выполнения цикла сравнения и копирования во вспомогательном массиве остались элементы, процедура MSS их просто копирует. Если же элементы остались во второй половине списка, их можно не копировать, как и в стандартной реализации метода слияния: они уже находятся на своих местах.

Вывод функции быстродействия сортировки слиянием достаточно сложен. Для простоты ее определения лучше принять, что в исходном списке находится 2х элементов. Предположим, что элементов 32. На первом уровне рекурсии процедура MSS будет вызываться один раз и на этапе слияния будет не более 32 сравнений. На втором уровне рекурсии процедура MSS будет вызываться два раза, причем количество сравнений при каждом вызове не будет превышать 16. Далее рассматриваем третий, четвертый и, наконец, пятый уровень рекурсии (когда будет выполняться сортировка всего двух элементов), на котором будет иметь место 16 вызовов процедуры по два сравнения в каждом. Таким образом, общее количество сравнений будет равно 5 * 32. Но причиной, по которой было получено пять уровней рекурсии, является то, что мы постоянно на каждом уровне постепенно делили список на две равные половины, а 25 = 32, что, естественно означает, что log232 = 5. Следовательно, не утруждая себя переходом от рассмотренного нами частного случая к общему, можно сказать, что сортировка слиянием принадлежит к классу 0(п log(fj)) алгоритмов.

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

Если отслеживать вызовы процедуры MSS в отладчике, то можно обратить внимание, что для небольших интервалов она вызывается очень часто. Например, если в списке содержится 32 элемента, то для списка из 32 элементов процедура MSS будет вызвана один раз, для списка из 16 элементов - дважды, четыре раза для 8 элементов, восемь раз для 4 элементов и шестнадцать раз для 2 элементов (список минимальной длины), т.е. всего 31 раз. Это очень много, особенно если учитывать, что большая часть вызовов (29) приходится для списков длиной восемь и менее элементов. Если бы исходный список содержал 1024 элемента, процедура MSS была бы вызвана 1023 раза, из которых 896 вызовов приходилось бы на долю списков длиной восемь и менее элементов. Просто ужасно! Фактически, для сортировки коротких списков было бы эффективнее использовать нерекурсивный алгоритм. Это позволило бы повысить скорость всей сортировки. Кроме того, применение более простой процедуры дало бы возможность для коротких диапазонов исключить копирование элементов между основным и вспомогательным списком. И одним из лучших методов для ускорения сортировки слиянием является сортировка методом вставок.

Листинг 5.13. Оптимизированная сортировка слиянием

const
MSCutOff = 16; procedure MSInsertionSort (aList : TList;
aFirst : integer;
aLast : integer;
aCompare : TtdCompareFunc);
var
i, j : integer;
IndexOfMin : integer;
Temp : pointers-begin
{найти наименьший элемент в списке}
IndexOfMin := aFirst;
for i := succ(aFirst) to aLast do
if (aCompare(aList.ListA[i], aList.ListA[IndexOfMin]) < 0) then IndexOfMin := i;
if (aFirstoindexOfMin) then begin
Temp := aList.ListA[aFirst];
aList.ListA[aFirst] := aList.ListA[IndexOfMin]; aList.ListA[IndexOfMin] : = Temp;
end;
{выполнить сортировку методом вставок) for i : = aFirst+2 to aLast do begin Temp := aList.ListA[i];
 
з •= i;
while (aCompare(Temp, aList.ListA[j-1]) < 0) do begin
aList.ListA[j] : = aList.ListA[j-1];
dec(j);
end;
aList.ListA[j] := Temp;
end;
end;
procedure MS (aList : TList;
aFirst : integer;
aLast : integer;
aCompare : TtdCompareFunc;
aTempList : PPointerList);
var
Mid : integers-is j : integer;
Tolnx : integer;
FirstCount : integer;
begin
{вычислить среднюю точку) Mid := (aFirst + aLast) div 2;
{выполнить сортировку первой половины списка с помощью сортировки слиянием илиг если количество элементов достаточно мало, при помощи сортировки методом вставок) if (aFirst <
Mid) then
if (Mid-aFirst) <= MSCutOff then
MSInsertionSort(aList, aFirst, Mid, aCompare) else
MS (aList, aFirst, Mid, aCompare, aTempList);
{аналогично выполнить сортировку второй половины) if (suce(Mid) <
aLast) then
if (aLast-succ(Mid) ) <= MSCutOf f then MSInsertionSort(aList, succ(Mid), aLast, aCompare)
else
MS (aList, suce(Mid), aLast, aCompare, aTempList); {скопировать первую половину списка во вспомогательный список) FirstCount := suce (Mid - aFirst) ;
Move(aList.ListA[aFirst], aTempListA[0], FirstCount*sizeof(pointer));
{установить значения индексов: i - индекс для вспомогательного списка (т.е. первой половины списка), j - индекс для второй половины списка, Tolnx -индекс в результирующем списке, куда будут копироваться отсортированные элементы)
i := 0;
j := suce (Mid) ; Tolnx := aFirst;
{выполнить слияние двух списков)
{повторять до тех пор, пока один из списков не опустеет) while (i <
FirstCount) and (j <= aLast) do begin
{определить элемент с наименьшим значением из следующих элементов в обоих списках и скопировать его; увеличить значение соответствующего индекса) if ( aCompare ( aTempListА [ i ], aList. ListA [ j ] ) <= 0 ) then begin aList.ListA[Tolnx] := aTempListA[i]; inc(i);
end
else begin
aList.ListA[Tolnx] := aList.ListA[ j ] ; inc(j);
end;
{в объединенном списке есть еще один элемент) inc(Tolnx);
end;
{если в первом списке остались элементы, скопировать их) if (i <
FirstCount) then Move(aTempListA[i], aList.ListA[Tolnx], (FirstCount - i) * sizeof(pointer)); {если во втором списке остались элементы, то они уже находятся в нужных позициях, значит, сортировка завершена; если второй список пуст, сортировка также завершена) end;
procedure TDMergeSort(aList : TList;
aFirst : integer;
aLast : integer;
aCompare : TtdCompareFunc);
var
TempList : PPointerList;
ItemCount: integer;
begin
TDValidateListRange(aList, aFirst, aLast, 'TDMergeSort'); {если есть хотя бы два элемента для сортировки} if (aFirst <
aLast) then begin
{создать временный список указателей}
ItemCount := suce (aLast - aFirst) ;
GetMem(TempList, (succ(ItemCount) div2) * sizeof(pointer)); try
MS(aList, aFirst, aLast, aCompare, TempList);
finally
FreeMem(TempList, (succ(ItemCount) div2) * sizeof(pointer));
end;
end;
end;

Несмотря на то что объем кода достаточно велик, в нем находятся всего три процедуры. Прежде всего, драйвер - TDMergeSort - процедура, которую мы вызываем. Как и в предыдущем случае, она используется для выделения из кучи памяти под вспомогательный список указателей и вызывает рекурсивную процедуру, названную в приведенном коде MS. В общих чертах процедура MS работает примерно так, как и ее предшественница - MSS (рекурсивная процедура для стандартной сортировки слиянием). Разница возникает только тогда, когда дело касается сортировки подсписков. Для небольших диапазонов элементов, длина которых меньше, чем значение MSCutOff, процедура MS вызывает третью процедуру, MSInsertionSort, которая сортирует элементы без рекурсивного вызова. Для длинных диапазонов элементов, естественно, происходит рекурсивный вызов процедуры MS. MSInsertionSort ничем не отличается от рассмотренной нами ранее процедуры TDInsertionSort, за исключением одного - она не проверяет корректность входных параметров (в проверке нет необходимости, поскольку все параметры были проверены в TDMergeSort).

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

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

В конце этой главы мы рассмотрим случай, в котором сортировка слиянием просто необходима, - сортировка связного списка.

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

Самые быстрые алгоритмы сортировки || Оглавление || Быстрая сортировка


Фундаментальные алгоритмы и структуры данных в Delphi



Новости за месяц

  • Сентябрь
    2019
  • Пн
  • Вт
  • Ср
  • Чт
  • Пт
  • Сб
  • Вс