diff --git a/Compte Rendu/README.md b/Compte Rendu/README.md
new file mode 100644
index 0000000..fe91989
--- /dev/null
+++ b/Compte Rendu/README.md
@@ -0,0 +1,90 @@
+# Test
+
+J'ai lancé l'algo avec 100k étudiants et 1k notes
+ça prends du temps...
+
+Pour 100 et 100 ça marche bien,
+pour 1k et 1k ça prends 3s~
+Pour 5k étudiants, ça a pris... pas eu le temps de finir
+
+On va donc prendre 1k étudiants et 1k notes pour le profiling
+
+
+
+# Partie gprof
+
+### Flat profile
+
+le temps et nombre dexecutions par fonction
+
+### Call graph
+
+Voir l'arbre d'appel, le temps et nombre d'appel par fonction
+
+## Analyse
+
+Le plus de temps a été pris par bubblesort
+
+
+Flat Profile
+ % cumulative self self total
+ time seconds seconds calls s/call s/call name
+ 78.10 2.30 2.30 1001000 0.00 0.00 bubblesort
+ 21.05 2.92 0.62 1000000 0.00 0.00 find_rank_student
+ 1.02 2.96 0.03 1 0.03 2.96 sort_students
+ 0.00 2.96 0.00 1000 0.00 0.00 generate_array
+ 0.00 2.96 0.00 2 0.00 0.00 free_array
+ 0.00 2.96 0.00 1 0.00 0.00 generate_grades
+ 0.00 2.96 0.00 1 0.00 0.00 generate_ranks
+
+
+
+Call Graph
+index % time self children called name
+ 0.03 2.92 1/1 main [2]
+[1] 100.0 0.03 2.92 1 sort_students [1]
+ 0.62 2.30 1000000/1000000 find_rank_student [3]
+ 0.00 0.00 1000/1001000 bubblesort [4]
+-----------------------------------------------
+
+[2] 100.0 0.00 2.96 main [2]
+ 0.03 2.92 1/1 sort_students [1]
+ 0.00 0.00 2/2 free_array [6]
+ 0.00 0.00 1/1 generate_grades [7]
+ 0.00 0.00 1/1 generate_ranks [8]
+-----------------------------------------------
+ 0.62 2.30 1000000/1000000 sort_students [1]
+[3] 98.9 0.62 2.30 1000000 find_rank_student [3]
+ 2.30 0.00 1000000/1001000 bubblesort [4] <-- gros probleme ici
+-----------------------------------------------
+ 0.00 0.00 1000/1001000 sort_students [1]
+ 2.30 0.00 1000000/1001000 find_rank_student [3] <-- gros probleme ici
+[4] 78.0 2.30 0.00 1001000 bubblesort [4] <-- gros probleme ici
+-----------------------------------------------
+ 0.00 0.00 1000/1000 generate_grades [7]
+[5] 0.0 0.00 0.00 1000 generate_array [5]
+-----------------------------------------------
+ 0.00 0.00 2/2 main [2]
+[6] 0.0 0.00 0.00 2 free_array [6]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [2]
+[7] 0.0 0.00 0.00 1 generate_grades [7]
+ 0.00 0.00 1000/1000 generate_array [5]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [2]
+[8] 0.0 0.00 0.00 1 generate_ranks [8]
+-----------------------------------------------
+
+
+
+## Changements dans le code
+
+Un bubblesort inutile se trouvait dans la fonction find_rank_student, après l'avoir retiré ça passe à 0.4s.
+Mais maintenant c'est buggé
+
+pour faire ce changement il faut changer while(swapped==1);
+car c'est possible qu'il faut faire plusieurs changements, donc il faut le changer en : while(swapped>0)
+
+# Passer au heapsort
+
+c'est rapide
\ No newline at end of file
diff --git a/bubblesort.c b/bubblesort.c
index a848827..94071bf 100644
--- a/bubblesort.c
+++ b/bubblesort.c
@@ -17,5 +17,5 @@ void bubblesort(int* array, int length)
swapped++;
}
}
- } while(swapped==1);
-}
+ } while(swapped>0);
+}
\ No newline at end of file
diff --git a/gmon.out b/gmon.out
new file mode 100644
index 0000000..133922a
Binary files /dev/null and b/gmon.out differ
diff --git a/quicksort.c b/quicksort.c
new file mode 100644
index 0000000..cf8c99b
--- /dev/null
+++ b/quicksort.c
@@ -0,0 +1,42 @@
+#include
+#include
+
+
+void swap(int* intArray, int num1, int num2) {
+ int temp = intArray[num1];
+ intArray[num1] = intArray[num2];
+ intArray[num2] = temp;
+}
+
+int partition(int* intArray, int left, int right, int pivot) {
+ int leftPointer = left - 1;
+ int rightPointer = right;
+ while (true) {
+ while (intArray[++leftPointer] < pivot) {
+ //do nothing
+ }
+ while (rightPointer > 0 && intArray[--rightPointer] > pivot) {
+ //do nothing
+ }
+
+ if (leftPointer >= rightPointer) {
+ break;
+ } else {
+ swap(intArray, leftPointer, rightPointer);
+ }
+ }
+
+ swap(intArray, leftPointer, right);
+ return leftPointer;
+}
+
+void quicksort(int* array, int left, int right) {
+ if (right - left <= 0) {
+ return;
+ } else {
+ int pivot = array[right];
+ int partitionPoint = partition(array, left, right, pivot);
+ quicksort(array, left, partitionPoint - 1);
+ quicksort(array, partitionPoint + 1, right);
+ }
+}
\ No newline at end of file
diff --git a/quicksort.h b/quicksort.h
new file mode 100644
index 0000000..c12c751
--- /dev/null
+++ b/quicksort.h
@@ -0,0 +1,8 @@
+#ifndef __QUICKSORT__
+#define __QUICKSORT__
+
+void quicksort(int* array, int left, int right);
+int partition(int left, int right, int pivot);
+void swap(int num1, int num2);
+
+#endif
\ No newline at end of file
diff --git a/student_rank b/student_rank
new file mode 100755
index 0000000..0a35662
Binary files /dev/null and b/student_rank differ
diff --git a/student_rank.c b/student_rank.c
index af84003..4a58727 100644
--- a/student_rank.c
+++ b/student_rank.c
@@ -5,6 +5,7 @@
#include
#include "heapsort.h"
#include "bubblesort.h"
+#include "quicksort.h"
void generate_grades(int** students_array, int students_number, int grades_number)
{
@@ -55,7 +56,6 @@ 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,7 @@ void sort_students(int** students_rank, int** students_array, int students_numbe
{
grades[j] = students_array[j][i];
}
- bubblesort(grades,students_number);
+ quicksort(grades, 0, students_number-1);
for(j = 0; j < students_number; j++)
{
students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);