exo3

exo2.pdf

@@ -0,0 +1,15 @@
+function_1:
+Pire des cas :
+O(n*m) : Si la condition est rempli à la fin ou jamais rempli, la boucle va devoir parcourir tout les éléments du tableau1 et le tableau2
+Meilleur des cas : 
+O(n) : Si la condition est rempli directement, on sort des boucles avec le break donc n fois comparaisons
+
+function_2:
+Pire des cas :
+O(x) : La boucle s'execute x fois, ici jusqu'à qu'elle arrive à 1, et fait des addition et soustraction dans celle-ci
+Meilleur des cas :
+O(1) : La boucle s'execute 1 fois si le paramètre d'entrée x est 0 ou négatif
+
+function_3:
+Pire des cas / Meilleur des cas :
+O(1): Cette fonction est éxecuter 1 seule fois dans le pire et meilleur des cas puisqu'il n'y a aucune boucle et aucun appelle récursif

exo3.java

@@ -0,0 +1,52 @@
+import java.util.Arrays;
+
+public class exo3 {
+    private static int calculSomme(int[] ligne) {
+        int somme = 0;
+        for (int element : ligne) {
+            somme += element;
+        }
+        return somme;
+    }
+
+    public static int[][] trierTab(int[][] tab) {
+        Arrays.sort(tab, (val1, val2) -> Integer.compare(calculSomme(val1), calculSomme(val2)));
+    
+        for (int[] val : tab) {
+            Arrays.sort(val);
+        }
+        
+        return tab;
+    }
+
+    public static void main(String[] args) {
+        int[][] orginalTab = {
+            {0, 3, 2},
+            {9, 4, 5},
+            {4, 1, 3},
+        };
+        // int[][] orginalTab = {
+        //     {7, 2, 9, 1},
+        //     {3, 8, 4},
+        //     {6, 1, 5, 2, 3},
+        //     {2, 9},
+        //     {4, 7, 1, 8},
+        // };
+
+        afficherTab(orginalTab);
+        System.out.println("-----");
+
+        int[][] resultTab = trierTab(orginalTab);
+
+        afficherTab(resultTab);
+    }
+
+    private static void afficherTab(int[][] tab) {
+        for (int i = 0; i < tab.length; i++) {
+            for (int j = 0; j < tab[i].length; j++) {
+                System.out.print(tab[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+}

exo3.pdf

@@ -0,0 +1,5 @@
+Complexité algorithmique de la fonction trierTab:
+Ici il y a deux principales instructions qu'on va calculer, le tri par somme et le tri de chaque sous-tableau
+Le tri O(N * M Log N)
+Le tri de chaque sous tableau O(N * M Log M)
+Donc le calcul total correspond à l'addition des deux : O(N * M Log N) + O(N * M Log M)