Compare commits

..

2 Commits

Author SHA1 Message Date
0dd5210e1e algo tri exercice 3 2025-10-15 12:12:56 +02:00
0223e367a4 ajout des réponses aux deux exercices 2025-10-15 12:12:42 +02:00
2 changed files with 135 additions and 0 deletions

24
README.md Normal file
View File

@@ -0,0 +1,24 @@
### Compte-rendu du TD4 par William Gentil
## Exercice 2
# Fonction 1
La fonction 1 prend en arguments deux tableaux différents. On peut y voir une bouvle for à l'intérieur d'une autre boucle for : on peut donc penser que la compléxité serait de n², sauf que les deux tablaeux peuvent avoir des valeurs différentes donc on serait plutôt sur une compléxité de xn. On pourrait tout de même ajouter que dans la deuxième boucle for on à l'exécution d'une action avec un break si le nombre1=nombre2 ce qui veut dire que notre complexité xn est le cas le plus pessimiste mais il pourrait y avoir une compléxité de O(1) si on venait à trouver dès la première case des deux tableaux la même valeur.
Résultat : O(xn)
# Fonction 2
La fonction 2 utilise une boucle while qui dit que tanyt que x est supérieur à 0, on ajoute x à valeur et on décrémente x de 1. Ce qui veut dire que la complexité est de O(x) car il faut que x=0 pour finir la boucle et x=0 seulement lorsque l'on arrive à x+(x*(-1)). Autrement dit, il faut que l'on décrémente x de x fois pour trouver la complexité maximale.
Résultat : O(n)
# Fonction 3
La fonction 3 est triviale, on a une fonction qui prend x en argument et qui traite la valeur de valeur selon la position de x par rapport à 0. Maintenant, la complexité serait de O(1) car l'ordinateur vérifie tous les if et ne fera qu'une seule instance car si un if est notre cas alors les deux autres ne sont forcément pas notre cas.
Résultat : O(1)

111
algo_tri.c Normal file
View File

@@ -0,0 +1,111 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Fonction de comparaison utilisée par qsort
int compare_ints(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
// Calcule la somme des éléments d'un bloc donné (dimension 1)
int sum_block(void* base, int block_size, int elem_size) {
int sum = 0;
for (int i = 0; i < block_size; i++) {
sum += *((int*)(base + i * elem_size));
}
return sum;
}
// Fonction récursive de tri
void recursive_sort(
void* data, int* dims, int dim_count, int elem_size
) {
if (dim_count == 1) {
// Cas de base : trier un tableau 1D
qsort(data, dims[0], elem_size, compare_ints);
return;
}
int sub_block_count = dims[0];
int* sub_dims = dims + 1;
// Calcul de la taille d'un sous-bloc
int sub_block_size = 1;
for (int i = 1; i < dim_count; i++) {
sub_block_size *= dims[i];
}
// Trier récursivement chaque sous-bloc
for (int i = 0; i < sub_block_count; i++) {
void* sub_block = (char*)data + i * sub_block_size * elem_size;
recursive_sort(sub_block, sub_dims, dim_count - 1, elem_size);
}
// Création de tableau temporaire pour le tri des blocs
void** blocks = malloc(sub_block_count * sizeof(void*));
int* sums = malloc(sub_block_count * sizeof(int));
for (int i = 0; i < sub_block_count; i++) {
blocks[i] = (char*)data + i * sub_block_size * elem_size;
sums[i] = sum_block(blocks[i], sub_block_size, elem_size);
}
// Tri des blocs par somme croissante
for (int i = 0; i < sub_block_count - 1; i++) {
for (int j = i + 1; j < sub_block_count; j++) {
if (sums[i] > sums[j]) {
// Swap sums
int tmp_sum = sums[i];
sums[i] = sums[j];
sums[j] = tmp_sum;
// Swap blocks
void* tmp_block = blocks[i];
blocks[i] = blocks[j];
blocks[j] = tmp_block;
}
}
}
// Réorganiser les données selon le nouvel ordre
void* temp = malloc(sub_block_count * sub_block_size * elem_size);
for (int i = 0; i < sub_block_count; i++) {
memcpy((char*)temp + i * sub_block_size * elem_size,
blocks[i], sub_block_size * elem_size);
}
memcpy(data, temp, sub_block_count * sub_block_size * elem_size);
free(temp);
free(blocks);
free(sums);
}
// Fonction pour afficher un tableau 2D
void print_2d_array(int* arr, int rows, int cols) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%d ", arr[i * cols + j]);
}
printf("\n");
}
}
int main() {
// Exemple pour un tableau 2D : 3 lignes, 3 colonnes
int dims[2] = {3, 3}; // 2D : 3x3
int arr[3][3] = {
{0, 3, 2},
{9, 4, 5},
{4, 1, 3}
};
printf("Avant tri :\n");
print_2d_array((int*)arr, dims[0], dims[1]);
recursive_sort((void*)arr, dims, 2, sizeof(int));
printf("\nAprès tri :\n");
print_2d_array((int*)arr, dims[0], dims[1]);
return 0;
}