algo tri exercice 3

README.md

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

algo_tri.c

@@ -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;
+}