- •Алгоритмы поиска и сортировки. Сортировки: выбором, обменом, вставкой. Анализ сложности алгоритмов на примере сортировок. Простой и бинарный поиск.
- •Оценка алгоритмов сортировки
- •Классификация алгоритмов сортировок
- •Сортировка выбором
- •Void selectSort(t* arr, int size)
- •Сортировка пузырьковым всплытием (обменом)
- •Void bubbleSort(t* arr, int size)
- •If(pr) break;
- •Шейкерная (перемешиванием) сортировка
- •Void ShakerSort(t* arr, int start, int n)
- •Int left, right, I;
- •Сортировка вставками
- •Void insertSort(t* a, int size)
- •// Поиск места элемента в готовой последовательности
- •Быстрая сортировка
- •Рассмотрим алгоритм подробнее.
- •Общий алгоритм
- •Void quickSortR(t* a, long n) {
- •Модификации кода и метода
- •Void qsortR(t *a, long size) {
- •InsertSort(a, size);
- •Итеративная QuickSort
- •Void qSortI(t a[], long size)
- •Сортировка слиянием
- •Void Merging_Sort (t *a, int n){
- •Сортировка методом Шелла
- •Void Shell_Sort (t *a, int n)
- •Алгоритмы поисков в массивах
- •Линейный поиск (поиск в лоб) в массивах
- •Двоичный поиск (дихотомия)
Классификация алгоритмов сортировок
Все разнообразие и многообразие алгоритмов сортировок можно классифицировать по различным признакам, например, по устойчивости, по поведению, по использованию операций сравнения, по потребности в дополнительной памяти, по потребности в знаниях о структуре данных, выходящих за рамки операции сравнения, и другие.
Наиболее подробно рассмотрим классификацию алгоритмов сортировки по сфере применения. В данном случае основные типы упорядочивания делятся следующим образом.
Внутренняя сортировка – это алгоритм сортировки, который в процессе упорядочивания данных использует только оперативную память компьютера. То есть оперативной памяти достаточно для помещения в нее сортируемого массива данных с произвольным доступом к любой ячейке и, собственно, для выполнения алгоритма. В зависимости от конкретного алгоритма и его реализации данные могут сортироваться в той же области памяти, либо использовать дополнительную оперативную память.
Внешняя сортировка – это алгоритм сортировки, который при проведении упорядочивания данных использует внешнюю память, как правило, жесткие диски. Внешняя сортировка разработана для обработки больших списков данных, для сортировки которых не рационально использовать только оперативную память. Обращение к различным носителям накладывает некоторые дополнительные ограничения на данный алгоритм. Доступ к носителю осуществляется последовательным образом, то есть в каждый момент времени можно считать или записать только элемент, следующий за текущим.
Внутренняя сортировка является базовой для любого алгоритма внешней сортировки. Следует отметить, что внутренняя сортировка значительно эффективней внешней, так как на обращение к оперативной памяти затрачивается намного меньше времени, чем на обращение к носителям.
Методы сортировки
включением
распределением
обменамии
слиянием
выборкой
подсчетом
Быстрая (Хоара)
пузырькового
всплытия
древесная
простым
выбором
Шелла
простым
включением
Рассмотрим некоторые алгоритмы внутренних сортировок.
Начнем с методов простых для понимания и надежных для реализации: простого включения, простого выбора и пузырькового всплытия. Все они сравнительно неэффективны, их среднее время исполнения пропорционально квадрату числа сортируемых элементов O(n2). Когда n не велико, они могут оказаться достаточно эффективными.
Сортировка выбором
Идея метода состоит в том, чтобы создавать отсортированную последовательность путем присоединения к ней одного элемента за другим в правильном порядке. Если входная последовательность почти упорядочена, то сравнений будет столько же, значит, алгоритм ведет себя неестественно.
//-------------------------------------------------------------------------------------------
template< class T >
Void selectSort(t* arr, int size)
{
T tmp;
for(int i = 0; i < size; ++i) // i - номер текущего шага
{
int pos = i;
for(int j = i + 1; j < size; ++j) // цикл выбора индекса наименьшего
// элемента
if (arr[j] < arr[pos]) pos = j;
tmp=arr[pos];
arr[pos] = arr[i];
arr[i] = tmp; // меняем местами наименьший с arr[i]
}
}
//----------------------------------------------------------------------------------------------
