test SAE2.02

algo.c

@@ -1,100 +1,179 @@
+#include <stdio.h>
+#include <stdlib.h>
 #include <time.h>
 
-void algo1(int tab[], int nb);
-void algo2(int tab[], int nb);
-void algo3(int tab[], int n);
 
-void algo1(int tab[], int nb){
-	int echange = 1;
-	int i;
-	int deb = 0, fin = nb-1; 
-
-	while(echange>0){
-		echange=0; 
-		for(i=deb; i < fin; i++){
-			if(tab[i]> tab[i+1]){
-				echanger(tab, i, i+1);
-				echange++;
-			}
-		}
-		fin--;
-		for(i=fin; i > deb;i--){
-			if(tab[i]< tab[i-1]){
-				echanger(tab, i, i-1);
-				echange++;
-			}
-		}
-		deb++;
-	}	
-}
 
 void echanger(int tab[], int i, int j){
-	int tmp;
-tmp = tab[j];
-tab[i] = tab[j];
-tab[j] = tmp;
+    int tmp;
+    tmp = tab[j];
+    tab[j] = tab[i];
+    tab[i] = tmp;
+}
+
+void algo1(int tab[], int nb){
+    int echange = 1;
+    int i;
+    int deb = 0, fin = nb-1;
+    while(echange>0){
+        echange=0;
+        for(i=deb; i < fin; i++){
+            if(tab[i]> tab[i+1]){
+                echanger(tab, i, i+1);
+                echange++;
+            }
+        }
+        fin--;
+        for(i=fin; i > deb;i--){
+            if(tab[i]< tab[i-1]){
+                echanger(tab, i, i-1);
+                echange++;
+            }
+        }
+        deb++;
+    }
 }
 
 void algo2(int tab[], int nb){
-	int *cpt;
-	int min = tab[0], max = tab[0];
-	int i, j;
+    int *cpt;
+    int min = tab[0], max = tab[0];
+    int i, j;
+    for(i=1; i < nb; i++){
+        if(min > tab[i]) min = tab[i];
+        if(max < tab[i]) max = tab[i];
+    }
+    cpt = (int*)calloc((max-min+1), sizeof(int));
+    if(cpt == NULL){
+        printf("pb aloc mémoire\n");
+        exit(1);
+    }
+    for(i = 0; i < nb; i++){
+        cpt[tab[i]-min]++;
+    }
+    j=0;
+    for(i = 0; i < max-min+1; i++){
+        while(cpt[i] != 0){
+            tab[j] = i+min;
+            j++;
+            cpt[i]--;
+        }
+    }
+    free(cpt);
+}
 
-	for(i=1; i < nb; i++){
-		if(min > tab[i]) min = tab[i];
-		if(max < tab[i]) max = tab[i];
-	}
+int recherchePos(int tab[], int n, int val){
+    int i ;
+    for(i = 0 ; i < n ; i++){
+        if(val < tab[i]){
+            return i ;
+        }
+    }
+    return i ;
+}
 
-	cpt = (int*)calloc((max-min+1), sizeof(int));
-	if(cpt == NULL){
-		printf(“pb aloc mémoire\n”);
-		exit(1);
-	}
-	for(i = 0; i < nb; i++){
-		cpt[tab[i]-min]++;
+void algo3(int tab[], int n){
+    int i, pos, j, tmp;
+    for(i = 1; i < n; i++){
+        pos = recherchePos(tab, i, tab[i]);
+        if(pos != i){
+            tmp = tab[i];
+            for(j = i; j > pos; j--){
+                tab[j] = tab[j-1];
+            }
+            tab[pos] = tmp;
+        }
+    }
+}
+
+int main(){
+    int i, j, n, *tab, *tab2, *tab3;
+    clock_t start, end;
+    double time_used;
+
+    srand(time(NULL)); // initialisation de la graine pour les nombres aléatoires
+
+    // Tableau aléatoire
+    for(n = 100; n <= 1000; n += 100){
+        tab = (int*)malloc(n*sizeof(int));
+        for(i = 0; i < n; i++){
+            tab[i] = rand()%1000; // nombres aléatoires entre 0 et 999
+        }
+
+        start = clock();
+        algo1(tab, n);
+        end = clock();
+        time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+
+		start = clock();
+		algo2(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo2 sur un tableau aléatoire de taille %d : %lf secondes\n", n, time_used);
+
+		start = clock();
+		algo3(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo3 sur un tableau aléatoire de taille %d : %lf secondes\n", n, time_used);
+
+		free(tab);
 	}
 
-	j=0;
-	for(i = 0; i < max-min+1; i++){
-		while(cpt[i] != 0){
-			tab[j] = i+min;
-			j++;
-			cpt[i]--;
+	// Tableau trié par ordre croissant
+	for(n = 100; n <= 1000; n += 100){
+		tab = (int*)malloc(n*sizeof(int));
+		for(i = 0; i < n; i++){
+			tab[i] = i;
 		}
+
+		start = clock();
+		algo1(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo1 sur un tableau trié par ordre croissant de taille %d : %lf secondes\n", n, time_used);
+
+		start = clock();
+		algo2(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo2 sur un tableau trié par ordre croissant de taille %d : %lf secondes\n", n, time_used);
+
+		start = clock();
+		algo3(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo3 sur un tableau trié par ordre croissant de taille %d : %lf secondes\n", n, time_used);
+
+		free(tab);
 	}
-	free(cpt);
-}
 
-void algo3(int tab[], int n){
-	int i, pos, j, tmp;
-	for(i = 1; i < n; i++){
-		pos = rechercherPos(tab, i, tab[i]);
-		if(pos != i){
-			tmp = tab[i];
-			for(j = i; j > pos; j--){
-				tab[j] = tab[j-1];
-			}
-			tab[pos] = tmp;
+	// Tableau trié par ordre décroissant
+	for(n = 100; n <= 1000; n += 100){
+		tab = (int*)malloc(n*sizeof(int));
+		for(i = 0; i < n; i++){
+			tab[i] = n-i;
 		}
-	}
-}
 
-int recherchePos(int tab[], int n, int val){
-	int i ;
+		start = clock();
+		algo1(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo1 sur un tableau trié par ordre décroissant de taille %d : %lf secondes\n", n, time_used);
 
-	for(i = 0 ; i < n ; i++){
-		if(val < tab[i]){
-			return i ;
-		}
-	}
-	return i ;
-}
+		start = clock();
+		algo2(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo2 sur un tableau trié par ordre décroissant de taille %d : %lf secondes\n", n, time_used);
 
+		start = clock();
+		algo3(tab, n);
+		end = clock();
+		time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+		printf("Temps d'exécution d'algo3 sur un tableau trié par ordre décroissant de taille %d : %lf secondes\n", n, time_used);
 
-int main() {
+		free(tab);
+	}
 
-    // algo1();
-    // algo2();
-    // algo3();
-    return 1;
+	return 0; //attentions
 }

algo.h

@@ -1 +0,0 @@
-#

algo1.c

@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void echanger(int tab[], int i, int j){
+    int tmp;
+    tmp = tab[j];
+    tab[j] = tab[i];
+    tab[i] = tmp;
+}
+
+void algo1(int tab[], int nb){
+    int echange = 1;
+    int i;
+    int deb = 0, fin = nb-1;
+    while(echange>0){
+        echange=0;
+        for(i=deb; i < fin; i++){
+            if(tab[i]> tab[i+1]){
+                echanger(tab, i, i+1);
+                echange++;
+            }
+        }
+        fin--;
+        for(i=fin; i > deb;i--){
+            if(tab[i]< tab[i-1]){
+                echanger(tab, i, i-1);
+                echange++;
+            }
+        }
+        deb++;
+    }
+}
+
+void algo2(int tab[], int nb){
+    int *cpt;
+    int min = tab[0], max = tab[0];
+    int i, j;
+    for(i=1; i < nb; i++){
+        if(min > tab[i]) min = tab[i];
+        if(max < tab[i]) max = tab[i];
+    }
+    cpt = (int*)calloc((max-min+1), sizeof(int));
+    if(cpt == NULL){
+        printf("pb aloc mémoire\n");
+        exit(1);
+    }
+    for(i = 0; i < nb; i++){
+        cpt[tab[i]-min]++;
+    }
+    j=0;
+    for(i = 0; i < max-min+1; i++){
+        while(cpt[i] != 0){
+            tab[j] = i+min;
+            j++;
+            cpt[i]--;
+        }
+    }
+    free(cpt);
+}
+
+int recherchePos(int tab[], int n, int val){
+    int i ;
+    for(i = 0 ; i < n ; i++){
+        if(val < tab[i]){
+            return i ;
+        }
+    }
+    return i ;
+}
+
+void algo3(int tab[], int n){
+    int i, pos, j, tmp;
+    for(i = 1; i < n; i++){
+        pos = recherchePos(tab, i, tab[i]);
+        if(pos != i){
+            tmp = tab[i];
+            for(j = i; j > pos; j--){
+                tab[j] = tab[j-1];
+            }
+            tab[pos] = tmp;
+        }
+    }
+}
+
+void test_1() {
+    int nb;
+    printf("Entrez le nombre d'éléments du tableau : ");
+    scanf("%d", &nb);
+
+    int tab[nb];
+
+    // Génère un tableau d'éléments avec des nombres aléatoires entre 1 et 100
+    srand(time(NULL));
+    for (int i = 0; i < nb; i++) {
+        tab[i] = rand() % 100 + 1;
+    }
+
+    clock_t debut = clock(); // Début du chronomètre
+    algo1(tab, nb); // Appel de la fonction à tester
+    clock_t fin = clock(); // Fin du chronomètre
+    double temps_execution = (double)(fin - debut) / CLOCKS_PER_SEC; // Calcul du temps d'exécution
+
+    printf("Temps d'execution : %f secondes\n", temps_execution); // Affichage du temps d'exécution
+}
+
+
+void test_2() {
+    int nb;
+    printf("Entrez le nombre d'éléments du tableau : ");
+    scanf("%d", &nb);
+
+    int tab[nb];
+
+    // Génère un tableau d'éléments avec des nombres aléatoires entre 1 et 100
+    srand(time(NULL)); 
+    for (int i = 0; i < nb; i++) {
+        tab[i] = rand() % 100 + 1;
+    }
+
+    clock_t debut = clock(); // Début du chronomètre
+    algo2(tab, nb); // Appel de la fonction à tester
+    clock_t fin = clock(); // Fin du chronomètre
+    double temps_execution = (double)(fin - debut) / CLOCKS_PER_SEC; // Calcul du temps d'exécution
+
+    printf("Temps d'execution : %f secondes\n", temps_execution); // Affichage du temps d'exécution
+}
+
+void test_3(){
+    int nb;
+    printf("Entrez le nombre d'éléments du tableau : ");
+    scanf("%d", &nb);
+
+    int tab[nb];
+
+    // Génère un tableau d'éléments avec des nombres aléatoires entre 1 et 100
+    srand(time(NULL)); 
+    for (int i = 0; i < nb; i++) {
+        tab[i] = rand() % 100 + 1;
+    }
+
+    clock_t debut = clock(); // Début du chronomètre
+    algo3(tab, nb); // Appel de la fonction à tester
+    clock_t fin = clock(); // Fin du chronomètre
+    double temps_execution = (double)(fin - debut) / CLOCKS_PER_SEC; // Calcul du temps d'exécution 
+
+    printf("Temps d'execution : %f secondes\n", temps_execution); // Affichage du temps d'exécution
+}
+
+int main(){
+    //test_1();
+    //test_2();
+    //test_3();
+    return 0;
+}