Сортировка слиянием — различия между версиями
Строка 21: | Строка 21: | ||
<pre>// слияние двух массивов с помощью временного | <pre>// слияние двух массивов с помощью временного | ||
− | merge (array a, | + | merge(array a, int left, int middle, int right) // left - левая граница, right - правая, middle - середина |
− | i = | + | array b = a[middle + 1, right]; |
+ | i = left, j = middle + 1, k = 0; | ||
array temp; | array temp; | ||
− | while i <= | + | while i <= middle and j <= right |
temp[k++] = (a[j] < b[i]) ? a[j++] : b[i++]; | temp[k++] = (a[j] < b[i]) ? a[j++] : b[i++]; | ||
− | while i <= | + | while i <= middle |
temp[k++] = b[i++]; | temp[k++] = b[i++]; | ||
− | while j <= | + | while j <= right |
temp[k++] = a[j++]; | temp[k++] = a[j++]; | ||
for (int t = 0; t != k; t++) | for (int t = 0; t != k; t++) | ||
Строка 37: | Строка 38: | ||
==Рекурсивный алгоритм== | ==Рекурсивный алгоритм== | ||
[[Файл:Merge sort1.png|300px|right|thumb|Пример работы рекурсивного алгоритма сортировки слиянием]] | [[Файл:Merge sort1.png|300px|right|thumb|Пример работы рекурсивного алгоритма сортировки слиянием]] | ||
− | Проще всего формализовать этот алгоритм рекурсивным способом. Функция сортирует участок массива от элемента с номером | + | Проще всего формализовать этот алгоритм рекурсивным способом. Функция сортирует участок массива от элемента с номером left до элемента с номером right: |
− | <pre>// | + | <pre> |
− | + | sort(array a, int left, int right) // right и left — правая и левая граница массива, middle — середина | |
− | if | + | middle = right / 2 |
+ | if middle == right // условие выхода — если массив стал состоять из 1 элемента | ||
return | return | ||
− | sort | + | sort(a, left, middle) |
− | sort | + | sort (a, middle + 1, right) |
− | merge | + | merge(array a, left, middle, right) |
</pre> | </pre> | ||
Строка 51: | Строка 53: | ||
==Время работы== | ==Время работы== | ||
− | Чтобы оценить время работы этого алгоритма, составим рекуррентное соотношение. Пускай <tex>T(n)</tex> | + | Чтобы оценить время работы этого алгоритма, составим рекуррентное соотношение. Пускай <tex>T(n)</tex> — время сортировки массива длины n, тогда для сортировки слиянием справедливо <tex>T(n)=2T(n/2)+O(n)</tex> <br> |
− | (<tex>O(n)</tex> | + | (<tex>O(n)</tex> — это время, необходимое на то, чтобы слить два массива). Распишем это соотношение: |
<tex>T(n)</tex> <tex>=</tex> <tex>2T(n/2)</tex> <tex>+</tex> <tex>O(n)</tex> <tex>=</tex> <tex>4T(n/4)</tex> <tex>+</tex> <tex>2*O(n)</tex> <tex>=</tex> <tex>...</tex> <tex>=</tex> <tex>2^kT(1)</tex> <tex>+</tex> <tex>kO(n).</tex> | <tex>T(n)</tex> <tex>=</tex> <tex>2T(n/2)</tex> <tex>+</tex> <tex>O(n)</tex> <tex>=</tex> <tex>4T(n/4)</tex> <tex>+</tex> <tex>2*O(n)</tex> <tex>=</tex> <tex>...</tex> <tex>=</tex> <tex>2^kT(1)</tex> <tex>+</tex> <tex>kO(n).</tex> | ||
− | Осталось оценить <tex>k</tex>. Мы знаем, что <tex>2^k=n</tex>, а значит <tex>k=\log(n)</tex>. Уравнение примет вид <tex>T(n)=nT(1)+ \log(n)O(n)</tex>. Так как <tex>T(1)</tex> | + | Осталось оценить <tex>k</tex>. Мы знаем, что <tex>2^k=n</tex>, а значит <tex>k=\log(n)</tex>. Уравнение примет вид <tex>T(n)=nT(1)+ \log(n)O(n)</tex>. Так как <tex>T(1)</tex> — константа, то <tex>T(n)=O(n)+\log(n)O(n)=O(n\log(n))</tex>. |
==Ссылки== | ==Ссылки== | ||
− | *[http://ru.wikipedia.org/wiki/Mergesort Википедия | + | *[http://ru.wikipedia.org/wiki/Mergesort Википедия — сортировка слиянием] |
*[http://iproc.ru/parallel-programming/lection-6/ Сортировка слиянием] | *[http://iproc.ru/parallel-programming/lection-6/ Сортировка слиянием] | ||
− | *[http://www.sorting- | + | *[http://www.sorting-algorithms.com/merge-sort Сортировка слиянием, анимация и свойства (англ.)] |
*[http://ru.wikibooks.org/wiki/%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8_%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC Примеры реализации на различных языках (Википедия)] | *[http://ru.wikibooks.org/wiki/%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8_%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC Примеры реализации на различных языках (Википедия)] | ||
*[http://iproc.ru/parallel-programming/lection-6/ Сортировка слиянием в картинках (источник картинок в статье)] | *[http://iproc.ru/parallel-programming/lection-6/ Сортировка слиянием в картинках (источник картинок в статье)] |
Версия 13:10, 17 мая 2012
Содержание
Описание
Сортировка слиянием — алгоритм сортировки, хороший пример использования принципа «разделяй и властвуй». Он был предложен Джоном фон Нейманом в 1945 году.
Это стабильный алгоритм сортировки, использующий
дополнительной памяти и времени.Принцип работы
Принцип «разделяй и властвуй» — сначала задача разбивается на несколько подзадач меньшего размера. Затем эти задачи решаются с помощью рекурсивного вызова или непосредственно, если их размер достаточно мал. Наконец, их решения комбинируются, и получается решение исходной задачи.
Процедура слияния требует два отсортированных массива. Заметив, что массив из одного элемента по определению является отсортированным, мы можем осуществить сортировку следующим образом:
- Разбить имеющиеся элементы массива на пары и осуществить слияние элементов каждой пары, получив отсортированные цепочки длины 2 (кроме, быть может, одного элемента, для которого не нашлось пары).
- Разбить имеющиеся отсортированные цепочки на пары, и осуществить слияние цепочек каждой пары.
- Если число отсортированных цепочек больше единицы, перейти к шагу 2.
Слияние двух массивов
Допустим, у нас есть два отсортированных массива А и B размерами
и соответственно, и мы хотим объединить их элементы в один большой отсортированный массив C размером . Для этого можно применить процедуру слияния, суть которой заключается в повторяющемся «отделении» элемента, наименьшего из двух имеющихся в началах исходных массивов, и присоединении этого элемента к концу результирующего массива. Элементы мы переносим до тех пор, пока один из исходных массивов не закончится. После этого оставшийся «хвост» одного из входных массивов дописывается в конец результирующего массива. Пример работы процедуры показан на рисунке:
Алгоритм слияния формально можно записать следующим образом:
// слияние двух массивов с помощью временного merge(array a, int left, int middle, int right) // left - левая граница, right - правая, middle - середина array b = a[middle + 1, right]; i = left, j = middle + 1, k = 0; array temp; while i <= middle and j <= right temp[k++] = (a[j] < b[i]) ? a[j++] : b[i++]; while i <= middle temp[k++] = b[i++]; while j <= right temp[k++] = a[j++]; for (int t = 0; t != k; t++) a[t] = temp[t] // в конце a[1..k] это будет отсортированный массив
Рекурсивный алгоритм
Проще всего формализовать этот алгоритм рекурсивным способом. Функция сортирует участок массива от элемента с номером left до элемента с номером right:
sort(array a, int left, int right) // right и left — правая и левая граница массива, middle — середина middle = right / 2 if middle == right // условие выхода — если массив стал состоять из 1 элемента return sort(a, left, middle) sort (a, middle + 1, right) merge(array a, left, middle, right)
Пример работы алгоритма показан на рисунке:
Время работы
Чтобы оценить время работы этого алгоритма, составим рекуррентное соотношение. Пускай
( — это время, необходимое на то, чтобы слить два массива). Распишем это соотношение:
Осталось оценить
. Мы знаем, что , а значит . Уравнение примет вид . Так как — константа, то .