This gist contains the implementation of sort algorithms in C

Sort Algorithms

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

void bubbleSort(int arr[], int count);
void quicksort(int arr[], int left, int right);
void insertionSort(int arr[], int count);
void selectionSort(int arr[], int count);
void shellSort(int arr[], int count);
void heapSort(int arr[], int count);
void cresce_heap(int *, int, int);
void printVector(int *, int count);

int main(){
    int option, count, *vector, *clone;
    clock_t t1, t2;
    int exec = 1;
    
    while(exec){
        printf("\n\n1. Gerar Vetor\n2. Ordenar - Buble Sort\n3. Ordenar - Quick Sort\n4. Ordenar - Insert Sort\n5. Ordenar - Select Sort\n6. Ordenar - Shell Sort\n7. Ordenar - Heap Sort\n8. Ordenar e comparar\n9. Sair\n");

        scanf("%d", &option);

        switch(option){
            case 1://Create vector
                printf("\n\nDigite a quantidade de elementos: ");
                scanf("%i", &count);
                vector = (int *) malloc(count * sizeof(int));

                for(int i = 0; i< count; i++){
                    vector[i] = rand() % count;
                }
                // for(int i = 0; i< count; i++){
                //     printf("%i ", vector[i]);
                // }
                break;
            case 2://Bubble Sort
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                bubbleSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 3://Quick Sort
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                quicksort(clone, 0, count-1);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 4://Insert Sort
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                insertionSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 5://Select Sort
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                selectionSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 6://Shell Sort
            clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                shellSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 7://Heap Sort
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                t1 = clock();
                heapSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                printf("Vetor primário\n");
                printVector(vector, count);
                printf("\n\nVetor Ordenado\n");
                printVector(clone, count);
                free(clone);

                break;
            case 8://Sort and compare
                clone = (int *) malloc(count * sizeof(int));
                for(int i = 0; i< count; i++){
                    clone[i] = vector[i];
                }
                printf("Bubble Sort\n");
                t1 = clock();
                bubbleSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);
                
                printf("Quick Sort\n");
                t1 = clock();
                quicksort(clone, 0, count-1);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);

                printf("Insert Sort\n");
                t1 = clock();
                insertionSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);

                printf("Select Sort\n");
                t1 = clock();
                selectionSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);

                printf("Shell Sort\n");
                t1 = clock();
                shellSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);

                printf("Heap Sort\n");
                t1 = clock();
                heapSort(clone, count);
                t2 = clock();
                printf("Tempo para executar: %.3f ms\n\n", ((double)(t2-t1) / CLOCKS_PER_SEC) * 1000);

                break;
            case 9://exit
                exec = 0;
                break;
            default:
                printf("\n\nEscolha uma opção válida...");
                break;
        }
    }

    return 0;
}

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

void heapSort (int arr[], int count) {
    int e, d, x, i;
    d = count; e = (d / 2);

    while (e > 0) {
        cresce_heap (arr, e, d); e--;
    }

    while (d >= 1) {
        x = arr[0];
        arr[0] = arr[d - 1];
        arr[d - 1] = x;
        d--;
        cresce_heap (arr, 1, d);
    }
}

void cresce_heap (int *A, int e, int d) {
    int i, j, naoachou, x;
    i = e; j = 2 * i; naoachou = 1;
    x = A[i - 1];

    while ((j <= d) && (naoachou == 1)) {
        if (j < d){
            if (A[j - 1] < A[j]){
                j++;
            }
        }

        if (x < A[j - 1]) {
            A[i - 1] = A[j - 1];
            i = j; j = 2 * i;
        }else{
            naoachou = 0;
        }
    }
    A[i - 1] = x;
}

void shellSort(int arr[], int count){
    int gap, i, j, temp;

    for (gap = count / 2; gap > 0; gap /= 2) {
        for (i = gap; i < count; i++) {
            for (j = i - gap; j >= 0 && arr[j] > arr[j + gap]; j -= gap) {
                temp = arr[j];
                arr[j] = arr[j + gap];
                arr[j + gap] = temp;
            }   
        }   
    }   
}

void selectionSort(int arr[], int count) {
    if(count == 1)
        return;
    
    int largest = 0;
    int largest_position = 0;
    int i;
    
    for(i = 0; i < count; i++) {
        if(arr[i] > largest) {
            largest = arr[i];
            largest_position = i;
        }
    }
    
    arr[largest_position] = arr[count - 1];
    arr[count - 1] = largest;
    
    selectionSort(arr, count - 1);
}

void insertionSort (int arr[], int count) {
	for (int i = 1; i < count; i++) {
		for (int j = i; j > 0 && arr[j] < arr[j-1]; j--) {
			// swap(arr, j, j-1);
            int aux = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = aux;
		}
	}
}

void quicksort(int arr[], int left, int right) {
  if(left >= right) return;
  int i = left, j = right;
  int tmp, pivot = arr[i];
  for(;;) {
    while(arr[i] < pivot) i++;
    while(pivot < arr[j]) j--;
    if(i >= j) break;
    tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
    i++; j--;
  }
  quicksort(arr, left, i-1);
  quicksort(arr, j+1, right);
}

void bubbleSort(int arr[], int count){
    int i = count, j;
    int temp;

    while(i > 0)
    {
        for(j = 0; j < i - 1; j++)
        {
            if(arr[j] > arr[j + 1])
            {   temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        i--;
    }
}