Министерство Образования, Культуры и Исследований

Технический Университет Молдовы

Факультет Вычислительной техники, Информатики и Микроэлектроники
Департамент Микроэлектроники и Нанотехнологий

Отчёт
по лабораторной работе № 5
“Эмпирический анализ алгоритмов сортировки”

Выполнил: Цуркану Денис

Группа MN-222
Проверил: конф. унив. Бузурнюк С.

Кишинев, 2023
 Лабораторная работа №5

Тема: Эмпирический анализ алгоритмов сортировки

Цель работы: Изучение возможностей и средств языка C
программирования алгоритмов сортировки для одномерных массивов
и получение навыков эмпирического анализа алгоритмов.
Задание: Написать программу на языке C для эмпирического анализа
предложенного алгоритма с созданием функции сортировки для
одномерного массива из n-элементов с отображением на экране
следующего меню параметров:
1. Демонстрация работы программы для массива из n-
элементов (10 <= n <= 15)
2. Сортировка для массива случайных чисел (n >= 10.000)
3. Эмпирический анализ алгоритмов сортировки
0. Выход из программы
Код программы:
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

unsigned int search_time1 = 0;

unsigned int search_time2 = 0;
unsigned int search_time3 = 0;
unsigned int search_time4 = 0;
unsigned int search_time5 = 0;
unsigned int search_time6 = 0;
unsigned int search_time7 = 0;

void swap(int &A, int &B){

int temp = A;
A = B;
B = temp;
}
int compare(const int *A, const int *B){
return *A - *B;
}
void isSorted(int *Array, const int &length){
int prev = Array[0];
for(int i=0; i<length; ++i){
if(prev > Array[i]){
cout << "Array isn't sorted" << endl;
break;
}
prev = Array[i];
}
cout << "Array is sorted" << endl;
}
void bubbleSort(int *Array, int const &length){
for(int i=0; i<length; ++i){
for(int j=i; j<length; ++j){
if(Array[i] > Array[j]){
swap(Array[i], Array[j]);
}
}
}
}
void selectionSort(int *Array, int const &length){
int min;
for(int i=0; i<length-1; ++i){
min = i;
for(int j=i+1; j<length; ++j){
if(Array[min] > Array[j])
min = j;
}
swap(Array[i], Array[min]);
}
}
void shakerSort(int *Array, int const &length){
int begin, end;
begin = 0;
end = length - 1;
while(begin <= end){
for(int i=end; i>begin; --i){
if(Array[i-1] > Array[i])
swap(Array[i-1], Array[i]);
}
++begin;
for(int i=begin; i<=end; ++i){
if(Array[i-1] > Array[i])
swap(Array[i-1], Array[i]);
}
--end;
}
}
void shellSort(int *Array, int const &length){
for(int step = length/2; step>0; step /= 2){
for(int i=step; i<length; ++i){
int j;
for(j=i; j >= step; j -= step){
if(Array[i] < Array[j - step])
Array[j] = Array[j - step];
else
break;
}
Array[j] = Array[i];
}
}
}
void hoaraSort(int *Array, int left, int right){
int i = left, j = right,
reference = Array[(i+j)/2];
do{
while(Array[i] < reference)
++i;
while(Array[j] > reference)
--j;
if(i <= j){
if(i < j){
swap(Array[i], Array[j]);
}
++i;
--j;
}
}while(i <= j);
if(i < right)
hoaraSort(Array, i, right);
if(left < j)
hoaraSort(Array, left, j);
}
void merge(int *Array, int length, int *temp, int from, int mid, int to){
int k = from,
i = from,
j = mid + 1;
 while(i <= mid && j <= to){
if(Array[i] < Array[j])
temp[k++] = Array[i++];
else
temp[k++] = Array[j++];
}
while(i < length && i <= mid)
temp[k++] = Array[i++];
for(int i=from; i<=to; i++)
Array[i] = temp[i];
}
void mergeSort(int *Array, int length, int* temp, int low, int high){
for(int i=1; i<=high - low; i = 2*i){
for(int j=low; j<high; j+=2*i){
int from = j;
int mid = j + i - 1;
int to = min(j + 2*i - 1, high);

merge(Array, length, temp, from, mid, to);

}
}
}
void sortingArrays(int* Array,const int &length, int *temp){
system("cls");
unsigned short cmd;
f_start:
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| Command list: |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 1.Bubble sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 2.Selection sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 3.Shaker sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 4.Shell sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 5.Hoara quick sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 6.Merge sort |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 7.qsort() |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~\n" << endl;
cout << "Choose a command: ";
cin >> cmd;
system("cls");
switch(cmd){
case 1:{
// Метод пузырька
unsigned int start_time = clock();
bubbleSort(Array, length);
unsigned int end_time = clock();
search_time1 = end_time - start_time;
cout << "runtime = " << search_time1/1000.0 << "s." <<endl;
break;
}
case 2:{
// Метод прямого выбора
unsigned int start_time = clock();
selectionSort(Array, length);
unsigned int end_time = clock();
search_time2 = end_time - start_time;
cout << "runtime = " << search_time2/1000.0 << "s." <<endl;
break;
}
case 3:{
// Шейкернай сортировка
unsigned int start_time = clock();
shakerSort(Array, length);
unsigned int end_time = clock();
search_time3 = end_time - start_time;
cout << "runtime = " << search_time3/1000.0 << "s." <<endl;
break;
}
case 4:{
// Сортировка методом Шелла
unsigned int start_time = clock();
shellSort(Array, length);
unsigned int end_time = clock();
search_time4 = end_time - start_time;
cout << "runtime = " << search_time4/1000.0 << "s." <<endl;
break;
}
case 5:{
// Быстрая сортировка Хоара
unsigned int start_time = clock();
hoaraSort(Array, 0, length-1);
unsigned int end_time = clock();
search_time5 = end_time - start_time;
cout << "runtime = " << search_time5/1000.0 << "s." <<endl;
break;
}
case 6:{
// Сортировка слиянием
unsigned int start_time = clock();
mergeSort(Array, length,temp, 0, length - 1);
unsigned int end_time = clock();
search_time6 = end_time - start_time;
cout << "runtime = " << search_time6/1000.0 << "s." <<endl;
break;
}
case 7:{
// Сортировка qsort()
unsigned int start_time = clock();
qsort(Array, length, sizeof(int),
(int(*) (const void *, const void *)) compare);
unsigned int end_time = clock();
search_time7 = end_time - start_time;
cout << "runtime = " << search_time7/1000.0 << "s." << endl;
break;
}
default:{
 cout << "\x1B[31m!!! ENTER THE CORRECT NUMBER FROM 1 TO 7 !!!\n\033[0m";
goto f_start;
}
}
}
int main(){
unsigned short comm;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| Sort Manager ver. 1.0 |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" << endl;
start:
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| Command list: |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 1.Array (15 >= n >= 10) |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 2.Random Array (n >= 10.000) |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 3.Analysis of qsort() and bsearch() |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" <<
"| 0.Exit program |\n" <<
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" << endl;
cout << "Choose a command: ";
cin >> comm;
system("cls");
switch(comm){
case 1: {
/*
* TODO: Возможно переделать заполнение массива
* через ввод пользователем, а не заполнением
* через rand()
*/
s_case1:
system("cls");
cout << "Enter length of array (15 >= n >= 10): ";
int n;
cin >> n;
if(n < 10 || n > 15){
goto s_case1;
}
int *Array = new int[n],
*temp = new int[n];
for(int i=0; i<n; ++i)
temp[i] = Array[i] = 1 + rand() % n;
sortingArrays(Array, n, temp);
isSorted(Array, n);
for(int i=0; i<n; ++i){
cout << Array[i] << " ";
}
break;
}
case 2:{
s_case2:
system("cls");
cout << "Enter length of array (n>=10.000): ";
int n;
 cin >> n;
if(n < 10000){
goto s_case2;
}
int *Array = new int[n],
*temp = new int[n];
for(int i=0; i<n; ++i)
temp[i] = Array[i] = 1 + rand() % n;
sortingArrays(Array, n, temp);
isSorted(Array, n);
break;
}
case 3:{
unsigned int cmd;
cout << "1. Analyse sort for 10.000 elements" <<
"2. Analyse sort for 10.000.000 elements\n" << endl;
cout << "Choose a command: ";
cin >> cmd;
while(cmd > 2)
cin >> cmd;
switch(cmd){
case 1:{
int n = 100000;
unsigned int time[7];
for(int i=0; i<7; ++i){
int *Array = new int[n],
*temp = new int[n];
for(int j=0; j<n; ++j){
temp[j] = Array[j] = 1 + rand() % n;
}
unsigned int start_time = clock();
if(i == 0){
bubbleSort(Array, n);
}
if(i == 1){
selectionSort(Array, n);
}
if(i == 2){
shakerSort(Array, n);
}
if(i == 3){
shellSort(Array, n);
}
if(i == 4){
hoaraSort(Array, 0, n-1);
}
if(i == 5){
mergeSort(Array, n, temp, 0, n - 1);
}
if(i == 6){
qsort(Array, n, sizeof(int),
(int(*) (const void *, const void *)) compare);
}
unsigned int end_time = clock();
time[i] = end_time - start_time;
}
 cout << "Time for 100.000 elements" << endl;
cout << "| Bubble sort\t" << "| Selection \t" << "| Shaker sort\t" << "|
Shell sort\t" << "| Hoara sort\t" << "| Merge sort\t" << "| qsort" << endl;
for(int i=0; i<7; ++i){
cout << "| " << time[i]/1000.0 << " s. \t";
}
break;
}
case 2:{
int n = 10000000;
unsigned int time[4];
for(int i=0; i<4; ++i){
int *Array = new int[n],
*temp = new int[n];
for(int j=0; j<n; ++j){
temp[j] = Array[j] = 1 + rand() % n;
}
unsigned int start_time = clock();
if(i == 0){
shellSort(Array, n);
}
if(i == 1){
hoaraSort(Array, 0, n-1);
}
if(i == 2){
mergeSort(Array, n, temp, 0, n - 1);
}
if(i == 3){
qsort(Array, n, sizeof(int),
(int(*) (const void *, const void *)) compare);
}
unsigned int end_time = clock();
time[i] = end_time - start_time;
}
cout << "Time for 10.000.000 elements" << endl;
cout << "| Shell sort\t" << "| Hoara sort\t" << "| Merge sort\t" << "|
qsort" << endl;
for(int i=0; i<4; ++i){
cout << "| " << time[i]/1000.0 << " s. \t";
}
break;
}
}
break;
}
case 0:{
return (EXIT_SUCCESS);
}
default:{
cout << "\x1B[31m!!! ENTER THE CORRECT NUMBER FROM 1 TO 3 !!!\n\033[0m";
goto start;
}
}
unsigned short bol = 0;
cout << "\n\nWant to choose another command? [1/0]: ";
cin >> bol;
 if (bol) {
system("cls");
goto start;
}
else{
return (EXIT_SUCCESS);
}
}

Вывод программы:
1. Array (15 >= n >= 10)
2. Random array (n >= 10.000)
3. Analysis of qsort()
Вывод:
Можно заметить, что алгоритм qsort() в частности быстрее
представленных алгоритмов сортировки.