Слияние
На сегодняшнем занятии мы начнем рассмотрении
темы внешняя сортировка.
Внешняя сортировка сортирует файлы, которые не
помещаются целиком в оперативную память.
Внешняя сортировка сильно отличается от
внутренней. Дело в том, что доступ к файлу
является последовательным, а не параллельным как
это было в массиве. И поэтому считывать файл
можно только блоками и этот блок отсортировать в
памяти и снова записать в файл.
Принципиальную возможность эффективно
отсортировать файл, работая с его частями и не
выходя за пределы части обеспечивает алгоритм
слияния.
Под слиянием понимается объединение двух (или
более) упорядоченных последовательностей в одну
упорядоченную последовательность при помощи
циклического выбора элементов, доступных в
данный момент.
Слияние - намного более простая операция, чем
сортировка.
Мы рассмотрим 2 алгоритма слияния:
- Прямое слияние. Алгоритм Боуза - Нельсона
- Естественное (Неймановское) слияние.
Прямое слияние. Алгоритм Боуза -
Нельсона
- Последовательность а разбивается на две
половины b и с.
- Последовательности b и с сливаются при помощи
объединения отдельных элементов в упорядоченные
пары.
- Полученной последовательности присваивается
имя а, после чего повторяются шаги 1 и 2; при этом
упорядоченные пары сливаются в упорядоченные
четверки.
- Предыдущие шаги повторяются, при этом четверки
сливаются в восьмерки и т.д., пока не будет
упорядочена вся последовательность, т.к. длины
последовательностей каждый раз удваиваются.
Пример
Исходная последовательность
А = 44 55 12 42 94 18 06 67
1 b = 44 55 12 42
с = 94 18 06 67
а = 44 94' 18 55' 06 12' 42 67
2 b = 44 94' 18 55'
с =06 12' 42 67
а = 06 12 44 94' 18 42 55 67'
3 b = 06 12 44 94'
с = 18 42 55 67'
а = 06 12 18 42 44 55 67 94
Операция, которая однократно обрабатывает всё
множество данных, называется фазой.
Наименьший подпроцесс, который, повторяясь,
образует процесс сортировки, называется
проходом или этапом.
В нашем примере сортировка производится за три
прохода. Каждый проход состоит из фазы разбиения
и фазы слияния.
Главным минусом сортировки слиянием является
удвоение размера памяти, первоначально занятой
сортируемыми данными. Рассмотрим алгоритм с
рекурсивным актом слияния, предложенный Боузом и
Нельсоном и не требующий резерва памяти.
Он основан на очевидной идее: слить две равные
упорядоченные части можно слиянием их начальных
половин, слиянием конечных и слиянием 2-й
половины 1-го результата с 1-й половиной 2-го
результата, например:
Если части не равны или не делятся
точно пополам, процедуру уточняют надлежащим
образом. Аналогично слияние "половинок"
можно свести к слиянию "четвертушек",
"восьмушек" и т. д.; имеет место рекурсия.
Const n=200;
Type
tipkl=word;
tip = Record
kl: tipkl;
z:Array[1..50] of real
End;
Var
A: Array[1..n] of tip;
j:word;
Procedure Bose (Var AA; voz:Boolean);
Var
m,j:word; x:tip; {tip - тип сортируемых записей}
A: Array [1..65520 div Sizeof(tip)] of tip Absolute AA;
Procedure Sli(j,r,m: word); { r - расстояние между началами
сливаемых частей, а m - их размер, j - наименьший
номер записи}
Begin
if j+r<=n Then
If m=1 Then
Begin
If voz Xor (A[j].kl < A[j+r].kl) Then
Begin
x:=A[j];
A[j]:= A[j+r];
A[j+r]:=x
End
End
Else
Begin
m:=m div 2;
Sli(j,r,m); {Слияние "начал"}
If j+r+m<=n Then
Sli(j+m,r,m); {Слияние "концов"}
Sli(j+m,r-m,m) End {Слияние в центральной части}
End{блока Sli};
Begin
m:=1;
Repeat
j:=1; {Цикл слияния списков равного размера: }
While j+m<=n do
Begin
Sli(j,m,m);
j:=j+m+m
End;
m:=m+m {Удвоение размера списка перед началом
нового прохода}
Until m >= n {Конец цикла, реализующего все дерево
слияний}
End{блока Bose};
BEGIN
Randomize;
For j:=1 to n do
begin
A[j].kl:= Random(65535);
Write(A[j].kl:8);
end;
Readln;
Bose(A,true);
For j:=1 to n do
Write(A[j].kl:8);
Readln
END.
Естественное (Неймановское) слияние.
Она объединяются упорядоченные части,
спонтанно возникшие в исходном массиве; они
могут быть также следствием предыдущей
обработки данных. Рассчитывать на одинаковый
размер сливаемых частей не приходится.
Записи, идущие в порядке неубывания ключей,
сцепляются, образуя подсписок. Минимальный
подсписок одна запись.
Пример:
Пусть даны ключи записей
5 7 8 3 9
4 1 7 6
Ищем подсписки
В один общий список соединяются 1-й, 3-й,
5-й и т. д. подсписки, в другой - 2-й, 4-й и т. д.
подсписки.
Произведем слияние 1 подсписка 1 списка и 1
подсписка 2 списка, 2 подсписка 1 списка и 2
подсписка 2 списка и т.д.
Будут получены следующие цепи
3 --> 5 --> 7 --> 8 --> 9 и 1 --> 4 --> 7
Подсписок, состоящий из записи "6", пары не
имеет и "принудительно" объединяется с
последней цепью, принимающей вид 1 --> 4--> 6 --> 7.
При нашем небольшом числе записей 2-й этап, на
котором сливаются две цепи, окажется последним.
В общем случае на каждом этапе подсписок -
результат слияния начальных подсписков 1 и 2
списка становится началом нового 1-го списка, а
результат слияния следующих двух подсписков -
началом 2-го списка. Следующие образуемые
подсписки поочередно включаются в 1-й и во 2-й
список.
Для программной реализации заводят массив sp:
элемент sp[i] - это номер записи, которая следует за
i-й.
Последняя запись одного подсписка ссылается на
первую запись другого, а для различения концов
подсписков эта ссылка снабжается знаком минус.
Repeat {Повторение актов
слияний подсписков}
If A[j].kl < A[i].kl Then {Выбирается меньшая запись}
Begin sp[k]:=j; k:=j; j:=sp[j];
If j<=0 Then {Сцепление с остатком "i"-подсписка}
Begin sp[k]:=i; Repeat m:=i; i:=sp[i] Until i<=0 End
End
Else
Begin sp[k]:=i; k:=i; i:=sp[i];
If i<=0 Then {Сцепление с остатком "j"-подсписка}
Begin sp[k]:=j; Repeat m:=j; j:=sp[j] Until j<=0 End
End;
If j<=0 Then Begin sp[m]:= 0; sp[p]:=-sp[p]; i:=-i;
j:=-j; If j<>0 Then p:=r; k:=r; r:=m End
Until j=0;
{В конец сформированного подсписка всегда
заносится нулевая ссылка (sp[m]:= 0), ибо он может
оказаться последним.
Действие sp[p]:= -sp[p] обозначает минусом конец
ранее построенного подсписка.
В переменных i,j ссылки на начала новых
сливаемых подсписков - со знаком минус; его
снимаем. Переход к новым подспискам требует
обновления переменных p, k, r}
Итак, на сегодняшнем занятии мы рассмотрели
алгоритмы слияния. |
