Прізвище: Бойко

Ім'я: Назарій
Група: КН-106
Варіант: 2
Дата захисту:28.04.2020р.

Кафедра: САПР
Дисципліна: Алгоритмізація та програмування. Ч.2
Перевірив: Андрійчук М. І.

ЗВІТ
до лабораторної роботи №10
на тему "Алгоритми сортування"

Мета роботи: Вивчення та практична реалізація алгоритмів сортування.

Відповіді на контрольні запитання:

1. Що таке алгоритм?
Набір інструкцій, які описують порядок дій виконавця, щоб досягти
результату розв'язання задачі за скінченну кількість дій
2. Що таке сортування?
Розміщення у визначеному порядку, упорядкування, класифікація чого-
небудь.
3. Для чого використовуються алгоритми сортування?
Алгоритм розв'язує задачу сортування, тобто здійснює впорядкування
лінійного списку (масиву) елементів.
4. Які основні характеристики алгоритмів сортування?
a. Час, необхідний на впорядкування n-елементного масиву.
b. Необхідність додаткової пам'яті для сортування.
c. Стабільність
5. Переваги та недоліки запропонованих Вам методів сортування.
a. Бульбашкове сортування
Даний алгоритм має низьку ефективність у випадках, коли N є
досить великим, за винятком рідкісних конкретних випадків, коли
заздалегідь відомо, що масив з самого початку буде добре відсортований.
b. Пірамідальне сортування
c. Сортування комірками
d. Коктейльне сортування
6. Що таке ефективність алгоритму сортування?
Це властивість алгоритму, пов'язана з обчислювальними ресурсами,
використовуваними алгоритмом.
7. Прямі та швидкі методи сортування.
Прямий метод відповідно провіряє кожен елемент у масиві. Швидкі
методи розподіляють масив на декілька частин таким чином проводять
найефективніше обчислення.
8. Що таке швидкодія алгоритму?
Швидкодія алгоритму визначається часом виконання операторів і
глибиною алгоритму. Стосовно до алгоритмів, описуваних за допомогою
 регулярних виразів, глибиною алгоритму є максимальна кількість умов, які
необхідно перевірити в процесі роботи алгоритму

Індивідуальне завдання :
1. Сортування бульбашкою
2. Пірамідальне сортування
3. Сортування комірками
4. Коктейльне сортування

Розв’язок:
Завдання 1. Сортування бульбашкою
/*Бульбашкове сортування*/

#include <iostream>
#include <Windows.h>
using namespace std;

int* fillArray(int* arr, int n); // Функція заповнення масива

int* bubblesort(int* arr, int n); // Метод сортування
void showArray(int* arr, int size); // Функція виведення масива

int main()
{
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
int size = 1;
cout << "Введіть кількість елементі в масиві\nКількість елементів = ";
cin >> size;
int *arr = new int[size];
fillArray(arr, size);
bubblesort(arr, size);
cout << "\nВідсортований масив:" << endl;
showArray(arr, size);
delete[] arr;
return 0;
}
int* fillArray(int* arr, int n)
{
for (int i = 0; i < n; i++)
{
cout << "arr[" << i << "] = ";
cin >> arr[i];
}

return arr;
}

int* bubblesort(int* arr, int n) {

bool stop = false;
int tmp, check = 0;
while (!stop) {
for (int i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
tmp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = tmp;
check++;
}
}
if (check == 0)
 stop = true;
check = 0;
}
return arr;
}

void showArray(int* arr, int n) {

for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}

Завдання 2. Пірамідальне сортування

#include <iostream>
#include <Windows.h>

using namespace std;

int *heapify(int *arr, int n, int i)

{
int largest = i;
// Ініціалізуємо найбільший елемент як корінь
int l = 2 * i + 1; // лівий = 2*i + 1
int r = 2 * i + 2; // правий = 2*i + 2

// Якщо лівий дочірній елемент більший за корінь

if (l < n && arr[l] > arr[largest])
largest = l;

// Якщо правий дочірній елемент більший за найбільше значення

if (r < n && arr[r] > arr[largest])
largest = r;

// Якщо найбільший елемент не корінь

if (largest != i)
{
swap(arr[i], arr[largest]);

// Рекурсивно преобразовуємо в двійкове дерево

heapify(arr, n, largest);
}
return arr;
}

// Основна функція сортування

int *heapSort(int *arr, int n)
{
// Побудова кучі
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);

// Один за другим достаємо елементи з кучі

for (int i = n - 1; i >= 0; i--)
{
// Переміщуємо корінь в кінець
swap(arr[0], arr[i]);

// Визиваємо функцію в новому дереві

heapify(arr, i, 0);
}
return arr;
}
// Вивід на екран
void printArray(int *arr, int n)
{
for (int i = 0; i < n; ++i)
cout << arr[i] << " ";
cout << "\n";
}

int *getArray(int arr[], int n)

{
for (int i = 0; i < n; ++i) {
cout << "arr[" << i << "] = ";
cin >> arr[i];
}
return arr;
}
int main()
{
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
int N;
cout << "Введіть довжину масива = ";
cin >> N;
int *arr = new int[N];
getArray(arr, N);
heapSort(arr, N);
cout << "Відсортований масив: \n";
printArray(arr, N);
}

Завдання №3. Сортування комірками

#include <iostream>
#include <Windows.h>
#include <cmath>

using namespace std;

struct Node {
int value = 0;
Node* next = nullptr;
};

int* bucketSort(int* arr, int n);

int* fillArray(int* arr, int N);
void printArray(int* arr, int N);
Node* sort(Node*& buck);
Node* pushback(Node*& buck, int value);
int* getValue(Node*& buck);
int* bubblesort(int* arr, int N);
int* getList(int* arr, int& N, Node* buck);

int main()
{
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
cout << "Введіть довжину масиву = ";
int N;
cin >> N;
int* arr = new int[N];
fillArray(arr, N);
bucketSort(arr, N);
cout << "Відсортований масив: \n";
 printArray(arr, N);
return 0;
}

int* bucketSort(int *arr, int N)

{
Node *arrs[10];
for (int i = 0; i < 10; i++)
arrs[i] = NULL;
for (int i = 0; i < N; i++) {
int arg = arr[i] / 10;
pushback(arrs[arg], arr[i]);
}
int count = 0;
while (count != 10) {
sort(arrs[count]);
count++;
}
count = 0;
int fullarr = 0;
for (int i = 0; i < 10; i++)
if (arrs[i] != NULL)
getList(arr, fullarr, arrs[i]);
return arr;
}

int* fillArray(int* arr, int N) {

for (int i = 0; i < N; i++) {
cout << "arr[" << i << "] = ";
cin >> arr[i];
while (arr[i] > 99)
cin >> arr[i];
cout << endl;
}
return arr;
}

void printArray(int* arr, int N) {

for (int i = 0; i < N; i++)
cout << arr[i] << " ";
}

Node* sort(Node*& buck) {

Node* tail = buck;
int number = 0;
if (tail != NULL) {
while (tail != NULL) {
number++;
tail = tail->next;
}
tail = buck;
int* list = new int[number];
int i = 0;
while (tail != NULL) {
list[i] = tail->value;
i++;
tail = tail->next;
}
bubblesort(list, number);
Node* tmp = NULL;
for (int i = 0; i < number; i++)
pushback(tmp, list[i]);
 buck = tmp;
}
return buck;
}
Node* pushback(Node*& buck, int value) {
Node* temp = new Node;
temp->value = value;
temp->next = nullptr;
if (buck == nullptr)
buck = temp;
else
{
Node* tail = buck;
while (tail->next != nullptr)
tail = tail->next;
tail->next = new Node;
tail->next->value = value;
tail->next->next = nullptr;
}
return buck;
}

int* getList(int *arr, int &N, Node* buck)

{
if (buck != NULL) {
Node* tail = buck;
while (tail != NULL) {
arr[N] = tail->value;
N++;
tail = tail->next;
}
}
return arr;
}

int* bubblesort(int* arr, int N) {

bool stop = false;
int tmp, check = 0;
while (!stop) {
for (int i = 0; i < N - 1; i++) {
if (arr[i] > arr[i + 1]) {
tmp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = tmp;
check++;
}
}
if (check == 0)
stop = true;
check = 0;
}
return arr;
}
Завдання 4. Коктейльне сортування
#include <iostream>
#include <algorithm>
#include <Windows.h>

using namespace std;

int* CocktailSort(int *a, int n)

{
bool swapped = true;
int start = 0;
int end = n - 1;

while (swapped)
{
swapped = false;
for (int i = start; i < end; ++i)
{
if (a[i] > a[i + 1]) {
swap(a[i], a[i + 1]);
swapped = true;
}
}

if (!swapped)
break;
//swapped = false;
--end;

for (int i = end - 1; i >= start; --i)

{
if (a[i] > a[i + 1]) {
swap(a[i], a[i + 1]);
swapped = true;
}
}
++start;
}
return a;
}

int* fillArray(int* arr, int n) {

for (int i = 0; i < n; i++) {
cout << "arr[" << i << "] = ";
cin >> arr[i];
cout << endl;
}
return arr;
}

void printArray(int* a, int n) {

for (int i = 0; i < n; i++)
cout << a[i] << " ";
}

// Driver code
int main()
{
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
cout << "Введіть довжину масиву = ";
int N;
cin >> N;
int* arr = new int[N];
fillArray(arr, N);
CocktailSort(arr, N);
cout << "Відсортований масив: \n";
printArray(arr, N);
return 0;
}
Результати виконання роботи:

Рис.1. Сортування бульбашкою

Рис.2. Пірамідальне сортування

Рис.3. Сортування комірками

 Рис.4. Коктейльне сортування

Аналіз результатів: було реалізовано 4 різні методи сортування: бульбашкове,

пірамідальне, комірками та коктейльне.
1. Бульбашкове сортування: Ідея методу: крок сортування полягає в проході
знизу вверх по масиву. У процесі просування по масиве порівнюємо пари
сусідніх елементів. Якщо елементи деякої пари знаходяться в неправильному
порядку, то міняємо їх місцями.
2. Пірамідальне сортування: Його ідея полягає у тому, що замість повного
дерева порівняння початковий масив а[1], а[2], ..., а[n] перетвориться на
піраміду, що має таку властивість, що для кожного а[і] виконуються умови
а[і]<= а[2і] і а[і]<= а[2і+1]. Потім піраміда використовується для сортування.
3. Сортування комірками: Алгоритм сортування, в якому сортовані елементи
розподіляються між кінцевим числом окремих блоків (кишень, кошиків) так,
щоб всі елементи в кожному наступному по порядку блоці були завжди більше
(або менше ), ніж у попередньому. Кожен блок потім сортується окремо, або
рекурсивно тим же методом, або іншим. Потім елементи поміщаються назад в
масив.
4. Коктейльне сортування: Виробляється багаторазовий прогін по масиву,
сусідні елементи порівнюються і, коли лівий елемент більший за правий,
міняються місцями. При досягненні кінця масиву напрямок змінюється на
протилежний. Таким чином по черзі виштовхуються великі і дрібні елементи
масиву в кінець і початок структури відповідно.

Висновок: в результаті виконання лабораторної роботи було реалізовано 4 різні методи

сортування: бульбашкове, пірамідальне, комірками та коктейльне сортування.