Реферат по лабораторной номер 5 пк

Raport
Лабораторная работа № 5
Тема: эмпирический анализ алгоритмов сортировки и поиска.

Цель работы: изучение возможностей и средств языка C программирования алгоритмов
сортировки и поиска для одномерных массивов и получение навыков эмпирического
анализа алгоритмов.
Задание: написать программу на языке C для эмпирического анализа предложенного
алгоритма (по варианту) с созданием функции поиска или сортировки для одномерного
массива из n элементов с отображением на экране следующего меню параметров:
1. Демонстрация работы программ для массива из n элементов (15  n  10 ).
2. Вычисления для массива случайных чисел (n=10000, n=100000).
3. Эмпирический анализ функции сортировки qsort() или функции поиска bsearch ()
из библиотеки языка C.
0. Выход из программы.
Эмпирический анализ алгоритма состоит из:

а) определение времени выполнения, количества сравнений для разного числа
элементов массива.
б) сравнение полученных результатов с результатами расчетов с помощью
соответствующих функций из библиотеки языка.
Варианты алгоритмов
 Сортировка методом прямого обмена (пузырька).

 Сортировка по методу прямого выбора.
 Шейкерная сортировка в порядке возрастания.
 Сортировка методом Шелла.
 Быстрая сортировка Хоара.
 Сортировка слиянием.
 Сортировка qsort ().
Выполнил :Шологан Артемиос

Група: MN-222
Преподователь:Бузурнюк С.
Код:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void bubble_sort(int arr[], int n) {
int i, j, temp;
for (i = 0; i < n-1; i++) {
for (j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
void selectionSort(int arr[], int n) {

int i, j, minIndex, temp;
for (i = 0; i < n-1; i++) {
minIndex = i;
for (j = i+1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
void cocktailSort(int arr[], int n) {

int i, temp, start = 0, end = n-1, swapped = 1;
while (swapped) {
swapped = 0;
for (i = start; i < end; i++) {
if (arr[i] > arr[i+1]) {
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
swapped = 1;
}
}
if (!swapped) {
break;
}
swapped = 0;
end--;
for (i = end-1; i >= start; i--) {
if (arr[i] > arr[i+1]) {
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
swapped = 1;
}
}
start++;
}
}
void shellSort(int arr[], int n) {

int i, j, gap, temp;
for (gap = n/2; gap > 0; gap /= 2) {
for (i = gap; i < n; i++) {
temp = arr[i];
for (j = i; j >= gap && arr[j-gap] > temp; j -= gap) {
arr[j] = arr[j-gap];
}
arr[j] = temp;
}
}
}
void quickSort(int arr[], int left, int right) {

int i = left, j = right, temp;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
temp = arr[i];
arr[i] =arr[j];
arr[j] = temp;
i++;
j--;
}
}
if (left < j) {
quickSort(arr, left, j);
}
if (i < right) {
quickSort(arr, i, right);
}
}
void merge(int arr[], int left, int middle, int right) {

int i, j, k;
int n1 = middle - left + 1;
int n2 = right - middle;
int L[n1], R[n2];
for (i = 0; i < n1; i++) {
L[i] = arr[left + i];
}
for (j = 0; j < n2; j++) {
R[j] = arr[middle + 1 + j];
}
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int middle = left + (right - left) / 2;
mergeSort(arr, left, middle);
mergeSort(arr, middle+1, right);
merge(arr, left, middle, right);
}
}
int compare(const void *a, const void *b) {

return (*(int*)a - *(int*)b);
}
int compare1(const void* a, const void* b) {

const int* p1 = (const int*) a;
const int* p2 = (const int*) b;
if (*p1 < *p2) {

return -1;
} else if (*p1 > *p2) {
return 1;
} else {
return 0;
}
}
void sort1(int arr[], int n) {

qsort(arr, n, sizeof(int), compare1);
}
// Функция для заполнения массива случайными числами

void fill_random(int arr[], int n) {
int i, j, temp;
srand(time(NULL)); // установить случайное зерно
for (i = n - 1; i >= 1; i--) {
j = rand() % (i + 1);
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
void sort(int arr[], int n) {
qsort(arr, n, sizeof(int), compare);
}
// Функция для вывода массива на экран

void print_array(int arr[], int n) {
int i;
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int search(int arr[], int n, int x) {

int *p = (int*) bsearch(&x, arr, n, sizeof(int), compare);
if (p == NULL) {
return -1;
} else {
return (p - arr);
}
}
int main() {
int n;
printf("Введите размер массива (от 15 до 100): ");
scanf("%d", &n);
while (n < 15 || n > 100) {
printf("Размер массива должен быть от 15 до 100. Попробуйте еще раз: ");
scanf("%d", &n);
}
int arr[n];
int choice;
do {
printf("\nМеню параметров:\n");
printf("1. Демонстрация работы программ для массива из %d элементов.\n",
n);
printf("2. Вычисления для массива случайных чисел (n=10000, n=100000).\
n");
printf("3. Эмпирический анализ функции сортировки qsort.\n");
printf("0. Выход из программы.\n");
printf("Выберите параметр: ");
scanf("%d", &choice);
switch (choice) {
case 1: {
int arr[n];
printf("Введите элементы массива: ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
printf("\nИсходный массив: ");
print_array(arr, n);
int sort;
do {
printf("1.Сортировка методом пузырька\n2.Сортировка
методом прямого выбора\n3.Шейкерная сортировка в порядке возрастания\n4.Сортировка
методом Шелла\n5.Быстрая сортировка Хоара\n6.Сортировка слиянием\n7.Сортировка
qsort()\n8.Поиск\n9.Вернуться к выбору сортировки\n");
printf("Выберите параметр: ");
scanf("%d", &sort);
switch (sort) {
case 1: {
bubble_sort(arr, n); // Сортировка методом

пузырька
printf("Отсортированный массив: ");
break;
}
case 2: {
selectionSort(arr, n); // Сортировка методом

прямого выбора
break;
}
case 3: {
cocktailSort(arr, n); // Шейкерная
сортировка в порядке возрастания
break;
}
case 4: {
shellSort(arr, n); // Сортировка методом
Шелла
break;
}
case 5: {
quickSort(arr, 0, n - 1); // Быстрая
сортировка Хоара
break;
}
case 6: {
mergeSort(arr, 0, n - 1); // Сортировка
слиянием
break;
}
case 7: {
qsort(arr, n, sizeof(int), compare); //
Сортировка qsort()
break;
}
case 8: {
int x;
printf("Элемент для поиска :");
scanf("%d",&x);
int index = search(arr, n, x);
if (index == -1) {
printf("\nЭлемент %d не найден\n",
x);
} else {
printf("\nЭлемент %d найден в
позиции %d\n", x, index);
}
break;
}
case 9: {
printf("Exit");
break;
}
default : {
printf("Ошибка! Неверный выбор
параметра.\n");
break;
}
}
} while (sort != 9);
break;
}
case 2: {
int arr1[10000];
int arr2[100000];
fill_random(arr1, 10000);
fill_random(arr2, 100000);
clock_t start, end;

double cpu_time_used;
start = clock();
bubble_sort(arr1, 10000);
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("Сортировка массива из 100000 элементов заняла %f
секунд.\n", cpu_time_used);
start = clock();
bubble_sort(arr2, 100000);
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("Сортировка массива из 100000 элементов заняла %f

секунд.\n", cpu_time_used);
}
break;
case 3: {
printf("\nЭмпирический анализ функции сортировки
пузырьком:\n");
clock_t start, end;

double cpu_time_used;
int i, j, arr[100000],arr1[100000];
fill_random(arr, n);
printf("Метод сортировки пользуясь библиотекой :\n");
// Измеряем время выполнения и количество сравнений для
массивов разных размеров
for (i = 1000; i <= 10000; i += 1000) {
fill_random(arr, i);
start = clock();
sort(arr, i);
end = clock();
cpu_time_used = ((double) (end - start)) /

CLOCKS_PER_SEC;
printf("Время выполнения сортировки массива из %d
элементов: %f секунд.\n", i, cpu_time_used);
// Количество сравнений для i-элементного массива

int comparisons = 0;
sort(arr, i);
for (j = 0; j < i-1; j++) {
comparisons++;
}
printf("Количество сравнений для сортировки массива
из %d элементов: %d.\n", i, comparisons);
}
printf("Мой метод сортировки qsort:\n");
for (i = 1000; i <= 10000; i += 1000) {
fill_random(arr1, i);
start = clock();
qsort(arr1, n, sizeof(int), compare1);
end = clock();
cpu_time_used = ((double) (end - start)) /

CLOCKS_PER_SEC;
printf("Время выполнения сортировки массива из %d
элементов: %f секунд.\n", i, cpu_time_used);
// Количество сравнений для i-элементного массива

int comparisons = 0;
qsort(arr1, n, sizeof(int), compare1);
for (j = 0; j < i-1; j++) {
comparisons++;
}
printf("Количество сравнений для сортировки массива
из %d элементов: %d.\n", i, comparisons);
}
break;
}
case 0: {
printf("Выход из программы.\n");
break;
}
default: {
printf("Ошибка! Неверный выбор параметра.\n");
break;
}
}
} while (choice != 0);
return 0;
}
Реализация кода :Введите размер массива (от 15 до 100): 15

Меню параметров:
1. Демонстрация работы программ для массива из 15 элементов.
3. Эмпирический анализ функции сортировки qsort().
Выберите параметр: 1
Введите элементы массива: 76 31 19 23 53 49 91 21 78 43 26 1 80 34 0
Исходный массив: 76 31 19 23 53 49 91 21 78 43 26 1 80 34 0
1.Сортировка методом пузырька
2.Сортировка методом прямого выбора
3.Шейкерная сортировка в порядке возрастания
4.Сортировка методом Шелла
5.Быстрая сортировка Хоара
6.Сортировка слиянием
7.Сортировка qsort()
8.Поиск
9.Вернуться к выбору сортировки
Отсортированный массив: 0 1 19 21 23 26 31 34 43 49 53 76 78 80 91
8.Поиск
Элемент для поиска :76
Элемент 76 найден в позиции 11
8.Поиск
Exit
Сортировка массива из 10000 элементов заняла 0.177291 секунд.
Сортировка массива из 100000 элементов заняла 15.607767 секунд.
Эмпирический анализ функции сортировки пузырьком:
Время выполнения сортировки массива из 1000 элементов: 0.000070 секунд.
Количество сравнений для сортировки массива из 1000 элементов: 999.
Метод сортировки пользуясь библиотекой : Мой метод сортировки qsort:
Время выполнения сортировки массива из Время выполнения сортировки массива из

1000 элементов: 0.000069 секунд. 1000 элементов: 0.000004 секунд.
Количество сравнений для сортировки Количество сравнений для сортировки
массива из 1000 элементов: 999. массива из 1000 элементов: 999.
массива из 10000 элементов: массива из 10000 элементов
Вывод. Исходя из данных таблицы можно сделать вывод ,что своя функция сортировки
более эфективна ,чем использование библиотеки .

Реферат по лабораторной номер 5 пк

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Реферат по лабораторной номер 5 пк

Загружено:

Авторское право:

Доступные форматы

Raport

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

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

 Сортировка методом прямого обмена (пузырька).

Выполнил :Шологан Артемиос

void selectionSort(int arr[], int n) {

void cocktailSort(int arr[], int n) {

void shellSort(int arr[], int n) {

void quickSort(int arr[], int left, int right) {

void merge(int arr[], int left, int middle, int right) {

int compare(const void *a, const void *b) {

int compare1(const void* a, const void* b) {

if (*p1 < *p2) {

void sort1(int arr[], int n) {

// Функция для заполнения массива случайными числами

// Функция для вывода массива на экран

int search(int arr[], int n, int x) {

bubble_sort(arr, n); // Сортировка методом

selectionSort(arr, n); // Сортировка методом

clock_t start, end;

printf("Сортировка массива из 100000 элементов заняла %f

clock_t start, end;

cpu_time_used = ((double) (end - start)) /

// Количество сравнений для i-элементного массива

cpu_time_used = ((double) (end - start)) /

// Количество сравнений для i-элементного массива

Реализация кода :Введите размер массива (от 15 до 100): 15

Метод сортировки пользуясь библиотекой : Мой метод сортировки qsort:

Время выполнения сортировки массива из Время выполнения сортировки массива из

Вам также может понравиться

int compare(const void a, const void b) {

if (p1 < p2) {