fin du TP

TriND.java

@@ -0,0 +1,71 @@
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class TriND {
+
+    public static void main(String[] args) {
+        // Exemple de tableau à 3 dimensions
+        Integer[][][] tableau3D = {
+            { {3, 1, 2}, {9, 0, 8} },
+            { {4, 5, 1}, {2, 2, 2} }
+        };
+
+        // Appel de la fonction de tri
+        trierND(tableau3D);
+
+        // Affichage du tableau trié
+        System.out.println("Tableau trié : ");
+        System.out.println(Arrays.deepToString(tableau3D));
+    }
+
+    /**
+     * Fonction qui trie un tableau de n'importe quelle dimension.
+     * Si c'est un tableau d'entiers, on le trie directement.
+     * Sinon, on trie les sous-tableaux récursivement, puis le tableau actuel
+     * selon la somme des sous-tableaux.
+     */
+    public static void trierND(Object tableau) {
+        if (tableau instanceof int[]) {
+            // Si on est au dernier niveau (tableau d'entiers)
+            Arrays.sort((int[]) tableau);
+        } else if (tableau instanceof Object[]) {
+            Object[] tab = (Object[]) tableau;
+
+            // On trie d'abord les sous-tableaux (appel récursif)
+            for (Object sousTab : tab) {
+                trierND(sousTab);
+            }
+
+            // Puis on trie le tableau courant selon la somme de ses sous-tableaux
+            Arrays.sort(tab, new Comparator<Object>() {
+                @Override
+                public int compare(Object a, Object b) {
+                    int sommeA = sommeRecursive(a);
+                    int sommeB = sommeRecursive(b);
+                    return Integer.compare(sommeA, sommeB);
+                }
+            });
+        }
+    }
+
+    /**
+     * Fonction qui calcule récursivement la somme d'un tableau à N dimensions.
+     */
+    public static int sommeRecursive(Object tableau) {
+        if (tableau instanceof int[]) {
+            int somme = 0;
+            for (int valeur : (int[]) tableau) {
+                somme += valeur;
+            }
+            return somme;
+        } else if (tableau instanceof Object[]) {
+            int sommeTotale = 0;
+            for (Object sousTab : (Object[]) tableau) {
+                sommeTotale += sommeRecursive(sousTab);
+            }
+            return sommeTotale;
+        } else {
+            return 0;
+        }
+    }
+}

readme.md

@@ -0,0 +1,23 @@
+Hugo Raban et Patrick Felix-Vimalaratnam
+
+# Ex 2
+
+## Code 1
+
+La complexité de ce code est de O(n*m) car pour chaque valeur du tableau1 on va regarder toutes les valeurs du tableau2.
+
+## Code 2
+
+La complexité de ce code est de O(n) car le nombre d'itération de la boucle dépend de la valeur de x.
+
+## Code 3
+
+La complexité de ce code est de O(1) car peu importe la valeur de x, il n'y a pas de boucle.
+
+# Ex 3
+
+Le code trie récursivement chaque sous-tableau, puis trie le tableau courant selon la somme des sous-tableaux.
+
+À chaque niveau, le tri coûte O(M*log(⁡M)) et chaque comparaison parcourt tous les éléments du sous-tableau (O(M^(n−1))).
+
+Donc pour un tableau à N dimensions et M éléments par niveau, la complexité totale est O(M^N*log(⁡M)).