Void SortBubble (int count, int* pArr)
{
int trash = 0;
for (int i = 0; i < count; i++) // i - номер прохода
{
for (int j=0; j < count-i-1; j++) // внутренний цикл прохода
{
if (pArr[j] > pArr[j+1]) //если "левый" больше "правого"
{
trash = pArr[j]; //меняем местами элементы
pArr[j] = pArr[j+1];
pArr[j+1] = trash;
}
}
}
}
Сортировка
выбором
Сортировка выбором выполняется несколько быстрее, чем сортировка методом пузырька. Алгоритм заключается в следующем: нужно найти элемент массива, имеющий наименьшее значение, переставить его с первым элементом, затем проделать тоже самое, начав со второго элемента и т.д. Таким образом, создается отсортированная последовательность путем присоединения к ней одного элемента за другим в правильном порядке. На i-м шаге выбирается наименьший из элементов a[i] ... a[n] и меняем его местами с a[i]. Последовательность шагов изображена на рис.38.
Исходный массив
16 6 6 20 2 19 13 6 3 3
№ шага
1: 2 6 6 20 16 19 13 6 3 3
2: 2 3 6 20 16 19 13 6 6 3
3: 2 3 3 20 16 19 13 6 6 6
4: 2 3 3 6 16 19 13 20 6 6
5: 2 3 3 6 6 19 13 20 16 6
6: 2 3 3 6 6 6 13 20 16 19
7: 2 3 3 6 6 6 13 20 16 19
8: 2 3 3 6 6 6 13 16 20 19
9: 2 3 3 6 6 6 13 16 19 20
10: 2 3 3 6 6 6 13 16 19 20
Результат
2 3 3 6 6 6 13 16 19 20
Рис. 38. Результат сортировки выбором
Вне зависимости от номера текущего шага i, последовательность a[0]...a[i] является упорядоченной. Таким образом, на (n-1)-м шаге вся последовательность, кроме a[n] оказывается отсортированной, а a[n] стоит на последнем месте по праву: все меньшие элементы уже ушли влево.
//процедура сортировки выбором
Void SortSelect(int count, int* pArr)
{
Int i1,temp;
Int jmax;
for (int i = count - 1; i > 0; i--) // i - номер текущего шага
{
jmax = 0;
for (int j = 0; j <= i; j++)
{
if (pArr [jmax] < pArr [j]) i1 = j;
}
temp = pArr [i1];
pArr [i1] = pArr [i];
pArr [i] = temp;
}}
Сортировка
простыми вставками
Просматривается массив и каждый новый элемент a[i] вставляется на подходящее место в уже упорядоченную совокупность a[1],...,a[i-1]. Это место определяется последовательным сравнением a[i] с упорядоченными элементами a[1],...,a[i-1]. Таким образом в начале массива "вырастает" отсортированная последовательность.
Однако в сортировке пузырьком или выбором можно было четко заявить, что на i-м шаге элементы a[1]...a[i-1]стоят на правильных местах и никуда более не переместятся. Здесь же подобное утверждение будет более слабым: последовательность a[1]...a[i-1] упорядочена. При этом по ходу алгоритма в нее будут вставляться (см. название метода) все новые элементы.
Рассмотрим действия алгоритма на i-м шаге. Как говорилось выше, последовательность к этому моменту разделена на две части: готовую a[1]...a[i-1] и неупорядоченную a[i]...a[n].
На следующем, i-м каждом шаге алгоритма берем a[i] и вставляем на нужное место в готовую часть массива. Поиск подходящего места для очередного элемента входной последовательности осуществляется путем последовательных сравнений с элементом, стоящим перед ним. В зависимости от результата сравнения элемент либо остается на текущем месте (вставка завершена), либо они меняются местами и процесс повторяется (рис.39).
Таким образом, в процессе вставки мы "просеиваем" элемент X к началу массива, останавливаясь в случае, когда
1. Hайден элемент, меньший X.
2. Достигнуто начало последовательности.
Исходный массив
№ шага
2:
12 16 10 9 10 9 9 11 10 11
3:
10 12 16 9 10 9 9 11 10 11
4:
9 10 12 16 10 9 9 11 10 11
5:
9 10 10 12 16 9 9 11 10 11
6:
9 9 10 10 12 16 9 11 10 11
7:
9 9 9 10 10 12 16 11 10 11
8:
9 9 9 10 10 11 12 16 10 11
9:
9 9 9 10 10 10 11 12 16 11
10: 9 9 9 10 10 10 11 11 12 16
Результат
9 9 9 10 10 10 11 11 12 16
Рис. 39. Сортировка массива простыми вставками
//процедура сортировки простыми вставками