Національний технічний університет України

«Київський політехнічний інститут імені Ігоря Сікорського»

Навчально-науковий інститут атомної і теплової енергетики
Кафедра цифрових технологій в енергетиці

Проектування та аналіз обчислювальних

алгоритмів

ЗВІТ ДО
КОМП’ЮТЕРНОГО ПРАКТИКУМУ № 12

«Методи сортування масиві»

Варіант № 12

Виконав: студент 2-го курсу

гр. ТР-13
Куликовський Владислав Геннадійович

Оцінка _________ Перевірив: _____________

Дата «24» жовтня 2022 _______________________

Київ – 2022
 Завдання до роботи:
У якості індивідуального завдання необхідно написати програмний
код, у якому реалізується сортування масиву методами бульбашки, вставок,
вибору, сортуванням Шелла, Гоара (швидкого сортування). Виконати
порівняння ефективності вказаних методів сортування (розрахувати час
виконання
блоку «сортування» та визначити кількість ітерацій з перестановки
елементів масиву для усіх методів). Вихідні дані вибрати відповідно до
свого варіанту.
Індивідуальне завдання:

Теоретична частина:
Алгоритм сортування — це алгоритм, що розв'язує задачу сортування,
тобто здійснює впорядкування лінійного списку (масиву) елементів.
Сортування обміном або сортування бульбашкою.
Алгоритм працює таким чином — у поданому наборі даних (списку чи
масиві) порівнюються два сусідні елементи. Якщо один з елементів, не
відповідає критерію сортування (є більшим, або ж, навпаки, меншим за свого
сусіда), то ці два елементи міняються місцями. Прохід по списку
продовжується доти, доки дані не будуть відсортованими. Алгоритм отримав
свою назву від того, що процес сортування за ним нагадує поведінку
бульбашок повітря у резервуарі з водою. Оскільки для роботи з елементами
масиву він використовує лише порівняння, це сортування на основі
порівнянь.
Сортування включенням або сортування вставлянням.
На кожному кроці алгоритму ми вибираємо один з елементів вхідних
даних і вставляємо його на потрібну позицію у вже відсортованому списку
доти, доки набір вхідних даних не буде вичерпано. Метод вибору чергового
елементу з початкового масиву довільний; може використовуватися
практично будь-який алгоритм вибору. Зазвичай (і з метою отримання
стійкого алгоритму сортування), елементи вставляються за порядком їх
появи у вхідному масиві.
Швидке сортування.
Ідея алгоритму полягає в переставлянні елементів масиву таким чином,
щоб його можна було розділити на дві частини і кожний елемент з першої
частини був не більший за будь-який елемент з другої. Впорядкування
кожної з частин відбувається рекурсивно. Алгоритм швидкого сортування
може бути реалізований як у масиві, так і в двозв'язному списку.
 Сортування Шелла.
На початку обираються m-елементів: d1, d2,…, dm, причому, d1 > d2
>…> dm = 1.

Потім виконується m впорядкувань методом включення, спочатку для

елементів, що стоять через d1, потім для елементів через d2 і т. д. до dm = 1
Ефективність досягається тим, що кожне наступне впорядкування
вимагає меншої кількості перестановок, оскільки деякі елементи вже стали
на свої місця.
Сортування вибором.
Алгоритм працює таким чином:
Знаходить у списку найменше значення
Міняє його місцями із першим значенням у списку
Повторює два попередніх кроки, доки список не завершиться
(починаючи з наступної позиції)
Фактично, таким чином ми поділили список на дві частини: перша
(ліва) — повністю відсортована, а друга (права) — ні.
Опис програми:
По завданню, потрібно протабулювати функцію задану нам за
варіантом, з результатів створити масив, та відсортувати його 5 різними
видами сортування. Порівняти кількість часу, затраченого на сортування та
кількість ітерацій проведених з масивом. Табуляція функції відбувається у
методі task1. У ньому ми задаємо верхню та нижню межі, а також крок
відповідно до завдання. Створюємо масив, розміром у кількість відповідей. Її
ми вираховуємо помноживши різницю меж на крок. Створюємо змінну y,
яка в ході виконання буде змінюватись та додаватись у масив. Створюємо
змінні k та l, які допомагають нам додавати елементи у масив. Потім, за
допомогою циклу for, розв’язуємо рівняння, присвоюємо результат змінній y,
а елемент масиву згідно циклу, робимо таким як y.
Коли табуляція завершена, переходим до сортування. Першим було
реалізовано сортування методом бульбашки. Для цього створено метод
bubbleSort. Перш за все, варто звернути увагу, що у всіх методах сортування
реалізований counter, який рахує кількість ітерацій під час сортування. Для
того, щоб відсортувати масив за спаданням, ми створюємо 2 цикли for.
Перший має межу array.length, для того, щоб не виходити за межі масиву,
другий же має межі array.length – step(змінна першого циклу). Це потрібно
для того, щоб розрізняти яка частина масиву відсортована, а яка ні. Далі, за
умови, що array[i-1] < array[i], ми створюємо змінну temp, та даємо їй
значення array[i-1]. Потім, array[i-1] = array[i]. Тобто пересуваємо більший
елемент вперед масиву. Та в кінці робимо менший елемент наступним після
більшого array[i] = temp. На цьому принцип роботи алгоритму сортування
бульбашкою завершено.
Наступний алгоритм це сортування вставкою. Він реалізований у
методі insertionSort. У ньому для початку ми створюємо цикл for, де межею є
довжина масиву. Потім, створюємо змінну key, яка буде дорівнювати
елементу масиву, згідно до циклу. Також робимо змінну і, яка буде на 1
меншою, ніж змінна циклу. Далі, за умови що i > -1 та array[i] < key, міняємо
місцями елемент i+1 та i. Віднімаємо i-1. Виходимо з умови, та робимо array[i
+ 1] = key, тобто міняємо більший та менший елемент місцями. На цьому,
після завершення циклу, робота з цим методом завершена.
Потім реалізуємо алгоритм сортування вибором у методі ChoiceSort.
Створюємо цикл, з межею в довжину масиву. Робимо змінну р, яка дорівнює
змінній циклу. Робимо змінну max, яка буде дорівнювати елементу масиву
під номером, який дорівнює змінній циклу. Робимо наступний цикл, у якому
змінна j = i+1, тобто змінна попереднього циклу + 1. Це потрібно для того,
щоб програма розуміла яка частина масива вже відсортована. Потім, за
умови, що array[j] > max, присвоюємо змінній max значення максимального
знайденого елементу, а змінній p даємо значення позиції цього елементу.
Потім, міняємо місцями найбільший знайдений елемент з елементом
відповідно циклу. На цьому, по завершенню циклу, роботу алгоритму
завершено.
Алгоритм Шелла реалізований наступним у методі ShellSort.
Створюємо 3 змінні i, j та x. Також створюємо змінну temp. Створюємо
масив, змінною якого буде х, що дорівнює половині довжини масиву, а
межею його буде 0. З кожним проходом циклу, х буде ділитись на 2. Це
принцип роботи цього алгоритму. Порівняння елементів які знаходяться на
певній відстані. Робимо наступний цикл, в якому змінна i = x, проте межею
вже є весь масив, а при проходження до і буде додаватись 1. Потім, змінній
temp присвоюємо значення array[i]. Потім, робимо останній цикл, у якому
змінна j = i, та межею є x. І при кожному проходженні, від j буде відніматись
х. І потім, за умови, що temp > array[j-x](тобто перший елемент), ми міняємо
елементи місцями. Це відбувається за допомогою того, що temp = array[i], а j
= i. array[j] = array[j - x]. І потім повертаємо елемент, за допомогою array[j] =
temp. На цьому роботу методу завершено.
Останній алгоритм сортування це швидке сортування, реалізоване у
методі quickSort. Він є рекурсивним. Для початку, знаходимо номер
середнього елементу масиву. Для цього додаємо номер першого елементу до
останнього, та ділимо на 2. Робимо змінну х, яка дорівнює середньому
елементу масиву. Для зручності, створюємо змінні i та j, які дорівнюються
номерам першого та останнього елементу масиву. Потім, ділимо масив на
частини, за допомогою умов i <= j, array[i] > x, array[j] < x. Це і є сутність
цього методу. Потім, якщо i<=j, то створюємо змінну temp, та присвоюємо їй
значення array[i], array[i] = array[j], array[j] = temp. Міняємо елементи
масивів місцями. Після цього, додаємо до і 1, а від j віднімаємо 1. Та
викликаємо цей метод знов, рекурсією, проте межі масиву відповідно робимо
low та j.(ділимо масив). Алгоритм продовжується до того часу, допоки масив
не буде остаточно відсортований.
Результати роботи:
 Висновки:
В ході результати лабораторної роботи, було отримано навички роботи
з різними методами сортування. Розібрані на практиці їх особливості,
перевірена швидкість роботи. Створено програму табуляції функції,
результати занесено у масив та відсортовано 5 способами. Можна помітити,
що швидке сортування виявилось найоптимальнішим.
Додатки:
Лістинг програми:
import java.util.Arrays;

import java.lang.Math;

public class Lab1Algo {

public static int X = 0;

public static void main(String[] args) {

System.out.println("Початковий масив:");
System.out.println(Arrays.toString(task1()));
long time = System.nanoTime();
bubbleSort(task1());
time = System.nanoTime() - time;
System.out.printf("Потрачено часу на виконання%,9.3f ms\n", time /
1_000_000.0);
long time2 = System.nanoTime();
insertionSort(task1());
time2 = System.nanoTime() - time2;
System.out.printf("Потрачено часу на виконання%,9.3f ms\n", time2 /
1_000_000.0);
long time3 = System.nanoTime();
ChoiceSort(task1());
time3 = System.nanoTime() - time3;
System.out.printf("Потрачено часу на виконання%,9.3f ms\n", time3 /
1_000_000.0);
 long time4 = System.nanoTime();
ShellSort(task1());
time4 = System.nanoTime() - time4;
System.out.printf("Потрачено часу на виконання%,9.3f ms\n", time4 /
1_000_000.0);
long time5 = System.nanoTime();
System.out.println("Швидкий метод сортування:");
System.out.println(Arrays.toString(quickSort(task1(), 0,
task1().length - 1)));
System.out.printf("Кількість ітерацій: %d\n", X);
time5 = System.nanoTime() - time5;
System.out.printf("Потрачено часу на виконання:%,9.3f ms\n", time5 /
1_000_000.0);
}

public static double[] task1() {

int upper = 1;
int bottom = 0;
double step = 0.05;
double[] a = new double[21];
double y;
int k = 0;
int l = -1;
for (double i = bottom; i <= upper + step; i = i + step) {
k++;
l++;
for (int j = l; j <= k - 1; j++) {
y = Math.sin(i) + Math.cos(i);
a[j] = y;
}
}
return a;
}

public static void bubbleSort(double[] array) {

int counter = 0;
for (int x = 0; x < array.length; x++) {
for (int i = 1; i < array.length - x; i++) {
if (array[i-1] < array[i]) {
double temp = array[i-1];
array[i-1] = array[i];
array[i] = temp;
counter++;
}
}
}
System.out.println("Метод сортування бульбашкою:");
System.out.println(Arrays.toString((array)));
System.out.printf("Кількість ітерацій: %d\n", counter);
}

public static void insertionSort(double[] array) {

int counter = 0;
for (int j = 1; j < array.length; j++) {
double key = array[j];
int i = j - 1;
while ((i > -1) && (array[i] < key)) {
array[i + 1] = array[i];
i--;
counter++;
}
array[i + 1] = key;
}
 System.out.println("Метод сортування вставкою:");
System.out.println(Arrays.toString((array)));
System.out.printf("Кількість ітерацій: %d\n", counter);
}

public static void ChoiceSort(double[] array) {

int counter = 0;
for (int i = 0; i < array.length; i++) {
int p = i;
double min = array[i];
for (int j = i + 1; j < array.length; j++) {
if (array[j] > min) {
p = j;
min = array[j];
}
}
array[p] = array[i];
array[i] = min;
counter++;
}
System.out.println("Метод сортування вибором:");
System.out.println(Arrays.toString((array)));
System.out.printf("Кількість ітерацій: %d\n", counter);
}

public static void ShellSort(double[] array) {

int counter = 0;
int i, j, step;
double tmp;
for (step = array.length / 2; step > 0; step /= 2)
for (i = step; i < array.length; i++) {
 tmp = array[i];
for (j = i; j >= step; j -= step) {
if (tmp > array[j - step]) {
array[j] = array[j - step];
counter++;
} else
break;
}
array[j] = tmp;
}
System.out.println("Метод сортування Шелла:");
System.out.println(Arrays.toString((array)));
System.out.printf("Кількість ітерацій: %d\n", counter);
}

public static double[] quickSort(double[] array, int low, int high) {

int middle = low + (high - low) / 2;
double x = array[middle];
int i = low, j = high;
while (i <= j) {
while (array[i] > x) {
i++;
}
while (array[j] < x) {
j--;
}
if (i <= j) {
double temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
 j--;
X++;
}
}
if (low < j)
quickSort(array, low, j);
if (high > i)
quickSort(array, i, high);
return array;
}
}