diff --git a/Comte-rendu.md b/Comte-rendu.md
new file mode 100644
index 0000000..cfee5d4
--- /dev/null
+++ b/Comte-rendu.md
@@ -0,0 +1,20 @@
+##Patrick Felix-Vimalaratnam
+
+J'ai compilé avec :
+    gcc -g -pg -o student_rank student_rank.c heapsort.c bubblesort.c
+
+puis j'ai lancé :
+    ./student_rank 1000 1000 0
+
+Dans le fichier gmon.out donner avec la commande gprof, il y a :
+    - un tableau pour avoir le temps d'execution et le nombre d'appel de chaque fonctions appelées dan sle code avec une légende de chaque colonne du tableau.
+    - un autre tableau mais avec un graphe de chaque appel avec aussi une légende de chaque colonne.
+    - un ordre d'appel de fonction avec le nom de la fonction.
+
+Il fallait supprimer l'appel à bubble_sort dans la fonction find_rank_student du fichier student_rank.
+
+Pour coriger le probleme de bubble sort il faut changer la condition d'arret du do while de égale à 1 à supérieur à 0.
+
+Utiliser heapsort est plus rapide qu'avec bubblesort.
+
+Tentative de quicksort mais je n'ai pas réussi à faire le threading.
\ No newline at end of file
diff --git a/bubblesort.c b/bubblesort.c
index a848827..1e88188 100644
--- a/bubblesort.c
+++ b/bubblesort.c
@@ -17,5 +17,5 @@ void bubblesort(int* array, int length)
 				swapped++;
 			}
 		}
-	} while(swapped==1);
+	} while(swapped>0);
 }
diff --git a/gmon.out b/gmon.out
new file mode 100644
index 0000000..9aba743
Binary files /dev/null and b/gmon.out differ
diff --git a/quicksort.c b/quicksort.c
new file mode 100644
index 0000000..230da5c
--- /dev/null
+++ b/quicksort.c
@@ -0,0 +1,28 @@
+#include "quicksort.h"
+
+void quicksort(int* tab, int first, int last) {
+    int pivot, i, j, tmp;
+    if(first < last) {
+        pivot = first;
+        i = first;
+        j = last;
+        while (i < j) {
+            while(tab[i] <= tab[pivot] && i < last){
+                i++;
+            }
+            while(tab[j] > tab[pivot]){
+                j--;
+            }
+            if(i < j) {
+                tmp = tab[i];
+                tab[i] = tab[j];
+                tab[j] = tmp;
+            }
+        }
+        tmp = tab[pivot];
+        tab[pivot] = tab[j];
+        tab[j] = tmp;
+        quicksort(tab, first, j - 1);
+        quicksort(tab, j + 1, last);
+    }
+}
diff --git a/quicksort.h b/quicksort.h
new file mode 100644
index 0000000..e47fc61
--- /dev/null
+++ b/quicksort.h
@@ -0,0 +1,6 @@
+#ifndef __QUICKSORT__
+#define __QUICKSORT__
+
+void quicksort(int* tab, int first, int last);
+
+#endif
diff --git a/student_rank b/student_rank
new file mode 100755
index 0000000..8089fcb
Binary files /dev/null and b/student_rank differ
diff --git a/student_rank.c b/student_rank.c
index af84003..8f95581 100644
--- a/student_rank.c
+++ b/student_rank.c
@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #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,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);
+        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);