#include <stdio.

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

void bubbleSort(int *vector, size_t size) {

int flag = 0;
do {
flag = 0;
int i;
for (i = 0; i < size - 1; i++) {
if (vector[i] > vector[i + 1]) {
flag = 1;
int aux = vector[i];
vector[i] = vector[i + 1];
vector[i + 1] = aux;
}
}
} while (flag);
}

void shellSort(int *vector, size_t size) {

int i = 0;
for (i = size / 2; i > 0; i = i / 2) {
int j;
for (j = i; j < size; j++) {
int temp = vector[j];
int k;
for (k = j; k >= i && vector[k - i] > temp; k = k - i) {
vector[k] = vector[k - i];
}
vector[k] = temp;
}
}
}

int partition(int a[], int l, int r) {

int pivot, i, j, t;
pivot = a[l];
i = l;
j = r + 1;

while (1) {
do ++i; while (a[i] <= pivot && i <= r);
do --j; while (a[j] > pivot);
if (i >= j) break;
t = a[i];
a[i] = a[j];
a[j] = t;
}
t = a[l];
a[l] = a[j];
a[j] = t;
return j;
}

void quickSort(int a[], int l, int r) {

int j;

if (l < r) {
 j = partition(a, l, r);
quickSort(a, l, j - 1);
quickSort(a, j + 1, r);
}

void merge(int *A, int *L, int leftCount, int *R, int rightCount) {
int i, j, k;
i = 0;
j = 0;
k = 0;
while (i < leftCount && j < rightCount) {
if (L[i] < R[j]) A[k++] = L[i++];
else A[k++] = R[j++];
}
while (i < leftCount) A[k++] = L[i++];
while (j < rightCount) A[k++] = R[j++];
}

void mergeSort(int *A, int n) {

int mid, i, *L, *R;
if (n < 2) return;
mid = n / 2;
L = (int *) malloc(mid * sizeof(int));
R = (int *) malloc((n - mid) * sizeof(int));
for (i = 0; i < mid; i++) L[i] = A[i];
for (i = mid; i < n; i++) R[i - mid] = A[i];
mergeSort(L, mid);
mergeSort(R, n - mid);
merge(A, L, mid, R, n - mid);
free(L);
free(R);
}

void siftDown(int numbers[], int root, int bottom) {

int done, maxChild, temp;

done = 0;
while ((root * 2 <= bottom) && (!done)) {
if (root * 2 == bottom)
maxChild = root * 2;
else if (numbers[root * 2] > numbers[root * 2 + 1])
maxChild = root * 2;
else
maxChild = root * 2 + 1;

if (numbers[root] < numbers[maxChild]) {

temp = numbers[root];
numbers[root] = numbers[maxChild];
numbers[maxChild] = temp;
root = maxChild;
} else
done = 1;
}
}

void heapSort(int numbers[], int array_size) {

int i, temp;
 for (i = (array_size / 2) - 1; i >= 0; i--)
siftDown(numbers, i, array_size);

for (i = array_size - 1; i >= 1; i--) {

temp = numbers[0];
numbers[0] = numbers[i];
numbers[i] = temp;
siftDown(numbers, 0, i - 1);
}
}

void checkIfVectorIsSorted(int *vector, size_t size) {

int i = 0;
int flag = 0;
for (i = 0; i < size - 1; i++) {
if (vector[i] > vector[i + 1])
flag = 1;
}
if (flag) printf("Vectorul nu a fost sortat ok\n");
}

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

if (*(int *) a < *(int *) b) return -1;
if (*(int *) a == *(int *) b) return 0;
if (*(int *) a > *(int *) b) return 1;
}

int main() {
srand(time(NULL));
printf("introduceti dimensiunea vectorului: ");
int n;
scanf("%d", &n);
int i = 0;
int *vector;
vector = malloc(sizeof(int) * n);
for (i = 0; i < n; i++) {
vector[i] = 0;
}
for (i = 0; i < n; i++) {
int ran = rand();
// if (!ran) {
// i--;
// continue;
// }
// int k = 0;
// int exist = 0;
// for (k = 0; k < i; k++) {
// if (vector[k] == ran) {
// exist = 1;
// }
// }
// if (exist) {
// i--;
// continue;
// }
vector[i] = ran;
}
 printf("a inceput sortarea\n");
bubbleSort(vector, n);
// shellSort(vector, n);
// quickSort(vector, 0, n);
// mergeSort(vector, n);
// heapSort(vector, n);
// qsort(vector, n, sizeof(int), &compareInt); //qsort implementarea din
biblioteca standard C
int notOk = 0;
for (i = 0; i < n; i++) {
int j;
for (j = i + 1; j < n; j++) {
if (vector[i] == vector[j]) {
notOk = 1;
}
}
}
if (notOk) printf("Vectorul suprapune valorile\n");
checkIfVectorIsSorted(vector, n);
for (i = 0; i < n; i++) {
printf("%d ", vector[i]);
}
free(vector);

return 0;
}