Lucrare de laborator

la disciplina
Structuri de Date și Algoritmi

Raport

A efectuat: Revenko Ivan

St gr. TI-224
A verificat: Barnaz Adrian

Lucrare de laborator
la disciplina
Structuri de Date și Algoritmi
Lucrare de laborator nr. 5:

Tema:
Implementarea și analiza algoritmilor de sortare și de căutare în limbajul C.

Scopul lucrării
Scopul lucrării este de a familiariza studentul cu implementarea și analiza algoritmilor,
utilizînd pentru aceasta limbajul C.
Problema
 1. Să se elaboreze un program ce va aloca dinamic un tablou unidimensional de
numere întregi și va implementa următoarele funcții, funcțiile vor fi organizate sub
forma unui meniu:
- inițializarea tabloului cu numere aleatorii;
- afișarea tabloului;
- eliberarea memoriei tabloului;
- sortarea tabloului utilizînd una din metode ( selection sort, insertion sort, bubble sort ), se
va afișa în cît timp a fost executată sortarea;
- sortarea tabloului utilizînd una din metode ( merge sort, quick sort, heap sort ), se va afișa
în cît timp a fost executată sortarea.

1.1 Să se realizeze o analiză empirică a timpului necesar pentru a sorta un tablou

aleator de lungimea N unde N va avea valori [100, 1000, 10000, 100000], rezultatele
obținute se vor plasa în tabelul de mai jos:
N 100 1000 10000 100000
Metoda de sortare 1
( ex. selection sort)
Metoda de sortare 2
( ex. heap sort)

2. Să se elaboreze un program ce va aloca dinamic un tablou unidimensional de

numere întregi și va implementa următoarele funcții, funcțiile vor fi organizate sub
forma unui meniu:
- inițializarea tabloului cu numere aleatorii;
- afișarea tabloului;
- eliberarea memoriei tabloului;
- căutarea unui număr din tablou utilizînd metoda de căutare linear search, se va afișa în cît
timp se execută căutarea.
- căutarea unui număr din tablou utilizînd metoda de căutare binary search, se va afișa în
cît timp se execută căutarea.

2.2 Să se realizeze o analiză empirică a timpului necesar pentru a efectua 10000 de căutări
într-un tablou aleator de lungimea N unde N va avea valori [100, 1000, 10000, 100000],
rezultatele obținute se vor plasa în tabelul de mai jos:
N 100 1000 10000 100000
Linear search
Binary search

3.1 Să se realizeze un algoritm de calcul a unui element din șirul lui Fibonaci pe baza
poziției acestuia N, de exemplu:
- fib(0) == 0;
- fib(1) == 1;
- fib(5) == 3;
- fib(100) == 354224848179261915075;
- fib(500) ==
13942322456169788013972438287040728395007025658769730726410896294832557162286
3290691557658876222521294125;
Poziția unui element N, va fi în diapazonul [50;1000000] , asta înseamnă că algoritmul
trebuie să poată calcula minim fib(50) și maxim fib(1000000).
3.2 Să se realizeze o analiză empirică a timpului necesar pentru a calcula numărul lui
fibonaci de pe poziția N, unde N va avea valori [50, 100, 1000, 10000, 100000, 1000000],
rezultatele obținute se vor plasa în tabelul de mai jos:
N 50 100 1000 10000 100000 1000000
Fibonacci

Barem de notare:
Problema 1.1, 1.2 1.1, 1.2, 1.1, 1.2, 1.1, 1.2, Toate Toate
2.1 2.1, 2.2 2.1, 2.2, exercițiile și exercițiile și
3.1, algoritm algoritm
3.2 pentru pentru
fibonaci pînă fibonaci de la
la 1000 1000000
Nota 5 6 7 8 9 10

1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void initialize(int *arr, int size) {

for (int i = 0; i < size; i++) {
arr[i] = rand() % 100;
}
}

void display(int *arr, int size) {

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

void free_memory(int *arr) {

free(arr);
}

void selection_sort(int *arr, int size) {

for (int i = 0; i < size - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < size; j++) {
 if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
int partition(int *arr, int low, int high) {
int pivot = arr[high];
int i = (low - 1);

for (int j = low; j <= high - 1; j++) {

if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

int temp = arr[i + 1];

arr[i + 1] = arr[high];
arr[high] = temp;

return (i + 1);
}

void quick_sort(int *arr, int low, int high) {

if (low < high) {
int pi = partition(arr, low, high);

quick_sort(arr, low, pi - 1);

quick_sort(arr, pi + 1, high);
}
}

int main() {
int size;
printf("Introduceti dimensiunea tabloului: ");
scanf("%d", &size);

int *arr = (int *)malloc(size * sizeof(int));

int choice;
clock_t start, end;
double cpu_time_used;

while (1) {
printf("\nMeniu:\n");
printf("1. Initializare tablou\n");
printf("2. Afisare tablou\n");
printf("3. Eliberare memorie tablou\n");
 printf("4. Sortare selection sort\n");
printf("5. Sortare quick sort\n");
printf("6. Iesire\n");
printf("Alegeti optiunea: ");
scanf("%d", &choice);

switch (choice) {
case 1:
initialize(arr, size);
printf("Tabloul a fost initializat cu numere aleatorii.\n");
break;
case 2:
display(arr, size);
break;
case 3:
free_memory(arr);
break;
case 4:
start = clock();
selection_sort(arr, size);
end = clock();
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Timpul de executie selection sort: %f secunde\n", cpu_time_used);
break;
case 5:
start = clock();
quick_sort(arr, 0, size - 1);
end = clock();
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Timpul de executie quick sort: %f secunde\n", cpu_time_used);
break;
case 6:
exit(0);
default:
printf("Optiune invalida!\n");
 }} return 0; }

1.2
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void selection_sort(int arr[], int n);
void heap_sort(int arr[], int n);
void heapify(int arr[], int n, int i);
void swap(int *a, int *b);
int main() {
int N[] = {100, 1000, 10000, 100000};
int n, i, j;
clock_t start, end;
double time_used;
printf("N\t\t\tSelection Sort\tHeap Sort\n");
for (j = 0; j < 4; j++) {
n = N[j];
int arr1[n], arr2[n];
for (i = 0; i < n; i++) {
arr1[i] = arr2[i] = rand() % (n * 10);
}
start = clock();
selection_sort(arr1, n);
end = clock();
time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
start = clock();
heap_sort(arr2, n);
end = clock();
double time_used2 = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("%d\t\t\t%.5f\t\t%.5f\n", n, time_used, time_used2);}
return 0;
}
void selection_sort(int arr[], int n) {
int i, j, min_idx;

for (i = 0; i < n - 1; i++) {

min_idx = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
swap(&arr[min_idx], &arr[i]);
}
}
void heap_sort(int arr[], int n) {
int i;
for (i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}

for (i = n - 1; i > 0; i--) {

swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest]) {

 largest = left;
}

if (right < n && arr[right] > arr[largest]) {

largest = right;
}
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}

2.1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void initialize(int *arr, int size) {

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

void free_memory(int *arr) {

free(arr);
}

int linear_search(int *arr, int size, int target) {

for (int i = 0; i < size; i++) {
if (arr[i] == target) {
return i;
}
}
return -1;
}
int compare(const void *a, const void *b) {
return (*(int *)a - *(int *)b);
}
int binary_search(int *arr, int size, int target){
int left = 0, right = size - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
}
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

int main() {
srand(time(NULL));
int size, choice, target, result;
clock_t start, end;
double time_taken;

printf("Enter the size of the array: ");

scanf("%d", &size);

int *arr = (int *)malloc(size * sizeof(int));

while (1) {
printf("\nMenu:\n");
printf("1. Initialize array with random numbers\n");
printf("2. Print array\n");
printf("3. Free memory\n");
 printf("4. Linear search\n");
printf("5. Binary search\n");
printf("0. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
initialize(arr, size);
break;
case 2:
print_array(arr, size);
break;
case 3:
free_memory(arr);
break;
case 4:
printf("Enter the number to search: ");
scanf("%d", &target);
start = clock();
result = linear_search(arr, size, target);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
if (result != -1) {
printf("Number found at index %d\n", result);
} else {
printf("Number not found\n");
}
printf("Time taken: %f seconds\n", time_taken);
break;
case 5:
printf("Enter the number to search: ");
scanf("%d", &target);
qsort(arr, size, sizeof(int), compare);
start = clock();
result = binary_search(arr, size, target);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
if (result != -1) {
printf("Number found at index %d\n", result);
} else {
printf("Number not found\n");
}
printf("Time taken: %f seconds\n", time_taken);
break;
case 0:
free_memory(arr);
exit(0);
default:
printf("Invalid choice\n");
}
}

return 0;
}

2.2
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

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

for (int i = 0; i < n; i++) {
if (arr[i] == x) {
return i;
}
}
return -1;
}
int compare(const void *a, const void *b) {
return (*(int *)a - *(int *)b);
}

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

int left = 0, right = n - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == x) {
return mid;
} else if (arr[mid] < x) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

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

for (int i = 0; i < n; i++) {
arr[i] = rand() % (n * 2);
}
}

int main() {
int N[] = {100, 1000, 10000, 100000};
int num_searches = 10000;
srand(time(NULL));

printf("N\t\tLinear search\tBinary search\n");

for (int i = 0; i < 4; i++) {

int n = N[i];
int arr[n];
fill_random_array(arr, n);

clock_t start, end;

double linear_time, binary_time;

start = clock();
for (int j = 0; j < num_searches; j++) {
int x = rand() % (n * 2);
linear_search(arr, n, x);
}
end = clock();
linear_time = (double)(end - start) / CLOCKS_PER_SEC;

qsort(arr, n, sizeof(int), compare);

start = clock();
for (int j = 0; j < num_searches; j++) {
int x = rand() % (n * 2);
 binary_search(arr, n, x);
}
end = clock();
binary_time = (double)(end - start)/CLOCKS_PER_SEC;

printf("%d\t\t%.6f\t\t%.6f\n", n, linear_time, binary_time);

}

return 0;
}

3.1
#include <stdio.h>

unsigned long long fib(int n) {

unsigned long long a = 0, b = 1, c;
if (n == 0) {
return a;
}
for (int i = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
return b;
}

int main() {
int n;
printf("Al catalea termen in cautam: ");
scanf("%d",&n);
unsigned long long result = fib(n);
printf("Al %d-lea termen Fibonacci este %llu", n, result);
return 0;
}

3.2
#include <stdio.h>
#include <time.h>

unsigned long long fib(int n) {

unsigned long long a = 0, b = 1, c;
if (n == 0) {
return a;
}
for (int i = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
return b;
}

int main() {
int n[] = {50, 100, 1000, 10000, 100000, 1000000};
int num_elements = sizeof(n) / sizeof(n[0]);

printf("N\tTimp (ms)\n");

for (int i = 0; i < num_elements; i++) {

clock_t start = clock();
unsigned long long result = fib(n[i]);
 clock_t end = clock();
double time_spent = (double)(end - start) / CLOCKS_PER_SEC * 1000;
printf("%d\t%f\n", n[i], time_spent);
}

return 0;
}