ajout td1

bubblesort.c

@@ -17,5 +17,5 @@ void bubblesort(int* array, int length)
 				swapped++;
 			}
 		}
-	} while(swapped==1);
+	} while(swapped > 0);
 }

heapsort.c

@@ -78,3 +78,55 @@ void generate_array(int* array, int length)
         array[i] = rand() % 20 + 1;
     }
 }
+
+
+
+
+void echanger(int *a, int *b) {
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+int partitionner(int T[], int premier, int dernier, int pivot) {
+    echanger(&T[pivot], &T[dernier]);  // Échanger le pivot avec le dernier élément
+    int j = premier;
+    
+    for (int i = premier; i < dernier; i++) {
+        if (T[i] <= T[dernier]) {
+            echanger(&T[i], &T[j]);
+            j++;
+        }
+    }
+
+    echanger(&T[dernier], &T[j]);  // Placer le pivot à sa position finale
+    return j;
+}
+
+int choix_pivot(int T[], int premier, int dernier) {
+    // Pour simplifier, on choisit simplement le dernier élément comme pivot
+    return dernier;
+}
+
+void tri_rapide(int T[], int premier, int dernier) {
+    if (premier < dernier) {
+        int pivot = choix_pivot(T, premier, dernier);
+        pivot = partitionner(T, premier, dernier, pivot);
+        tri_rapide(T, premier, pivot - 1);
+        tri_rapide(T, pivot + 1, dernier);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+

heapsort.h

@@ -5,4 +5,11 @@ void heapsort(int* array, int length);
 void generate_array(int* array, int length);
 void print_array(int* array, int length);
 
+void echanger(int *a, int *b);
+int partitionner(int T[], int premier, int dernier, int pivot);
+int choix_pivot(int T[], int premier, int dernier);
+void tri_rapide(int T[], int premier, int dernier);
+
+
+
 #endif

rendu.txt

@@ -0,0 +1,24 @@
+En compilant ./student_rank avec 1000 élèves et 1000 notes, on a remarqué que le temps d'exécution était environ 3s. 
+
+En utilisant gprof ./student_rank, on a pu voir que la fonction bubblesort prenait 77.50% du temps d'exécution soit 2.29s avec 1 001 000 appel de la fonction contre 1 000 000 pour la fonction find_rank_student qui prend 20.98% du temps total.
+
+gprof affiche le Flat Profile qui permet de mesurer le temps et le nombre d'exécution par fonction.
+Il affiche aussi le Call Graph qui permet de visualiser les appels de fonctions (qui appel qui) et son nombre d'exécution par fonctions.
+
+Ici, bubblesort est trop lente et a nombre important d'appel dans la fonction find_rank_student.
+
+L'idée est donc d'optimiser le nombre d'appel dans la fonction find_rank_student.
+
+En observant le code, l'appel de bubblesort dans la fonction find_rank_student était inutile. En le retirant, le programme ne prend plus que 0.079s. Le problème maintenant, c'est que le codeest bug.
+
+Le problème était dans la fonction bubblesort qui déterminait une liste trié quand le nombre de swap (de changement dans le tri à bulle) n'était pas égal à 1. En modifiant par > 0, cela fonctionne.
+
+En utilisant gprof, on se rend compte que le programme prend autant de temps mais utilise moins d'appel. (1000 contre 1 000 000)
+
+Pour optimiser le code,  on peut utiliser un autre algo de tri comme heapsort.
+
+Dans le fichier heapsort.c, des fonctions d'un algo de tri plus rapide sont disponibles : quicksort. 
+
+
+
+

student_rank.c

@@ -55,7 +55,7 @@ int find_rank_student(int student_grade, int* grades_array, int students_number)
 {
     int position = -1;
     int i = 0;
-    bubblesort(grades_array,students_number);
+     
     for(i = students_number-1; i >= 0; i--)
     {
         if(grades_array[i] == student_grade)
@@ -77,7 +77,8 @@ void sort_students(int** students_rank, int** students_array, int students_numbe
 	{
 	    grades[j] = students_array[j][i];
 	}
-        bubblesort(grades,students_number);
+	/*heapsort(grades,students_number);*/
+        tri_rapide(grades, 200, 210);
 	for(j = 0; j < students_number; j++)
 	{
             students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);