Время работы алгоритма сортировки слиянием составляет

Сортировка слиянием (англ. Merge sort) — алгоритм сортировки, использующий дополнительной памяти и работающий за времени.

Принцип работы

Алгоритм использует принцип «разделяй и властвуй»: задача разбивается на подзадачи меньшего размера, которые решаются по отдельности, после чего их решения комбинируются для получения решения исходной задачи. Конкретно процедуру сортировки слиянием можно описать следующим образом:

1. Если в рассматриваемом массиве один элемент, то он уже отсортирован — алгоритм завершает работу.
2. Иначе массив разбивается на две части, которые сортируются рекурсивно.
3. После сортировки двух частей массива к ним применяется процедура слияния, которая по двум отсортированным частям получает исходный отсортированный массив.

Слияние двух массивов

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

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

Ниже приведён псевдокод процедуры слияния, который сливает две части массива — и



function merge(a : int[n]; left, mid, right : int):
    it1 = 0
    it2 = 0
    result : int[right - left]
  
    while left + it1 < mid and mid + it2 < right
        if a[left + it1] < a[mid + it2]
            result[it1 + it2] = a[left + it1]
            it1 += 1
        else
            result[it1 + it2] = a[mid + it2]
            it2 += 1
  
    while left + it1 < mid
        result[it1 + it2] = a[left + it1]
        it1 += 1
  
    while mid + it2 < right
        result[it1 + it2] = a[mid + it2]
        it2 += 1
  
    for i = 0 to it1 + it2
        a[left + i] = result[i]

Рекурсивный алгоритм

Функция сортирует подотрезок массива с индексами в полуинтервале .



function mergeSortRecursive(a : int[n]; left, right : int):
    if left + 1 >= right
        return
    mid = (left + right) / 2
    mergeSortRecursive(a, left, mid)
    mergeSortRecursive(a, mid, right)
    merge(a, left, mid, right)

Итеративный алгоритм

При итеративном алгоритме используется на меньше памяти, которая раньше тратилась на рекурсивные вызовы.



function mergeSortIterative(a : int[n]):
    for i = 1 to n, i *= 2
        for j = 0 to n - i, j += 2 * i
            merge(a, j, j + i, min(j + 2 * i, n))

Время работы

Чтобы оценить время работы этого алгоритма, составим рекуррентное соотношение. Пускай — время сортировки массива длины , тогда для сортировки слиянием справедливо
— время, необходимое на то, чтобы слить два массива длины . Распишем это соотношение:

.

Сравнение с другими алгоритмами

Достоинства:

• устойчивая,
• можно написать эффективную многопоточную сортировку слиянием,
• сортировка данных, расположенных на периферийных устройствах и не вмещающихся в оперативную память^[1].

Недостатки:

• требуется дополнительно памяти, но можно модифицировать до .

См. также

• Сортировка кучей
• Быстрая сортировка
• Timsort
• Cортировка слиянием с использованием O(1) дополнительной памяти

Примечания

Источники информации

• Википедия — сортировка слиянием
• Визуализатор
• Викиучебник — Примеры реализации на различных языках программирования

Merge sort is a sorting algorithm that works by dividing an array into smaller subarrays, sorting each subarray, and then merging the sorted subarrays back together to form the final sorted array.

In simple terms, we can say that the process of merge sort is to divide the array into two halves, sort each half, and then merge the sorted halves back together. This process is repeated until the entire array is sorted.

One thing that you might wonder is what is the specialty of this algorithm. We already have a number of sorting algorithms then why do we need this algorithm? One of the main advantages of merge sort is that it has a time complexity of O(n log n), which means it can sort large arrays relatively quickly. It is also a stable sort, which means that the order of elements with equal values is preserved during the sort.

Merge sort is a popular choice for sorting large datasets because it is relatively efficient and easy to implement. It is often used in conjunction with other algorithms, such as quicksort, to improve the overall performance of a sorting routine.

Merge Sort Working Process:

Think of it as a recursive algorithm continuously splits the array in half until it cannot be further divided. This means that if the array becomes empty or has only one element left, the dividing will stop, i.e. it is the base case to stop the recursion. If the array has multiple elements, split the array into halves and recursively invoke the merge sort on each of the halves. Finally, when both halves are sorted, the merge operation is applied. Merge operation is the process of taking two smaller sorted arrays and combining them to eventually make a larger one.

Illustration:

To know the functioning of merge sort, lets consider an array arr[] = {38, 27, 43, 3, 9, 82, 10}

• At first, check if the left index of array is less than the right index, if yes then calculate its mid point

• Now, as we already know that merge sort first divides the whole array iteratively into equal halves, unless the atomic values are achieved. 
• Here, we see that an array of 7 items is divided into two arrays of size 4 and 3 respectively.

• Now, again find that is left index is less than the right index for both arrays, if found yes, then again calculate mid points for both the arrays.

• Now, further divide these two arrays into further halves, until the atomic units of the array is reached and further division is not possible.

• After dividing the array into smallest units, start merging the elements again based on comparison of size of elements
• Firstly, compare the element for each list and then combine them into another list in a sorted manner.

• After the final merging, the list looks like this:

The following diagram shows the complete merge sort process for an example array {38, 27, 43, 3, 9, 82, 10}. 

If we take a closer look at the diagram, we can see that the array is recursively divided into two halves till the size becomes 1. Once the size becomes 1, the merge processes come into action and start merging arrays back till the complete array is merged.
 

Algorithm:

step 1: start

step 2: declare array and left, right, mid variable

step 3: perform merge function.
    if left > right
        return
    mid= (left+right)/2
    mergesort(array, left, mid)
    mergesort(array, mid+1, right)
    merge(array, left, mid, right)

step 4: Stop

Follow the steps below to solve the problem:

MergeSort(arr[], l,  r)
If r > l

• Find the middle point to divide the array into two halves: 
  • middle m = l + (r – l)/2
• Call mergeSort for first half:   
  • Call mergeSort(arr, l, m)
• Call mergeSort for second half:
  • Call mergeSort(arr, m + 1, r)
• Merge the two halves sorted in steps 2 and 3:
  • Call merge(arr, l, m, r)

Below is the implementation of the above approach:

Given array is 
12 11 13 5 6 7 
Sorted array is 
5 6 7 11 12 13 

Time Complexity: O(N log(N)),  Sorting arrays on different machines. Merge Sort is a recursive algorithm and time complexity can be expressed as following recurrence relation. 

T(n) = 2T(n/2) + θ(n)

The above recurrence can be solved either using the Recurrence Tree method or the Master method. It falls in case II of the Master Method and the solution of the recurrence is θ(Nlog(N)). The time complexity of Merge Sort isθ(Nlog(N)) in all 3 cases (worst, average, and best) as merge sort always divides the array into two halves and takes linear time to merge two halves.

Auxiliary Space: O(n), In merge sort all elements are copied into an auxiliary array. So N auxiliary space is required for merge sort.

Is Merge sort In Place?

No, In merge sort the merging step requires extra space to store the elements.

Is Merge sort Stable?

Yes, merge sort is stable. 

How can we make Merge sort more efficient?

Merge sort can be made more efficient by replacing recursive calls with Insertion sort for smaller array sizes, where the size of the remaining array is less or equal to 43 as the number of operations required to sort an array of max size 43 will be less in Insertion sort as compared to the number of operations required in Merge sort.

Analysis of Merge Sort:

A merge sort consists of several passes over the input. The first pass merges segments of size 1, the second merges segments of size 2, and the  pass merges segments of size 2^i-1. Thus, the total number of passes is [log₂n]. As merge showed, we can merge two sorted segments in linear time, which means that each pass takes O(n) time. Since there are [log₂n] passes, the total computing time is O(nlogn).

Applications of Merge Sort: 

• Merge Sort is useful for sorting linked lists in O(N log N) time. In the case of linked lists, the case is different mainly due to the difference in memory allocation of arrays and linked lists. Unlike arrays, linked list nodes may not be adjacent in memory. Unlike an array, in the linked list, we can insert items in the middle in O(1) extra space and O(1) time. Therefore, the merge operation of merge sort can be implemented without extra space for linked lists.
  In arrays, we can do random access as elements are contiguous in memory. Let us say we have an integer (4-byte) array A and let the address of A[0] be x then to access A[i], we can directly access the memory at (x + i*4). Unlike arrays, we can not do random access in the linked list. Quick Sort requires a lot of this kind of access. In a linked list to access i’th index, we have to travel each and every node from the head to i’th node as we don’t have a contiguous block of memory. Therefore, the overhead increases for quicksort. Merge sort accesses data sequentially and the need of random access is low.
• Inversion Count Problem
• Used in External Sorting

Advantages of Merge Sort:

• Merge sort has a time complexity of O(n log n), which means it is relatively efficient for sorting large datasets.
• Merge sort is a stable sort, which means that the order of elements with equal values is preserved during the sort.
• It is easy to implement thus making it a good choice for many applications.
• It is useful for external sorting. This is because merge sort can handle large datasets, it is often used for external sorting, where the data being sorted does not fit in memory.
• The merge sort algorithm can be easily parallelized, which means it can take advantage of multiple processors or cores to sort the data more quickly.
• Merge sort requires relatively few additional resources (such as memory) to perform the sort. This makes it a good choice for systems with limited resources.

Drawbacks of Merge Sort:

• Slower compared to the other sort algorithms for smaller tasks. Although effecient for large datasets its not the best choice for small datasets.
• The merge sort algorithm requires an additional memory space of 0(n) for the temporary array. This is to store the subarrays that are used during the sorting process.
• It goes through the whole process even if the array is sorted.
• It requires more code to implement since we are dividing the array into smaller subarrays and then merging the sorted subarrays back together.
• Recent Articles on Merge Sort
• Coding practice for sorting.
• Quiz on Merge Sort

Solution of the drawback for additional storage:

Use linked list. 

Other Sorting Algorithms on GeeksforGeeks: 
3-way Merge Sort, Selection Sort, Bubble Sort, Insertion Sort, Merge Sort, Heap Sort, QuickSort, Radix Sort, Counting Sort, Bucket Sort, ShellSort, Comb Sort
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.

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

• Сортировка выбором.

• Сортировка вставками.

• Поразрядная сортировка.

• Сортировка пузырьком.

• Сортировка слиянием.

• Пирамидальная сортировка.

• Быстрая сортировка.

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

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

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

Наибольшая временная сложность алгоритма равна  O( nlog n ).

Принцип работы

Сортировка слиянием — это эффективный алгоритм сортировки. Он работает по технике «Разделяй и властвуй».

• Разделяй: Это включает в себя разделение списка входных массивов на два списка одинакового размера.

• Властвуй: То есть рекурсивная сортировка подсписоков.

• Соединяй: Слияние обоих отсортированных подсписоков в один.

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

Принцип работы включает следующие шаги:

• Разделить заданный массив на подсписок;

• Объединить подсписки для получения одного полного отсортированного списка.

Возьмем к примеру массив из пяти элементов от 0 до 4. Этот массив будет разделен на две (левую и правую) части. Левая часть массива содержит 2 элемента, а правая часть — 3 элемента. Левая часть также будет разделена на две части, и тогда мы получим два отдельных подсписка. Как только мы получим отсортированные подсписки для левой части, они будут объединены в один отсортированный левый массив.

Теперь отсортируем правую часть массива, сначала разделив его на две части. Правая часть теперь будет содержать еще две части, то есть левую и правую части. Левая часть содержит только один элемент, а правая часть содержит два элемента. Левая часть уже отсортирована. Итак, теперь мы отсортируем правую часть, разделив ее на две части. Теперь эти две отсортированные части правой части будут объединены. Затем отсортированные слева и справа части правой стороны будут объединены в один отсортированный правый массив. Наконец, мы получим единый отсортированный массив / список, объединив отсортированный слева и справа массив.

Пример

Чтобы понять эту концепцию, давайте рассмотрим массив «B», который приведен ниже. В этом массиве всего девять элементов.

Мы разделим этот массив на два подмассива. Для этого мы найдем его среднюю точку, а затем разделим этот массив от этой средней точки. Итак, находим средину:

Итак, этот массив разделен по индексу 4, подмассивы будут:

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

Средняя точка первого подсписка:

Средняя точка второго подсписка:

Теперь у нас есть 4 подсписка. Они будут дальше отделены от своих средних точек.

Средняя точка третьего подсписка :

Средние точки четвертого, пятого и шестого подсписка :

Есть только один подсписок, состоящий из 2 элементов. Итак, мы разделим этот подсписок на следующие подсписки. Остальные подсписки останутся такими же, потому что они содержат по одному элементу.

Средняя точка седьмого подсписка:

 Далее мы объединим эти подсписки. Этот процесс будет выполняться путем объединения первых двух элементов и их сравнения. Видно, что 5 меньше 15, поэтому мы сначала поместим 5, а затем 15 в новый отсортированный подсписок.

И этот первый новый отсортированный подсписок будет сравниваться с третьим элементом, который равен 24. И, во-вторых, отсортированный подсписок будет:

Затем мы сравним 4-й и 5-й элементы подсписка, и можно увидеть, что 1 меньше 8. Итак, теперь сначала будет помещен 1, а затем 8. После этого мы получим 3-й отсортированный подсписок.:

Теперь этот третий отсортированный подсписок будет сравниваться со вторым отсортированным подсписком, и мы получим 4-й отсортированный подсписок:

Точно так же мы объединим 5-й отсортированный подсписок, сравнив и объединив 6-й и 7-й подсписки.

Теперь мы получим 6-й отсортированный подсписок, сравнив 8-й и 9-й подсписки.

Затем мы сравним и объединим 5-й и 6-й отсортированные подсписки, чтобы получить 7-й отсортированный подсписок.

В конце концов, 4-й и 7-й отсортированные подсписки будут сравниваться и объединяться, и будет получен 8-й отсортированный подсписок. Для этого мы сравним первый элемент 4-го и 7-го отсортированных подсписок и найдем элемент меньшего размера. Меньший элемент будет помещен первым. Затем указатель будет увеличиваться в этом отсортированном подсписке и сравниваться с другим отсортированным подсписком.

Алгоритм

Основанный на принципе разделяй и властвуй, алгоритм сортировки слиянием будет выглядеть так:

merge( B , fv , lv ){ 
  if ( lv < fv ){
    M = (lv +fv )/2 
    mergesort ( B , lv , M ) 
    mergesort ( B , M + 1 , fv ) 
    merge( B , lv , M , fv )
  }
}

Использование кода

Для этого давайте рассмотрим приведенный выше массив «B», состоящий из 8 элементов. Будет использоваться функция слияния, которая содержит имя массива, верхнее значение, нижнее значение и среднюю точку.

merge( B ,fv , M , lv )
x = fv;
y = M + 1;
z = fv;

while ( x ≤ M & y ≤ lv ){
	if ( B [x] ≤ B[y] ){
			C[z] = B [z];
			x++;
			z++;
  }else{
			C [z ] = B [y]
			y++;
			z++;
	}
	if ( x > M ){
		while ( y ≤ lv ){
      C[z] = B[y];
      y++;
      z++;
		}
   }else{
			while ( x ≤ M ){
				C[z] = B[x];
				x++;
				z++;
			}
		}
	for ( z = lv ; z ≤ fv ; z++ ){
			B[z] = C[z];
	}
}

Псевдокод

Чтобы понять принцип работы псевдокода сортировки слиянием, в качестве входных данных будет взят несортированный массив «B». И на выходе мы получим отсортированный массив. Мы разделим этот несортированный массив на подмассивы. Как только мы получим одноэлементный массив, нам не нужно будет делить его дальше, потому что это будет отсортированный массив. Это называется базовый вариант. Итак, сначала мы напишем базовый вариант, а затем будут созданы левый и правый массив. Затем эти массивы будут отсортированы и объединены.

if ( x == 1 ){
	return B;
}
L = mergesort( L );   
R = mergesort( R );    
m_array = merge ( L , R );  
return merdgedarray ;

Анализ времени выполнения

Время выполнения алгоритма обозначается как T(N). Рассмотрим два примера:

• Сначала будет базовый вариант, когда алгоритм займет постоянное количество времени, равное «а».

  

• Для слияния слева и справа время будет:

Где «b» — это просто константа. И bN показывает, что слияние занимает некоторое постоянное количество времени на каждый сливаемый элемент.

Можем записать как:

Таким образом, время выполнения сортировки слиянием будет ( Nlog2N )

K-Way слияние

Также известно как многостороннее слияние. Используется для внешней сортировки. Оно имеет входные k отсортированных массивов, в каждом из которых содержится n элементов. Здесь мы объединим отсортированный массив, чтобы получить отсортированный вывод.

2-сторонняя сортировка слиянием

Используется при внешнем слиянии. Он состоит из n элементов. Рассмотрим на примере двухстороннее слияние. В качестве входных данных были взяты два массива. Каждый массив состоит из четырех элементов. Размер обоих массивов — четыре. Оба массива проиндексированы от 0 до 3. Чтобы объединить эти два массива, нам нужен указатель с тремя указателями, который помещается в начальный элемент каждого массива. Оба массива уже отсортированы. Объединив эти два массива, мы получим результирующий массив, состоящий из восьми элементов. Сравним первый элемент первых двух массивов. И меньший элемент будет помещен первым в выходной массив. Затем указатель выходного массива и второго массива будет увеличен, и будет продолжен тот же процесс сравнения элементов. В итоге на выходе мы получим отсортированный массив.

3-сторонняя сортировка слиянием

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

Достоинства и недостатки сортировки слиянием

Достоинства:

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

• Стабильное время выполнения.

• Можно использовать для больших файлов.

• Идеально для организации труднодоступных данных.

Недостатки:

• Для короткого списка процесс более медленный.

• Требует дополнительной памяти для хранения информации.

Применение:

• Для организации связанных списков за время O (nlog n).

• Инверсивный счет.

• Сортировка большого количества информации.

An example of merge sort. First, divide the list into the smallest unit (1 element), then compare each element with the adjacent list to sort and merge the two adjacent lists. Finally, all the elements are sorted and merged.
Class	Sorting algorithm
Data structure	Array
Worst-case performance
Best-case performance	typical, natural variant
Average performance
Worst-case space complexity	total with auxiliary, auxiliary with linked lists[1]

In computer science, merge sort (also commonly spelled as mergesort) is an efficient, general-purpose, and comparison-based sorting algorithm. Most implementations produce a stable sort, which means that the order of equal elements is the same in the input and output. Merge sort is a divide-and-conquer algorithm that was invented by John von Neumann in 1945.^[2] A detailed description and analysis of bottom-up merge sort appeared in a report by Goldstine and von Neumann as early as 1948.^[3]

Algorithm[edit]

Conceptually, a merge sort works as follows:

1. Divide the unsorted list into n sublists, each containing one element (a list of one element is considered sorted).
2. Repeatedly merge sublists to produce new sorted sublists until there is only one sublist remaining. This will be the sorted list.

Top-down implementation[edit]

Example C-like code using indices for top-down merge sort algorithm that recursively splits the list (called runs in this example) into sublists until sublist size is 1, then merges those sublists to produce a sorted list. The copy back step is avoided with alternating the direction of the merge with each level of recursion (except for an initial one-time copy, that can be avoided too). To help understand this, consider an array with two elements. The elements are copied to B[], then merged back to A[]. If there are four elements, when the bottom of the recursion level is reached, single element runs from A[] are merged to B[], and then at the next higher level of recursion, those two-element runs are merged to A[]. This pattern continues with each level of recursion.

// Array A[] has the items to sort; array B[] is a work array.
void TopDownMergeSort(A[], B[], n)
{
    CopyArray(A, 0, n, B);           // one time copy of A[] to B[]
    TopDownSplitMerge(B, 0, n, A);   // sort data from B[] into A[]
}

// Split A[] into 2 runs, sort both runs into B[], merge both runs from B[] to A[]
// iBegin is inclusive; iEnd is exclusive (A[iEnd] is not in the set).
void TopDownSplitMerge(B[], iBegin, iEnd, A[])
{
    if (iEnd - iBegin <= 1)                     // if run size == 1
        return;                                 //   consider it sorted
    // split the run longer than 1 item into halves
    iMiddle = (iEnd + iBegin) / 2;              // iMiddle = mid point
    // recursively sort both runs from array A[] into B[]
    TopDownSplitMerge(A, iBegin,  iMiddle, B);  // sort the left  run
    TopDownSplitMerge(A, iMiddle,    iEnd, B);  // sort the right run
    // merge the resulting runs from array B[] into A[]
    TopDownMerge(B, iBegin, iMiddle, iEnd, A);
}

//  Left source half is A[ iBegin:iMiddle-1].
// Right source half is A[iMiddle:iEnd-1   ].
// Result is            B[ iBegin:iEnd-1   ].
void TopDownMerge(A[], iBegin, iMiddle, iEnd, B[])
{
    i = iBegin, j = iMiddle;
 
    // While there are elements in the left or right runs...
    for (k = iBegin; k < iEnd; k++) {
        // If left run head exists and is <= existing right run head.
        if (i < iMiddle && (j >= iEnd || A[i] <= A[j])) {
            B[k] = A[i];
            i = i + 1;
        } else {
            B[k] = A[j];
            j = j + 1;
        }
    }
}

void CopyArray(A[], iBegin, iEnd, B[])
{
    for (k = iBegin; k < iEnd; k++)
        B[k] = A[k];
}

Sorting the entire array is accomplished by TopDownMergeSort(A, B, length(A)).

Bottom-up implementation[edit]

Example C-like code using indices for bottom-up merge sort algorithm which treats the list as an array of n sublists (called runs in this example) of size 1, and iteratively merges sub-lists back and forth between two buffers:

// array A[] has the items to sort; array B[] is a work array
void BottomUpMergeSort(A[], B[], n)
{
    // Each 1-element run in A is already "sorted".
    // Make successively longer sorted runs of length 2, 4, 8, 16... until the whole array is sorted.
    for (width = 1; width < n; width = 2 * width)
    {
        // Array A is full of runs of length width.
        for (i = 0; i < n; i = i + 2 * width)
        {
            // Merge two runs: A[i:i+width-1] and A[i+width:i+2*width-1] to B[]
            // or copy A[i:n-1] to B[] ( if (i+width >= n) )
            BottomUpMerge(A, i, min(i+width, n), min(i+2*width, n), B);
        }
        // Now work array B is full of runs of length 2*width.
        // Copy array B to array A for the next iteration.
        // A more efficient implementation would swap the roles of A and B.
        CopyArray(B, A, n);
        // Now array A is full of runs of length 2*width.
    }
}

//  Left run is A[iLeft :iRight-1].
// Right run is A[iRight:iEnd-1  ].
void BottomUpMerge(A[], iLeft, iRight, iEnd, B[])
{
    i = iLeft, j = iRight;
    // While there are elements in the left or right runs...
    for (k = iLeft; k < iEnd; k++) {
        // If left run head exists and is <= existing right run head.
        if (i < iRight && (j >= iEnd || A[i] <= A[j])) {
            B[k] = A[i];
            i = i + 1;
        } else {
            B[k] = A[j];
            j = j + 1;    
        }
    } 
}

void CopyArray(B[], A[], n)
{
    for (i = 0; i < n; i++)
        A[i] = B[i];
}

Top-down implementation using lists[edit]

Pseudocode for top-down merge sort algorithm which recursively divides the input list into smaller sublists until the sublists are trivially sorted, and then merges the sublists while returning up the call chain.

function merge_sort(list m) is
    // Base case. A list of zero or one elements is sorted, by definition.
    if length of m ≤ 1 then
        return m

    // Recursive case. First, divide the list into equal-sized sublists
    // consisting of the first half and second half of the list.
    // This assumes lists start at index 0.
    var left := empty list
    var right := empty list
    for each x with index i in m do
        if i < (length of m)/2 then
            add x to left
        else
            add x to right

    // Recursively sort both sublists.
    left := merge_sort(left)
    right := merge_sort(right)

    // Then merge the now-sorted sublists.
    return merge(left, right)

In this example, the merge function merges the left and right sublists.

function merge(left, right) is
    var result := empty list

    while left is not empty and right is not empty do
        if first(left) ≤ first(right) then
            append first(left) to result
            left := rest(left)
        else
            append first(right) to result
            right := rest(right)

    // Either left or right may have elements left; consume them.
    // (Only one of the following loops will actually be entered.)
    while left is not empty do
        append first(left) to result
        left := rest(left)
    while right is not empty do
        append first(right) to result
        right := rest(right)
    return result

Bottom-up implementation using lists[edit]

Pseudocode for bottom-up merge sort algorithm which uses a small fixed size array of references to nodes, where array[i] is either a reference to a list of size 2ⁱ or nil. node is a reference or pointer to a node. The merge() function would be similar to the one shown in the top-down merge lists example, it merges two already sorted lists, and handles empty lists. In this case, merge() would use node for its input parameters and return value.

function merge_sort(node head) is
    // return if empty list
    if head = nil then
        return nil
    var node array[32]; initially all nil
    var node result
    var node next
    var int  i
    result := head
    // merge nodes into array
    while result ≠ nil do
        next := result.next;
        result.next := nil
        for (i = 0; (i < 32) && (array[i] ≠ nil); i += 1) do
            result := merge(array[i], result)
            array[i] := nil
        // do not go past end of array
        if i = 32 then
            i -= 1
        array[i] := result
        result := next
    // merge array into single list
    result := nil
    for (i = 0; i < 32; i += 1) do
        result := merge(array[i], result)
    return result

Analysis[edit]

In sorting n objects, merge sort has an average and worst-case performance of O(n log n). If the running time of merge sort for a list of length n is T(n), then the recurrence relation T(n) = 2T(n/2) + n follows from the definition of the algorithm (apply the algorithm to two lists of half the size of the original list, and add the n steps taken to merge the resulting two lists).^[4] The closed form follows from the master theorem for divide-and-conquer recurrences.

The number of comparisons made by merge sort in the worst case is given by the sorting numbers. These numbers are equal to or slightly smaller than (n ⌈lg n⌉ − 2^⌈lg n⌉ + 1), which is between (n lg n − n + 1) and (n lg n + n + O(lg n)).^[5] Merge sort’s best case takes about half as many iterations as its worst case.^[6]

For large n and a randomly ordered input list, merge sort’s expected (average) number of comparisons approaches α·n fewer than the worst case, where

In the worst case, merge sort uses approximately 39% fewer comparisons than quicksort does in its average case, and in terms of moves, merge sort’s worst case complexity is O(n log n) — the same complexity as quicksort’s best case.^[6]

Merge sort is more efficient than quicksort for some types of lists if the data to be sorted can only be efficiently accessed sequentially, and is thus popular in languages such as Lisp, where sequentially accessed data structures are very common. Unlike some (efficient) implementations of quicksort, merge sort is a stable sort.

Merge sort’s most common implementation does not sort in place;^[7] therefore, the memory size of the input must be allocated for the sorted output to be stored in (see below for variations that need only n/2 extra spaces).

Natural merge sort[edit]

A natural merge sort is similar to a bottom-up merge sort except that any naturally occurring runs (sorted sequences) in the input are exploited. Both monotonic and bitonic (alternating up/down) runs may be exploited, with lists (or equivalently tapes or files) being convenient data structures (used as FIFO queues or LIFO stacks).^[8] In the bottom-up merge sort, the starting point assumes each run is one item long. In practice, random input data will have many short runs that just happen to be sorted. In the typical case, the natural merge sort may not need as many passes because there are fewer runs to merge. In the best case, the input is already sorted (i.e., is one run), so the natural merge sort need only make one pass through the data. In many practical cases, long natural runs are present, and for that reason natural merge sort is exploited as the key component of Timsort. Example:

Start       :  3  4  2  1  7  5  8  9  0  6
Select runs : (3  4)(2)(1  7)(5  8  9)(0  6)
Merge       : (2  3  4)(1  5  7  8  9)(0  6)
Merge       : (1  2  3  4  5  7  8  9)(0  6)
Merge       : (0  1  2  3  4  5  6  7  8  9)

Formally, the natural merge sort is said to be Runs-optimal, where is the number of runs in , minus one.

Tournament replacement selection sorts are used to gather the initial runs for external sorting algorithms.

Ping-pong merge sort[edit]

Instead of merging two blocks at a time, a ping-pong merge merges four blocks at a time. The four sorted blocks are merged simultaneously to auxiliary space into two sorted blocks, then the two sorted blocks are merged back to main memory. Doing so omits the copy operation and reduces the total number of moves by half. An early public domain implementation of a four-at-once merge was by WikiSort in 2014, the method was later that year described as an optimization for patience sorting and named a ping-pong merge.^[9][10] Quadsort implemented the method in 2020 and named it a quad merge.^[11]

In-place merge sort[edit]

One drawback of merge sort, when implemented on arrays, is its O(n) working memory requirement. Several methods to reduce memory or make merge sort fully in-place have been suggested:

• Kronrod (1969) suggested an alternative version of merge sort that uses constant additional space.
• Katajainen et al. present an algorithm that requires a constant amount of working memory: enough storage space to hold one element of the input array, and additional space to hold O(1) pointers into the input array. They achieve an O(n log n) time bound with small constants, but their algorithm is not stable.^[12]
• Several attempts have been made at producing an in-place merge algorithm that can be combined with a standard (top-down or bottom-up) merge sort to produce an in-place merge sort. In this case, the notion of «in-place» can be relaxed to mean «taking logarithmic stack space», because standard merge sort requires that amount of space for its own stack usage. It was shown by Geffert et al. that in-place, stable merging is possible in O(n log n) time using a constant amount of scratch space, but their algorithm is complicated and has high constant factors: merging arrays of length n and m can take 5n + 12m + o(m) moves.^[13] This high constant factor and complicated in-place algorithm was made simpler and easier to understand. Bing-Chao Huang and Michael A. Langston^[14] presented a straightforward linear time algorithm practical in-place merge to merge a sorted list using fixed amount of additional space. They both have used the work of Kronrod and others. It merges in linear time and constant extra space. The algorithm takes little more average time than standard merge sort algorithms, free to exploit O(n) temporary extra memory cells, by less than a factor of two. Though the algorithm is much faster in a practical way but it is unstable also for some lists. But using similar concepts, they have been able to solve this problem. Other in-place algorithms include SymMerge, which takes O((n + m) log (n + m)) time in total and is stable.^[15] Plugging such an algorithm into merge sort increases its complexity to the non-linearithmic, but still quasilinear, O(n (log n)²).
• Many applications of external sorting use a form of merge sorting where the input get split up to a higher number of sublists, ideally to a number for which merging them still makes the currently processed set of pages fit into main memory.
• A modern stable linear and in-place merge variant is block merge sort which creates a section of unique values to use as swap space.
• The space overhead can be reduced to sqrt(n) by using binary searches and rotations.^[16] This method is employed by the C++ STL library and quadsort.^[11]
• An alternative to reduce the copying into multiple lists is to associate a new field of information with each key (the elements in m are called keys). This field will be used to link the keys and any associated information together in a sorted list (a key and its related information is called a record). Then the merging of the sorted lists proceeds by changing the link values; no records need to be moved at all. A field which contains only a link will generally be smaller than an entire record so less space will also be used. This is a standard sorting technique, not restricted to merge sort.
• A simple way to reduce the space overhead to n/2 is to maintain left and right as a combined structure, copy only the left part of m into temporary space, and to direct the merge routine to place the merged output into m. With this version it is better to allocate the temporary space outside the merge routine, so that only one allocation is needed. The excessive copying mentioned previously is also mitigated, since the last pair of lines before the return result statement (function merge in the pseudo code above) become superfluous.

Use with tape drives[edit]

An external merge sort is practical to run using disk or tape drives when the data to be sorted is too large to fit into memory. External sorting explains how merge sort is implemented with disk drives. A typical tape drive sort uses four tape drives. All I/O is sequential (except for rewinds at the end of each pass). A minimal implementation can get by with just two record buffers and a few program variables.

Naming the four tape drives as A, B, C, D, with the original data on A, and using only two record buffers, the algorithm is similar to the bottom-up implementation, using pairs of tape drives instead of arrays in memory. The basic algorithm can be described as follows:

1. Merge pairs of records from A; writing two-record sublists alternately to C and D.
2. Merge two-record sublists from C and D into four-record sublists; writing these alternately to A and B.
3. Merge four-record sublists from A and B into eight-record sublists; writing these alternately to C and D
4. Repeat until you have one list containing all the data, sorted—in log₂(n) passes.

Instead of starting with very short runs, usually a hybrid algorithm is used, where the initial pass will read many records into memory, do an internal sort to create a long run, and then distribute those long runs onto the output set. The step avoids many early passes. For example, an internal sort of 1024 records will save nine passes. The internal sort is often large because it has such a benefit. In fact, there are techniques that can make the initial runs longer than the available internal memory. One of them, the Knuth’s ‘snowplow’ (based on a binary min-heap), generates runs twice as long (on average) as a size of memory used.^[17]

With some overhead, the above algorithm can be modified to use three tapes. O(n log n) running time can also be achieved using two queues, or a stack and a queue, or three stacks. In the other direction, using k > two tapes (and O(k) items in memory), we can reduce the number of tape operations in O(log k) times by using a k/2-way merge.

A more sophisticated merge sort that optimizes tape (and disk) drive usage is the polyphase merge sort.

Optimizing merge sort[edit]

On modern computers, locality of reference can be of paramount importance in software optimization, because multilevel memory hierarchies are used. Cache-aware versions of the merge sort algorithm, whose operations have been specifically chosen to minimize the movement of pages in and out of a machine’s memory cache, have been proposed. For example, the tiled merge sort algorithm stops partitioning subarrays when subarrays of size S are reached, where S is the number of data items fitting into a CPU’s cache. Each of these subarrays is sorted with an in-place sorting algorithm such as insertion sort, to discourage memory swaps, and normal merge sort is then completed in the standard recursive fashion. This algorithm has demonstrated better performance^{[example needed]} on machines that benefit from cache optimization. (LaMarca & Ladner 1997)

Parallel merge Sort[edit]

Merge sort parallelizes well due to the use of the divide-and-conquer method. Several different parallel variants of the algorithm have been developed over the years. Some parallel merge sort algorithms are strongly related to the sequential top-down merge algorithm while others have a different general structure and use the K-way merge method.

Merge sort with parallel recursion[edit]

The sequential merge sort procedure can be described in two phases, the divide phase and the merge phase. The first consists of many recursive calls that repeatedly perform the same division process until the subsequences are trivially sorted (containing one or no element). An intuitive approach is the parallelization of those recursive calls.^[18] Following pseudocode describes the merge sort with parallel recursion using the fork and join keywords:

// Sort elements lo through hi (exclusive) of array A.
algorithm mergesort(A, lo, hi) is
    if lo+1 < hi then  // Two or more elements.
        mid := ⌊(lo + hi) / 2⌋
        fork mergesort(A, lo, mid)
        mergesort(A, mid, hi)
        join
        merge(A, lo, mid, hi)

This algorithm is the trivial modification of the sequential version and does not parallelize well. Therefore, its speedup is not very impressive. It has a span of , which is only an improvement of compared to the sequential version (see Introduction to Algorithms). This is mainly due to the sequential merge method, as it is the bottleneck of the parallel executions.

Merge sort with parallel merging[edit]

Better parallelism can be achieved by using a parallel merge algorithm. Cormen et al. present a binary variant that merges two sorted sub-sequences into one sorted output sequence.^[18]

In one of the sequences (the longer one if unequal length), the element of the middle index is selected. Its position in the other sequence is determined in such a way that this sequence would remain sorted if this element were inserted at this position. Thus, one knows how many other elements from both sequences are smaller and the position of the selected element in the output sequence can be calculated. For the partial sequences of the smaller and larger elements created in this way, the merge algorithm is again executed in parallel until the base case of the recursion is reached.

The following pseudocode shows the modified parallel merge sort method using the parallel merge algorithm (adopted from Cormen et al.).

/**
 * A: Input array
 * B: Output array
 * lo: lower bound
 * hi: upper bound
 * off: offset
 */
algorithm parallelMergesort(A, lo, hi, B, off) is
    len := hi - lo + 1
    if len == 1 then
        B[off] := A[lo]
    else let T[1..len] be a new array
        mid := ⌊(lo + hi) / 2⌋ 
        mid' := mid - lo + 1
        fork parallelMergesort(A, lo, mid, T, 1)
        parallelMergesort(A, mid + 1, hi, T, mid' + 1) 
        join 
        parallelMerge(T, 1, mid', mid' + 1, len, B, off)

In order to analyze a recurrence relation for the worst case span, the recursive calls of parallelMergesort have to be incorporated only once due to their parallel execution, obtaining

For detailed information about the complexity of the parallel merge procedure, see Merge algorithm.

The solution of this recurrence is given by

This parallel merge algorithm reaches a parallelism of , which is much higher than the parallelism of the previous algorithm. Such a sort can perform well in practice when combined with a fast stable sequential sort, such as insertion sort, and a fast sequential merge as a base case for merging small arrays.^[19]

Parallel multiway merge sort[edit]

It seems arbitrary to restrict the merge sort algorithms to a binary merge method, since there are usually p > 2 processors available. A better approach may be to use a K-way merge method, a generalization of binary merge, in which sorted sequences are merged. This merge variant is well suited to describe a sorting algorithm on a PRAM.^[20][21]

Basic Idea[edit]

Given an unsorted sequence of elements, the goal is to sort the sequence with available processors. These elements are distributed equally among all processors and sorted locally using a sequential Sorting algorithm. Hence, the sequence consists of sorted sequences of length . For simplification let be a multiple of , so that for .

These sequences will be used to perform a multisequence selection/splitter selection. For , the algorithm determines splitter elements with global rank . Then the corresponding positions of in each sequence are determined with binary search and thus the are further partitioned into subsequences with .

Furthermore, the elements of are assigned to processor , means all elements between rank and rank , which are distributed over all . Thus, each processor receives a sequence of sorted sequences. The fact that the rank of the splitter elements was chosen globally, provides two important properties: On the one hand, was chosen so that each processor can still operate on elements after assignment. The algorithm is perfectly load-balanced. On the other hand, all elements on processor are less than or equal to all elements on processor . Hence, each processor performs the p-way merge locally and thus obtains a sorted sequence from its sub-sequences. Because of the second property, no further p-way-merge has to be performed, the results only have to be put together in the order of the processor number.

Multi-sequence selection[edit]

In its simplest form, given sorted sequences distributed evenly on processors and a rank , the task is to find an element with a global rank in the union of the sequences. Hence, this can be used to divide each in two parts at a splitter index , where the lower part contains only elements which are smaller than , while the elements bigger than are located in the upper part.

The presented sequential algorithm returns the indices of the splits in each sequence, e.g. the indices in sequences such that has a global rank less than and .^[22]

algorithm msSelect(S : Array of sorted Sequences [S_1,..,S_p], k : int) is
    for i = 1 to p do 
	(l_i, r_i) = (0, |S_i|-1)
	
    while there exists i: l_i < r_i do
	// pick Pivot Element in S_j[l_j], .., S_j[r_j], chose random j uniformly
	v := pickPivot(S, l, r)
	for i = 1 to p do 
	    m_i = binarySearch(v, S_i[l_i, r_i]) // sequentially
	if m_1 + ... + m_p >= k then // m_1+ ... + m_p is the global rank of v
	    r := m  // vector assignment
	else
	    l := m 
	
    return l

For the complexity analysis the PRAM model is chosen. If the data is evenly distributed over all , the p-fold execution of the binarySearch method has a running time of . The expected recursion depth is as in the ordinary Quickselect. Thus the overall expected running time is .

Applied on the parallel multiway merge sort, this algorithm has to be invoked in parallel such that all splitter elements of rank for are found simultaneously. These splitter elements can then be used to partition each sequence in parts, with the same total running time of .

Pseudocode[edit]

Below, the complete pseudocode of the parallel multiway merge sort algorithm is given. We assume that there is a barrier synchronization before and after the multisequence selection such that every processor can determine the splitting elements and the sequence partition properly.

/**
 * d: Unsorted Array of Elements
 * n: Number of Elements
 * p: Number of Processors
 * return Sorted Array
 */
algorithm parallelMultiwayMergesort(d : Array, n : int, p : int) is
    o := new Array[0, n]                         // the output array
    for i = 1 to p do in parallel                // each processor in parallel
        S_i := d[(i-1) * n/p, i * n/p] 	         // Sequence of length n/p
	sort(S_i)                                // sort locally
        synch
	v_i := msSelect([S_1,...,S_p], i * n/p)          // element with global rank i * n/p
        synch
	(S_i,1, ..., S_i,p) := sequence_partitioning(si, v_1, ..., v_p) // split s_i into subsequences
	    
	o[(i-1) * n/p, i * n/p] := kWayMerge(s_1,i, ..., s_p,i)  // merge and assign to output array
	
    return o

Analysis[edit]

Firstly, each processor sorts the assigned elements locally using a sorting algorithm with complexity . After that, the splitter elements have to be calculated in time . Finally, each group of splits have to be merged in parallel by each processor with a running time of using a sequential p-way merge algorithm. Thus, the overall running time is given by

.

Practical adaption and application[edit]

The multiway merge sort algorithm is very scalable through its high parallelization capability, which allows the use of many processors. This makes the algorithm a viable candidate for sorting large amounts of data, such as those processed in computer clusters. Also, since in such systems memory is usually not a limiting resource, the disadvantage of space complexity of merge sort is negligible. However, other factors become important in such systems, which are not taken into account when modelling on a PRAM. Here, the following aspects need to be considered: Memory hierarchy, when the data does not fit into the processors cache, or the communication overhead of exchanging data between processors, which could become a bottleneck when the data can no longer be accessed via the shared memory.

Sanders et al. have presented in their paper a bulk synchronous parallel algorithm for multilevel multiway mergesort, which divides processors into groups of size . All processors sort locally first. Unlike single level multiway mergesort, these sequences are then partitioned into parts and assigned to the appropriate processor groups. These steps are repeated recursively in those groups. This reduces communication and especially avoids problems with many small messages. The hierarchical structure of the underlying real network can be used to define the processor groups (e.g. racks, clusters,…).^[21]

Further variants[edit]

Merge sort was one of the first sorting algorithms where optimal speed up was achieved, with Richard Cole using a clever subsampling algorithm to ensure O(1) merge.^[23] Other sophisticated parallel sorting algorithms can achieve the same or better time bounds with a lower constant. For example, in 1991 David Powers described a parallelized quicksort (and a related radix sort) that can operate in O(log n) time on a CRCW parallel random-access machine (PRAM) with n processors by performing partitioning implicitly.^[24] Powers further shows that a pipelined version of Batcher’s Bitonic Mergesort at O((log n)²) time on a butterfly sorting network is in practice actually faster than his O(log n) sorts on a PRAM, and he provides detailed discussion of the hidden overheads in comparison, radix and parallel sorting.^[25]

Comparison with other sort algorithms[edit]

Although heapsort has the same time bounds as merge sort, it requires only Θ(1) auxiliary space instead of merge sort’s Θ(n). On typical modern architectures, efficient quicksort implementations generally outperform merge sort for sorting RAM-based arrays.^{[citation needed]} On the other hand, merge sort is a stable sort and is more efficient at handling slow-to-access sequential media. Merge sort is often the best choice for sorting a linked list: in this situation it is relatively easy to implement a merge sort in such a way that it requires only Θ(1) extra space, and the slow random-access performance of a linked list makes some other algorithms (such as quicksort) perform poorly, and others (such as heapsort) completely impossible.

As of Perl 5.8, merge sort is its default sorting algorithm (it was quicksort in previous versions of Perl).^[26] In Java, the Arrays.sort() methods use merge sort or a tuned quicksort depending on the datatypes and for implementation efficiency switch to insertion sort when fewer than seven array elements are being sorted.^[27] The Linux kernel uses merge sort for its linked lists.^[28] Python uses Timsort, another tuned hybrid of merge sort and insertion sort, that has become the standard sort algorithm in Java SE 7 (for arrays of non-primitive types),^[29] on the Android platform,^[30] and in GNU Octave.^[31]

Notes[edit]

References[edit]

• Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2009) [1990]. Introduction to Algorithms (3rd ed.). MIT Press and McGraw-Hill. ISBN 0-262-03384-4.
• Katajainen, Jyrki; Pasanen, Tomi; Teuhola, Jukka (1996). «Practical in-place mergesort». Nordic Journal of Computing. 3 (1): 27–40. CiteSeerX 10.1.1.22.8523. ISSN 1236-6064. Archived from the original on 2011-08-07. Retrieved 2009-04-04.. Also Practical In-Place Mergesort. Also [3]
• Knuth, Donald (1998). «Section 5.2.4: Sorting by Merging». Sorting and Searching. The Art of Computer Programming. Vol. 3 (2nd ed.). Addison-Wesley. pp. 158–168. ISBN 0-201-89685-0.
• Kronrod, M. A. (1969). «Optimal ordering algorithm without operational field». Soviet Mathematics — Doklady. 10: 744.
• LaMarca, A.; Ladner, R. E. (1997). «The influence of caches on the performance of sorting». Proc. 8th Ann. ACM-SIAM Symp. On Discrete Algorithms (SODA97): 370–379. CiteSeerX 10.1.1.31.1153.
• Skiena, Steven S. (2008). «4.5: Mergesort: Sorting by Divide-and-Conquer». The Algorithm Design Manual (2nd ed.). Springer. pp. 120–125. ISBN 978-1-84800-069-8.
• Sun Microsystems. «Arrays API (Java SE 6)». Retrieved 2007-11-19.
• Oracle Corp. «Arrays (Java SE 10 & JDK 10)». Retrieved 2018-07-23.

External links[edit]

• Animated Sorting Algorithms: Merge Sort at the Wayback Machine (archived 6 March 2015) – graphical demonstration
• Open Data Structures — Section 11.1.1 — Merge Sort, Pat Morin

В статье «Sorting Algorithms in Python», перевод которой опубликовал сайт tproger.ru, рассмотрены популярные алгоритмы, принципы их работы и реализация на Python.

(Примечание редакции Techrocks: алгоритмы сортировки с примерами на JavaScript смотрите здесь).

В качестве общего примера возьмём сортировку чисел в порядке возрастания. Но эти методы можно легко адаптировать под ваши потребности.

Пузырьковая сортировка

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

Алгоритм

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

При достижении конца списка процесс повторяется заново для каждого элемента. Это крайне неэффективно, если в массиве нужно сделать, например, только один обмен. Алгоритм повторяется n² раз, даже если список уже отсортирован.

Для оптимизации алгоритма нужно знать, когда его остановить, то есть когда список отсортирован.

Чтобы остановить алгоритм по окончании сортировки, нужно ввести переменную-флаг. Когда значения меняются местами, устанавливаем флаг в значение True, чтобы повторить процесс сортировки. Если перестановок не произошло, флаг остаётся False и алгоритм останавливается.

Реализация

def bubble_sort(nums):  
    # Устанавливаем swapped в True, чтобы цикл запустился хотя бы один раз
    swapped = True
    while swapped:
        swapped = False
        for i in range(len(nums) - 1):
            if nums[i] > nums[i + 1]:
                # Меняем элементы
                nums[i], nums[i + 1] = nums[i + 1], nums[i]
                # Устанавливаем swapped в True для следующей итерации
                swapped = True

# Проверяем, что оно работает
random_list_of_nums = [5, 2, 1, 8, 4]  
bubble_sort(random_list_of_nums)  
print(random_list_of_nums)

Алгоритм работает в цикле while и прерывается, когда элементы ни разу не меняются местами. Вначале присваиваем swapped значение True, чтобы алгоритм запустился хотя бы один раз.

Время сортировки

Если взять самый худший случай (изначально список отсортирован по убыванию), затраты времени будут равны O(n²), где n — количество элементов списка.

Сортировка выборкой

Этот алгоритм сегментирует список на две части: отсортированную и неотсортированную. Наименьший элемент удаляется из второго списка и добавляется в первый.

Алгоритм

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

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

Реализация

def selection_sort(nums):  
    # Значение i соответствует кол-ву отсортированных значений
    for i in range(len(nums)):
        # Исходно считаем наименьшим первый элемент
        lowest_value_index = i
        # Этот цикл перебирает несортированные элементы
        for j in range(i + 1, len(nums)):
            if nums[j] < nums[lowest_value_index]:
                lowest_value_index = j
        # Самый маленький элемент меняем с первым в списке
        nums[i], nums[lowest_value_index] = nums[lowest_value_index], nums[i]

# Проверяем, что оно работает
random_list_of_nums = [12, 8, 3, 20, 11]  
selection_sort(random_list_of_nums)  
print(random_list_of_nums) 

По мере увеличения значения i нужно проверять меньше элементов.

Время сортировки

Затраты времени на сортировку выборкой в среднем составляют O(n²), где n — количество элементов списка.

Сортировка вставками

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

Алгоритм

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

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

Реализация

def insertion_sort(nums):  
    # Сортировку начинаем со второго элемента, т.к. считается, что первый элемент уже отсортирован
    for i in range(1, len(nums)):
        item_to_insert = nums[i]
        # Сохраняем ссылку на индекс предыдущего элемента
        j = i - 1
        # Элементы отсортированного сегмента перемещаем вперёд, если они больше
        # элемента для вставки
        while j >= 0 and nums[j] > item_to_insert:
            nums[j + 1] = nums[j]
            j -= 1
        # Вставляем элемент
        nums[j + 1] = item_to_insert

# Проверяем, что оно работает
random_list_of_nums = [9, 1, 15, 28, 6]  
insertion_sort(random_list_of_nums)  
print(random_list_of_nums)

Время сортировки

Время сортировки вставками в среднем равно O(n²), где n — количество элементов списка.

Пирамидальная сортировка

Также известна как сортировка кучей. Этот популярный алгоритм, как и сортировки вставками или выборкой, сегментирует список на две части: отсортированную и неотсортированную. Алгоритм преобразует второй сегмент списка в структуру данных «куча» (heap), чтобы можно было эффективно определить самый большой элемент.

Алгоритм

Сначала преобразуем список в Max Heap — бинарное дерево, где самый большой элемент является вершиной дерева. Затем помещаем этот элемент в конец списка. После перестраиваем Max Heap и снова помещаем новый наибольший элемент уже перед последним элементом в списке.

Этот процесс построения кучи повторяется, пока все вершины дерева не будут удалены.

Реализация

Создадим вспомогательную функцию heapify() для реализации этого алгоритма:

def heapify(nums, heap_size, root_index):  
    # Индекс наибольшего элемента считаем корневым индексом
    largest = root_index
    left_child = (2 * root_index) + 1
    right_child = (2 * root_index) + 2

    # Если левый потомок корня — допустимый индекс, а элемент больше,
    # чем текущий наибольший, обновляем наибольший элемент
    if left_child < heap_size and nums[left_child] > nums[largest]:
        largest = left_child

    # То же самое для правого потомка корня
    if right_child < heap_size and nums[right_child] > nums[largest]:
        largest = right_child

    # Если наибольший элемент больше не корневой, они меняются местами
    if largest != root_index:
        nums[root_index], nums[largest] = nums[largest], nums[root_index]
        # Heapify the new root element to ensure it's the largest
        heapify(nums, heap_size, largest)

def heap_sort(nums):  
    n = len(nums)

    # Создаём Max Heap из списка
    # Второй аргумент означает остановку алгоритма перед элементом -1, т.е.
    # перед первым элементом списка
    # 3-й аргумент означает повторный проход по списку в обратном направлении, 
    # уменьшая счётчик i на 1 
    for i in range(n, -1, -1):
        heapify(nums, n, i)

    # Перемещаем корень Max Heap в конец списка
    for i in range(n - 1, 0, -1):
        nums[i], nums[0] = nums[0], nums[i]
        heapify(nums, i, 0)

# Проверяем, что оно работает
random_list_of_nums = [35, 12, 43, 8, 51]  
heap_sort(random_list_of_nums)  
print(random_list_of_nums)

Время сортировки

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

Сортировка слиянием

Этот алгоритм относится к алгоритмам «разделяй и властвуй». Он разбивает список на две части, каждую из них он разбивает ещё на две и т. д. Список разбивается пополам, пока не останутся единичные элементы.

Соседние элементы становятся отсортированными парами. Затем эти пары объединяются и сортируются с другими парами. Этот процесс продолжается до тех пор, пока не отсортируются все элементы.

Алгоритм

Список рекурсивно разделяется пополам, пока в итоге не получатся списки размером в один элемент. Массив из одного элемента считается упорядоченным. Соседние элементы сравниваются и соединяются вместе. Это происходит до тех пор, пока не получится полный отсортированный список.

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

Реализация

def merge(left_list, right_list):  
    sorted_list = []
    left_list_index = right_list_index = 0

    # Длина списков часто используется, поэтому создадим переменные для удобства
    left_list_length, right_list_length = len(left_list), len(right_list)

    for _ in range(left_list_length + right_list_length):
        if left_list_index < left_list_length and right_list_index < right_list_length:
            # Сравниваем первые элементы в начале каждого списка
            # Если первый элемент левого подсписка меньше, добавляем его
            # в отсортированный массив
            if left_list[left_list_index] <= right_list[right_list_index]:
                sorted_list.append(left_list[left_list_index])
                left_list_index += 1
            # Если первый элемент правого подсписка меньше, добавляем его
            # в отсортированный массив
            else:
                sorted_list.append(right_list[right_list_index])
                right_list_index += 1

        # Если достигнут конец левого списка, элементы правого списка
        # добавляем в конец результирующего списка
        elif left_list_index == left_list_length:
            sorted_list.append(right_list[right_list_index])
            right_list_index += 1
        # Если достигнут конец правого списка, элементы левого списка
        # добавляем в отсортированный массив
        elif right_list_index == right_list_length:
            sorted_list.append(left_list[left_list_index])
            left_list_index += 1

    return sorted_list

def merge_sort(nums):  
    # Возвращаем список, если он состоит из одного элемента
    if len(nums) <= 1:
        return nums

    # Для того чтобы найти середину списка, используем деление без остатка
    # Индексы должны быть integer
    mid = len(nums) // 2

    # Сортируем и объединяем подсписки
    left_list = merge_sort(nums[:mid])
    right_list = merge_sort(nums[mid:])

    # Объединяем отсортированные списки в результирующий
    return merge(left_list, right_list)

# Проверяем, что оно работает
random_list_of_nums = [120, 45, 68, 250, 176]  
random_list_of_nums = merge_sort(random_list_of_nums)  
print(random_list_of_nums)

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

Время сортировки

В среднем время сортировки слиянием составляет O(n log n).

Быстрая сортировка

Этот алгоритм также относится к алгоритмам «разделяй и властвуй». Его используют чаще других алгоритмов, описанных в этой статье. При правильной конфигурации он чрезвычайно эффективен и не требует дополнительной памяти, в отличие от сортировки слиянием. Массив разделяется на две части по разные стороны от опорного элемента. В процессе сортировки элементы меньше опорного помещаются перед ним, а равные или большие —позади.

Алгоритм

Быстрая сортировка начинается с разбиения списка и выбора одного из элементов в качестве опорного. А всё остальное передвигаем так, чтобы этот элемент встал на своё место. Все элементы меньше него перемещаются влево, а равные и большие элементы перемещаются вправо.

Реализация

Существует много вариаций данного метода. Способ разбиения массива, рассмотренный здесь, соответствует схеме Хоара (создателя данного алгоритма).

def partition(nums, low, high):  
    # Выбираем средний элемент в качестве опорного
    # Также возможен выбор первого, последнего
    # или произвольного элементов в качестве опорного
    pivot = nums[(low + high) // 2]
    i = low - 1
    j = high + 1
    while True:
        i += 1
        while nums[i] < pivot:
            i += 1

        j -= 1
        while nums[j] > pivot:
            j -= 1

        if i >= j:
            return j

        # Если элемент с индексом i (слева от опорного) больше, чем
        # элемент с индексом j (справа от опорного), меняем их местами
        nums[i], nums[j] = nums[j], nums[i]

def quick_sort(nums):  
    # Создадим вспомогательную функцию, которая вызывается рекурсивно
    def _quick_sort(items, low, high):
        if low < high:
            # This is the index after the pivot, where our lists are split
            split_index = partition(items, low, high)
            _quick_sort(items, low, split_index)
            _quick_sort(items, split_index + 1, high)

    _quick_sort(nums, 0, len(nums) - 1)

# Проверяем, что оно работает
random_list_of_nums = [22, 5, 1, 18, 99]  
quick_sort(random_list_of_nums)  
print(random_list_of_nums) 

Время выполнения

В среднем время выполнения быстрой сортировки составляет O(n log n).

Обратите внимание, что алгоритм быстрой сортировки будет работать медленно, если опорный элемент равен наименьшему или наибольшему элементам списка. При таких условиях, в отличие от сортировок кучей и слиянием, обе из которых имеют в худшем случае время сортировки O(n log n), быстрая сортировка в худшем случае будет выполняться O(n²).

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

Отсортировать содержимое списка можно с помощью стандартного метода sort():

>>> apples_eaten_a_day = [2, 1, 1, 3, 1, 2, 2]
>>> apples_eaten_a_day.sort() 
>>> apples_eaten_a_day 
[1, 1, 1, 2, 2, 2, 3]

Или можно использовать функцию sorted() для создания нового отсортированного списка, оставив входной список нетронутым:

>>> apples_eaten_a_day_2 = [2, 1, 1, 3, 1, 2, 2] 
>>> sorted_apples = sorted(apples_eaten_a_day_2) 
>>> sorted_apples 
[1, 1, 1, 2, 2, 2, 3]

Оба эти метода сортируют в порядке возрастания, но можно изменить порядок, установив для флага reverse значение True:

# Обратная сортировка списка на месте 
>>> apples_eaten_a_day.sort(reverse=True) 
>>> apples_eaten_a_day 
[3, 2, 2, 2, 1, 1, 1] 

# Обратная сортировка, чтобы получить новый список 
>>> sorted_apples_desc = sorted(apples_eaten_a_day_2, reverse=True) >>> sorted_apples_desc 
[3, 2, 2, 2, 1, 1, 1]

В отличие от других алгоритмов, обе функции в Python могут сортировать также списки кортежей и классов. Функция sorted() может сортировать любую последовательность, которая включает списки, строки, кортежи, словари, наборы и пользовательские итераторы, которые вы можете создать.

Функции в Python реализуют алгоритм Tim Sort, основанный на сортировке слиянием и сортировке вставкой.

Сравнение скоростей сортировок

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

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

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

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

Сор­ти­ров­ка слия­ни­ем — ста­биль­ный ал­го­ритм сор­ти­ров­ки. Это озна­ча­ет, что по­ря­док «рав­ных» эле­мен­тов не из­ме­ня­ет­ся в ре­зуль­та­те ра­бо­ты ал­го­рит­ма. В не­ко­то­рых за­да­чах это свой­ство до­ста­точ­но важ­но.

Этот ал­го­ритм был пред­ло­жен Джо­ном фон Ней­ма­ном в 1945 го­ду

Вез­де в лек­ции эле­мен­ты мас­си­вов ну­ме­ру­ют­ся с ну­ля.

Про­це­ду­ра слия­ния

До­пу­стим, у нас есть два от­сор­ти­ро­ван­ных мас­си­ва А и B раз­ме­ра­ми и  со­от­вет­ствен­но, и мы хо­тим объ­еди­нить их эле­мен­ты в один боль­шой от­сор­ти­ро­ван­ный мас­сив C раз­ме­ром . Для это­го при­ме­ня­ет­ся про­це­ду­ра слия­ния, суть ко­то­рой за­клю­ча­ет­ся в том, что­бы «от­де­лять» эле­мент, наи­мень­ший из двух имею­щих­ся в на­ча­лах мас­си­вов, и при­со­еди­нять этот эле­мент к кон­цу ре­зуль­ти­рую­ще­го мас­си­ва. Это мы де­ла­ем, по­ка один из ис­ход­ных мас­си­вов не за­кон­чит­ся. По­сле это­го остав­ший­ся «хвост» од­но­го из вход­ных мас­си­вов до­пи­сы­ва­ет­ся в ко­нец ре­зуль­ти­рую­ще­го мас­си­ва:

(1)

Для обес­пе­че­ния ста­биль­но­сти ал­го­рит­ма сор­ти­ров­ки нуж­но, что­бы в слу­чае ра­вен­ства эле­мен­тов тот эле­мент, что идёт рань­ше во вход­ном мас­си­ве, по­па­дал в ре­зуль­ти­рую­щий мас­сив в первую оче­редь. Мы уви­дим да­лее, что ес­ли два эле­мен­та по­па­ли в раз­ные мас­си­вы (A и B), то тот эле­мент, что шёл рань­ше, по­па­дёт в мас­сив A. Сле­до­ва­тель­но, в слу­чае ра­вен­ства эле­мент из мас­си­ва A дол­жен иметь при­о­ри­тет. По­это­му в ал­го­рит­ме стои́т знак  вме­сто при срав­не­нии эле­мен­тов.

Не­до­стат­ком пред­став­лен­но­го ал­го­рит­ма яв­ля­ет­ся не­об­хо­ди­мость до­пи­сы­вать остав­ший­ся ку­сок, из-за че­го при даль­ней­ших мо­дифи­ка­ци­ях ал­го­рит­ма нам при­дёт­ся пи­сать мно­го по­вто­ряю­ще­го­ся ко­да. Что­бы это­го из­бе­жать, бу­дем ис­поль­зо­вать чуть ме­нее эф­фек­тив­ный, но бо­лее ко­рот­кий ал­го­ритм, в ко­то­ром ко­пи­ро­ва­ние «хво­ста» встрое­но в ос­нов­ной цикл:

(2)

Оче­вид­но, вре­мя ра­бо­ты про­це­ду­ры слия­ния со­став­ля­ет . При­мер ра­бо­ты про­це­ду­ры по­ка­зан на ри­сун­ке:

Реа­ли­за­ция про­це­ду­ры слия­ния на язы­ке про­грам­ми­ро­ва­ния C++ пред­став­ле­на в ли­стин­ге 1.

Сор­ти­ров­ка слия­ни­ем

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

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

Про­ще все­го фор­ма­ли­зо­вать этот ал­го­ритм ре­кур­сив­ным спо­со­бом (в сле­дую­щем раз­де­ле мы реа­ли­зу­ем этот ал­го­ритм ите­ра­ци­он­ным спо­со­бом). Функ­ция  сор­ти­ру­ет уча­сток мас­си­ва от эле­мен­та с но­ме­ром a до эле­мен­та с но­ме­ром b:

(3)

По­сколь­ку функ­ция  сор­ти­ру­ет лишь часть мас­си­ва, то при слия­нии двух фраг­мен­тов ей не оста­ёт­ся ни­че­го, кро­ме как вы­де­лять вре­мен­ный бу­фер для ре­зуль­та­та слия­ния, а за­тем ко­пи­ро­вать дан­ные об­рат­но:

Вре­мя ра­бо­ты сор­ти­ров­ки слия­ни­ем со­став­ля­ет . При­мер ра­бо­ты про­це­ду­ры по­ка­зан на ри­сун­ке:

Вос­хо­дя­щая сор­ти­ров­ка слия­ни­ем

Про­грам­ма, пред­став­лен­ная в ли­стин­ге 2, име­ет се­рьёз­ные не­до­стат­ки: она вы­де­ля­ет и осво­бож­да­ет мно­го бу­фе­ров па­мя­ти, и де­ла­ет ко­пи­ро­ва­ние ре­зуль­та­тов слия­ния в ис­ход­ный мас­сив вме­сто то­го, что­бы вер­нуть но­вый мас­сив в ка­че­стве ре­зуль­та­та (она не мо­жет вер­нуть но­вый мас­сив в ка­че­стве ре­зуль­та­та, т.к. на вхо­де по­лу­ча­ет за­ча­стую лишь часть боль­шо­го мас­си­ва).

Что­бы из­ба­вить­ся от этих не­до­стат­ков, от­ка­жем­ся от ре­кур­сив­ной реа­ли­за­ции, и сде­ла­ем сор­ти­ров­ку сле­дую­щим об­ра­зом:

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

Та­кой ал­го­ритм на­зы­ва­ет­ся вос­хо­дя­щей сор­ти­ров­кой слия­ни­ем. Реа­ли­за­ция его на язы­ке про­грам­ми­ро­ва­ния C++ при­ве­де­на в ли­стин­ге 3.

К со­жа­ле­нию, в этот ал­го­ритм не так про­сто впи­сать оп­ти­ми­за­цию для слу­чая слия­ния двух эле­мен­тов (ес­ли нуж­но, мож­но впи­сать эту оп­ти­ми­за­цию в про­це­ду­ру Merge).

При­мер ра­бо­ты про­грам­мы ли­стин­га 3 по­ка­зан на ри­сун­ке:

Ес­ли тре­бу­ет­ся вы­пол­нять вос­хо­дя­щую сор­ти­ров­ку для ча­сти мас­си­ва, или в дру­гих слу­ча­ях, ко­гда ука­затель на мас­сив ме­нять нель­зя, то бу­дет по­лез­ной мо­дифи­ка­ция про­грам­мы, ко­то­рая, ес­ли нуж­но, ко­пи­ру­ет ре­зуль­тат в ис­ход­ный мас­сив в кон­це ра­бо­ты:

Из­ме­ре­ние быст­ро­дей­ствия ал­го­рит­ма

Из­ме­рим быст­ро­дей­ствие про­грам­мы из ли­стин­га 3. Усло­вия из­ме­ре­ния — те же, что для ал­го­рит­ма пи­ра­ми­даль­ной сор­ти­ров­ки (см. лек­цию 5).

На рис. 4 по­ка­зан гра­фик ве­ли­чи­ны , опре­де­ля­е­мой вы­ра­же­ни­ем:

(4)

где n — ко­ли­че­ство сор­ти­руе­мых псев­до­слу­чай­ных че­ты­рёх­бай­то­вых це­лых чи­сел, — вре­мя сор­ти­ров­ки на мо­ём ком­пью­те­ре.

На гра­фи­ке про­яв­ля­ют­ся две важ­ные осо­бен­но­сти ал­го­рит­ма:

1. Сор­ти­ров­ка слия­ни­ем ра­бо­та­ет в пол­то­ра-два ра­за мед­лен­нее, чем пи­ра­ми­даль­ная сор­ти­ров­ка, ко­гда чис­ло сор­ти­руе­мых эле­мен­тов мень­ше 500. Так как ал­го­ритм сор­ти­ров­ки слия­ни­ем ре­кур­сив­ный, эта по­те­ря быст­ро­дей­ствия на сор­ти­ров­ке ма­лых мас­си­вов от­ра­жа­ет­ся на всём осталь­ном гра­фи­ке. Ес­ли мы смо­жем уско­рить ал­го­ритм для сор­ти­ров­ки ма­лых объ­ё­мов дан­ных — мы смо­жем уско­рить его для сор­ти­ров­ки лю­бых объ­ё­мов дан­ных.
2. Ско­рость сор­ти­ров­ки не па­да­ет, ко­гда ко­ли­че­ство сор­ти­руе­мых дан­ных ста­но­вит­ся боль­ше раз­ме­ра ке­ша! Это озна­ча­ет, что имен­но сор­ти­ров­ку слия­ни­ем сле­ду­ет ис­поль­зо­вать для сор­ти­ров­ки боль­ших объ­ё­мов дан­ных.

Ги­брид­ная сор­ти­ров­ка

Ана­лиз быст­ро­дей­ствия ал­го­рит­ма на­тал­ки­ва­ет нас на мысль объ­еди­нить пре­иму­ще­ства ал­го­рит­мов пи­ра­ми­даль­ной сор­ти­ров­ки и сор­ти­ров­ки слия­ни­ем. К сча­стью, сде­лать это очень про­сто: нуж­но раз­бить мас­сив сра­зу на боль­шие ку­соч­ки (на­при­мер, раз­ме­ром 512 эле­мен­тов), и при­ме­нить к ним ал­го­ритм пи­ра­ми­даль­ной сор­ти­ров­ки. По­лу­чен­ные от­сор­ти­ро­ван­ные ку­соч­ки за­тем мож­но «до­сор­ти­ро­вать» слия­ни­ем. Ис­поль­зуя функ­ции из лек­ции 5, тре­буе­мые из­ме­не­ния в ал­го­рит­ме ми­ни­маль­ны (за ос­но­ву взя­та функ­ция из ли­стин­га 3):

Быст­ро­дей­ствие ги­брид­ной сор­ти­ров­ки по­ка­за­но на гра­фи­ке:

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

Tiled-вер­сия

Tile пе­ре­во­дит­ся, как «че­ре­пи­ца», «плит­ка». При­ём про­грам­ми­ро­ва­ния, при ко­то­ром боль­шие объё­мы дан­ных раз­де­ля­ют­ся для об­ра­бот­ки и хра­не­ния на ча­сти мень­ше­го раз­ме­ра («tiles»), на­зы­ва­ет­ся «tiling». Вме­сто «tile» мы бу­дем го­во­рить «блок».

Ос­нов­ным не­до­стат­ком пред­став­лен­ных до сих пор реа­ли­за­ций сор­ти­ров­ки слия­ни­ем яв­ля­ет­ся не­об­хо­ди­мость иметь  байт опе­ра­тив­ной па­мя­ти для сор­ти­ров­ки N байт дан­ных. Са­мый про­стой спо­соб спра­вить­ся с этим — ра­бо­тать со свя­зан­ны­ми спис­ка­ми эле­мен­тов. При слия­нии двух спис­ков нуж­но пе­ре­но­сить эле­мен­ты из на­ча­ла ис­ход­ных спис­ков в ко­нец ре­зуль­ти­рую­ще­го спис­ка. При этом до­пол­ни­тель­ная па­мять для хра­не­ния про­ме­жу­точ­ных ре­зуль­та­тов не по­тре­бу­ет­ся.

Но свя­зан­ные спис­ки име­ют боль­шие на­клад­ные рас­хо­ды по па­мя­ти и быст­ро­дей­ствию: в каж­дом эле­мен­те тре­бу­ет­ся хра­нить ука­затель на сле­дую­щий эле­мент, тре­бу­ет­ся вре­мя на со­зда­ние и уни­что­же­ние эле­мен­тов спис­ка. Что­бы умень­шить на­клад­ные рас­хо­ды, нуж­но хра­нить боль­шое ко­ли­че­ство сор­ти­руе­мых дан­ных в каж­дом эле­мен­те спис­ка.

Свя­зан­ные спис­ки не поз­во­ля­ют быст­ро об­ра­щать­ся к про­из­воль­ным эле­мен­там, по­это­му мы пой­дём не­мно­го дру­гим пу­тём: бу­дем хра­нить мас­сив ука­за­те­лей на бло­ки па­мя­ти боль­шо­го раз­ме­ра (но уме­щаю­щие­ся в кэш про­цес­со­ра). Та­кая ст­рук­ту­ра дан­ных бы­ла опи­са­на в лек­ции 4 (раз­дел «Про­грамм­ная реа­ли­за­ция ал­го­рит­ма Гаус­са»).

Про­це­ду­ра слия­ния бу­дет осво­бож­дать об­ра­бо­тан­ные бло­ки па­мя­ти, и вы­де­лять но­вые по ме­ре за­пи­си ре­зуль­та­та. В этом слу­чае мак­си­маль­ный до­пол­ни­тель­ный объ­ём па­мя­ти, ко­то­рый по­на­до­бит­ся, ра­вен дву­крат­но­му раз­ме­ру бло­ка па­мя­ти. Кро­ме то­го, ука­за­те­ли на ре­зуль­ти­рую­щие бло­ки па­мя­ти по­сле слия­ния мож­но лег­ко пе­ре­не­сти в ис­ход­ный бу­фер. Для про­сто­ты бу­дем счи­тать, что все бло­ки, на ко­то­рые раз­бит ис­ход­ный мас­сив име­ют оди­на­ко­вый раз­мер: tileSize эле­мен­тов.

Так как про­це­ду­ра слия­ния воз­вра­ща­ет ре­зуль­тат сво­ей ра­бо­ты в ис­ход­ный мас­сив, нет не­об­хо­ди­мо­сти за­во­дить вто­рой бу­фер в про­це­ду­ре сор­ти­ров­ки, ко­то­рая бла­го­да­ря это­му упро­ща­ет­ся. Дан­ные внут­ри бло­ка в дан­ном при­ме­ре сор­ти­ру­ют­ся пи­ра­ми­даль­ной сор­ти­ров­кой, по­это­му этот ал­го­ритм то­же мож­но на­звать «ги­брид­ным»:

Чем боль­ше по раз­ме­рам бу­дет каж­дый блок па­мя­ти, тем мень­ше бу­дут на­клад­ные рас­хо­ды на ра­бо­ту с бло­ка­ми. Од­на­ко, при боль­шом раз­ме­ре бло­ков воз­рас­та­ют тре­бо­ва­ния к до­пол­ни­тель­но­му объ­ё­му па­мя­ти, тре­бу­е­мо­му про­грам­мой. Гра­фик ско­ро­сти ра­бо­ты про­грам­мы пред­став­лен на ри­сун­ке 6. Объ­ём од­но­го бло­ка был вы­бран рав­ным од­но­му ме­га­бай­ту, по­это­му гра­фик на­чи­на­ет­ся с 262144 эле­мен­тов:

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

Ес­те­ствен­ная сор­ти­ров­ка

До сих пор мы рас­смат­ри­ва­ли ал­го­рит­мы сор­ти­ров­ки, ко­то­рые ни­как не учи­ты­ва­ют то, что дан­ные (или их часть) мо­гут быть уже от­сор­ти­ро­ва­ны. Для ал­го­рит­ма сор­ти­ров­ки слия­ни­ем есть очень про­стая и эф­фек­тив­ная мо­дифи­ка­ция, ко­то­рая на­зы­ва­ет­ся «ес­те­ствен­ная сор­ти­ров­ка» («Natural Sort»). Суть её в том, что нуж­но об­ра­зо­вы­вать це­поч­ки, и про­из­во­дить их слия­ние не в за­ра­нее опре­де­лён­ном и фик­си­ро­ван­ном по­ряд­ке, а ана­ли­зи­ро­вать имею­щие­ся в мас­си­ве дан­ные. Ал­го­ритм сле­дую­щий:

1. раз­бить мас­сив на це­поч­ки уже от­сор­ти­ро­ван­ных эле­мен­тов (в худ­шем слу­чае, ко­гда эле­мен­ты в мас­си­ве идут по убы­ва­нию, все це­поч­ки бу­дут со­сто­ять из од­но­го эле­мен­та);
2. про­из­ве­сти слия­ние це­по­чек ме­то­дом сдваи­ва­ния.

При­мер ра­бо­ты это­го ал­го­рит­ма по­ка­зан на ри­сун­ке:

В от­ли­чие от ра­нее рас­смот­рен­ных ва­ри­ан­тов ал­го­рит­ма слия­ния, ес­те­ствен­ная сор­ти­ров­ка спра­ви­лась с за­да­чей за 3, а не за 4 ите­ра­ции.

Об­ра­ти­те вни­ма­ние, что во вре­мя ра­бо­ты ал­го­рит­ма не мо­гут об­ра­зо­вать­ся но­вые от­сор­ти­ро­ван­ные це­поч­ки кро­ме по­лу­чив­ших­ся в ре­зуль­та­те слия­ний (до­ка­жи­те!), по­это­му по­иск от­сор­ти­ро­ван­ных це­по­чек дол­жен про­во­дить­ся толь­ко на пер­вом эта­пе. Но как хра­нить най­ден­ные це­поч­ки? Вы­де­лять для них па­мять — очень не­эф­фек­тив­но. Са­мый про­стой спо­соб — во­об­ще их не хра­нить, а ис­кать каж­дый раз за­но­во. Это не­эф­фек­тив­но, за­то про­сто: