riera/TD1_DEV51_Qualite_Algo
1
0
Fork 0
forked from menault/TD1_DEV51_Qualite_Algo
Code Pull Requests Activity

TD1

Browse Source
This commit is contained in:
Damien RIERA
2025-09-10 17:24:01 +02:00
parent ca552281c9
commit dd0498e954
7 changed files with 144 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
Compte Rendu/README.md Normal file
View File

@@ -0,0 +1,90 @@
# Test
J'ai lancé l'algo avec 100k étudiants et 1k notes<br>
ça prends du temps...
Pour 100 et 100 ça marche bien,<br>
pour 1k et 1k ça prends 3s~<br>
Pour 5k étudiants, ça a pris... pas eu le temps de finir<br>
On va donc prendre 1k étudiants et 1k notes pour le profiling <br>
<br>
# 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
<details>
<summary>Flat Profile</summary>
% cumulative self self total <br>
time seconds seconds calls s/call s/call name <br>
78.10 2.30 2.30 1001000 0.00 0.00 bubblesort<br>
21.05 2.92 0.62 1000000 0.00 0.00 find_rank_student<br>
1.02 2.96 0.03 1 0.03 2.96 sort_students<br>
0.00 2.96 0.00 1000 0.00 0.00 generate_array<br>
0.00 2.96 0.00 2 0.00 0.00 free_array<br>
0.00 2.96 0.00 1 0.00 0.00 generate_grades<br>
0.00 2.96 0.00 1 0.00 0.00 generate_ranks<br>
</details>
<br>
<details>
<summary>Call Graph</summary>
index % time self children called name<br>
0.03 2.92 1/1 main [2]<br>
[1] 100.0 0.03 2.92 1 sort_students [1]<br>
0.62 2.30 1000000/1000000 find_rank_student [3]<br>
0.00 0.00 1000/1001000 bubblesort [4]<br>
-----------------------------------------------<br>
<spontaneous><br>
[2] 100.0 0.00 2.96 main [2]<br>
0.03 2.92 1/1 sort_students [1]<br>
0.00 0.00 2/2 free_array [6]<br>
0.00 0.00 1/1 generate_grades [7]<br>
0.00 0.00 1/1 generate_ranks [8]<br>
-----------------------------------------------<br>
0.62 2.30 1000000/1000000 sort_students [1]<br>
[3] 98.9 0.62 2.30 1000000 find_rank_student [3]<br>
2.30 0.00 1000000/1001000 bubblesort [4] <-- gros probleme ici<br>
-----------------------------------------------<br>
0.00 0.00 1000/1001000 sort_students [1]<br>
2.30 0.00 1000000/1001000 find_rank_student [3] <-- gros probleme ici<br>
[4] 78.0 2.30 0.00 1001000 bubblesort [4] <-- gros probleme ici<br>
-----------------------------------------------<br>
0.00 0.00 1000/1000 generate_grades [7]<br>
[5] 0.0 0.00 0.00 1000 generate_array [5]<br>
-----------------------------------------------<br>
0.00 0.00 2/2 main [2]<br>
[6] 0.0 0.00 0.00 2 free_array [6]<br>
-----------------------------------------------<br>
0.00 0.00 1/1 main [2]<br>
[7] 0.0 0.00 0.00 1 generate_grades [7]<br>
0.00 0.00 1000/1000 generate_array [5]<br>
-----------------------------------------------<br>
0.00 0.00 1/1 main [2]<br>
[8] 0.0 0.00 0.00 1 generate_ranks [8]<br>
-----------------------------------------------<br>
</details>
## 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

2
bubblesort.c
View File

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

BIN
gmon.out Normal file
View File

Binary file not shown.

42
quicksort.c Normal file
View File

@@ -0,0 +1,42 @@
#include <stdio.h>
#include <stdbool.h>
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);
}
}

8
quicksort.h Normal file
View File

@@ -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

BIN
student_rank Executable file
View File

Binary file not shown.

4
student_rank.c
View File

@@ -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,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);