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

Compare commits

base: bridja:ca552281c9e85dfcb5795e3b5c915ea625e5c23e
Branches Tags
bridja:main menault:main
...
compare: bridja:75cd4b3d4bbc19819173a95d09e89c3c360123f7
Branches Tags
bridja:main menault:main

2 Commits
ca552281c9 ... 75cd4b3d4b

Author SHA1 Message Date
Abed BRIDJA
75cd4b3d4b Add: Import file 2025-09-10 18:27:27 +02:00
Abed BRIDJA
69fb2df066 Add: Import folder 2025-09-10 17:24:50 +02:00
5 changed files with 160 additions and 3 deletions
Expand all files Collapse all files

125
Compte_rendu.md Normal file
View File

@@ -0,0 +1,125 @@
Analyse GProf
**Flat profile :** Donne le temps et le nombre d'execution par fonction
comme bubblesort prend 80% du temps avec 1001000 calls
cumulative self
time seconds seconds calls s/call s/call name
77.59 2.13 2.13 1001000 0.00 0.00 bubblesort
22.22 2.74 0.61 1000000 0.00 0.00 find_rank_student
0.36 2.75 0.01 1 0.01 2.75 sort_students
0.00 2.75 0.00 1000 0.00 0.00 generate_array
0.00 2.75 0.00 2 0.00 0.00 free_array
0.00 2.75 0.00 1 0.00 0.00 generate_grades
0.00 2.75 0.00 1 0.00 0.00 generate_ranks
Fonction bubblesort est appelé 1001000
Fonction find_rank_student est appelée 1000000
*Devra donc optimiser pour réduire le temps ?
**Call graph:** Voir arbre appel de fonctiopns + Temps et nombre execution par fonction
Call graph (explanation follows)
granularity: each sample hit covers 2 byte(s) for 0.36% of 2.75 seconds
index % time self children called name
0.01 2.74 1/1 main [2]
[1] 100.0 0.01 2.74 1 sort_students [1]
0.61 2.13 1000000/1000000 find_rank_student [3]
0.00 0.00 1000/1001000 bubblesort [4]
-----------------------------------------------
<spontaneous>
[2] 100.0 0.00 2.75 main [2]
0.01 2.74 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.61 2.13 1000000/1000000 sort_students [1]
[3] 99.6 0.61 2.13 1000000 find_rank_student [3]
2.13 0.00 1000000/1001000 bubblesort [4]
-----------------------------------------------
0.00 0.00 1000/1001000 sort_students [1]
2.13 0.00 1000000/1001000 find_rank_student [3]
[4] 77.5 2.13 0.00 1001000 bubblesort [4]
-----------------------------------------------
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]
-----------------------------------------------
L'index correspond à chaque fonction appelée exemple: [1] sort_students
Dans index [1] main appele sort_students[1] et find_rank_student[3], bubblesort[4] est appelées dans sort_students[1]
Quand main est appelé 1 fois il appele 1 fois sort_students d'ou le 1/1 dans called
Quand find_rank_student est appelé 10 fois il appele 1 fois sort_students d'ou le 1/1 dans called
**Analyse et modification**
Fonction plus lente : bubblesort
Nombre appel important de buublesort dans find_rank.student
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)
{
position = students_number-i;
break;
}
}
return position;
}
Mettre en commentaire bubblesort /* */
void bubblesort(int* array, int length)
{
int swapped, i, tmp;
do
{
swapped = 0;
for(i=1;i<length;i++)
{
if(array[i-1] > array[i])
{
tmp = array[i-1];
array[i-1] = array[i];
array[i] = tmp;
swapped++;
}
}
} while(swapped > 0);
}
Changement de swapped > 0 au lieu de swapped == 1;
Pour le tri à bulle comparaison entre deux nombres et voir le plus petit si c'est croissant
Tri par tas plus rapide pour les gros tableaux que les tri par bulle

32
bubblesort.c
View File

@@ -17,5 +17,35 @@ void bubblesort(int* array, int length)
swapped++;
}
}
} while(swapped==1);
} while(swapped > 0);
}
/* Trie rapide */
void permuter(int *a, int *b) {
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
void triRapid(int* array, int first, int last) {
int pivot, i, j;
if(first < last) {
pivot = first;
i = first;
j = last;
while (i < j) {
while(array[i] <= array[pivot] && i < last)
i++;
while(array[j] > array[pivot])
j--;
if(i < j) {
permuter(&array[i], &array[j]);
}
}
permuter(&array[pivot], &array[j]);
triRapid(tab, first, j - 1);
triRapid(tab, j + 1, last);
}
}

BIN
gmon.out Normal file
View File

Binary file not shown.

BIN
student_rank Executable file
View File

Binary file not shown.

6
student_rank.c
View File

@@ -55,7 +55,9 @@ int find_rank_student(int student_grade, int* grades_array, int students_number)
{
int position = -1;
int i = 0;
bubblesort(grades_array,students_number);
/*bubblesort(grades_array,students_number);*/
for(i = students_number-1; i >= 0; i--)
{
if(grades_array[i] == student_grade)
@@ -77,7 +79,7 @@ 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);
for(j = 0; j < students_number; j++)
{
students_rank[j][i] = find_rank_student(students_array[j][i],grades,students_number);