4. Выбор, вставка, пузырьки и Шелла

Сортировка вставками (англ. insertion sort) — простой алгоритм сортировки. Хотя этот метод сортировки намного менее эффективен чем более сложные алгоритмы (такие как быстрая сортировка), у него есть ряд преимуществ:

прост в реализации

эффективен на небольших наборах данных

эффективен на наборах данных, которые уже частично отсортированы

это устойчивый алгоритм сортировки (не меняет порядок элементов, которые уже отсортированы)

может сортировать список по мере его получения

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

Cортировка выбором (англ. selection sort) — алгоритм сортировки, относящийся к неустойчивым алгоритмам сортировки. На массиве из n элементов имеет время выполнения в худшем, среднем и лучшем случае Θ(n²), предполагая что сравнения делаются за постоянное время.

Шаги алгоритма:

находим минимальное значение в текущем списке

производим обмен этого значения со значением на первой позиции

теперь сортируем хвост списка, исключив из рассмотрения уже отсортированный первый элемент

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

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

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

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

public static void selectionSort (int[] numbers)

{

int min, temp;

for (int index = 0; index < numbers.length-1; index++)

{

min = index;

for (int scan = index+1; scan < numbers.length; scan++)

if (numbers[scan] < numbers[min])

min = scan;

// Swap the values

temp = numbers[min];

numbers[min] = numbers[index];

numbers[index] = temp;

}

}

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

public static int findMin(int[] array, int index) {

int min = index - 1;

if(index < array.length - 1) min = findMin(array, index + 1);

if(array[index] < array[min]) min = index;

return min;

}

public static void selectionSort(int[] array) {

selectionSort(array, 0);

}

public static void selectionSort(int[] array, int left) {

if (left < array.length - 1) {

swap(array, left, findMin(array, left));

selectionSort(array, left+1);

}

}

public static void swap(int[] array, int index1, int index2) {

int temp = array[index1];

array[index1] = array[index2];

array[index2] = temp;

}

Сортировка простыми обменами, сортиро́вка пузырько́м (англ. bubble sort) — простой алгоритм сортировки. Для понимания и реализации этот алгоритм — простейший, но эффективен он лишь для небольших массивов. Сложность алгоритма: O(n²).

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

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

void swap(int[] arr, int i, int j) { int t = arr[i]; arr[i] = arr[j]; arr[j] = t; }

void bubblesort(int[] arr)

{

for(int i = arr.length-1 ; i >= 0 ; i--)

for(int j = 0 ; j < i ; j++)

if( arr[j] > arr[j+1] ) swap(arr, j, j+1);

}

Сортировка Шелла (англ. Shell sort) — алгоритм сортировки, идея которого состоит в сравнении элементов, стоящих не только рядом, но и на расстоянии друг от друга.

При сортировке Шелла сначала сравниваются и сортируются между собой ключи, отстоящие один от другого на некотором расстоянии d. После этого процедура повторяется для некоторых меньших значений d, а завершается сортировка Шелла упорядочиванием элементов при d = 1 (то есть, обычной сортировкой вставками. Эффективность сортировки Шелла в определённых случаях обеспечивается тем, что элементы «быстрее» встают на свои места (в простых методах сортировки вставками или пузырьком (но она не предпочтительна, так как все равно остается медленной) каждая перестановка двух элементов уменьшает количество инверсий в списке максимум на 1, при сортировке Шелла же это число может быть больше).

void sort_shell(int[] a)

{ int i, j, k, h, m=0, b=a.length;

int[] d = { 1, 4, 10, 23, 57, 145, 356, 911, 1968, 4711, 11969, 27901,

84801, 213331, 543749, 1355339, 3501671, 8810089, 21521774,

58548857, 157840433, 410151271, 1131376761, 2147483647 };

while (d[m] < b)

++m;

while (--m >= 0)

{ k = d[m];

for (i=k; i<b; i++) // k-сортировка

{ j=i;

h=a[i];

while ((j >= k) && (a[j-k] > h))

{ a[j]=a[j-k];

j = j-k;

}

a[j] = h;

}

}

}