Téléverser les fichiers vers "/"

TD4.txt

@@ -0,0 +1,46 @@
+-----------Ex 2-----------
+Fonction 1 :
+la compléxité algorithmique : O(n*m)
+"n" est le tableau1 et "m" est le tableau2
+car chaque élément de tableau 1 est comparé avec chaque élément de tableau 2.
+
+Fonction 2 :
+la compléxité algorithmique : O(x)
+La boucle s'exécute x fois.
+
+Fonction 3 :
+la compléxité algorithmique : O(1)
+Les conditions sont évaluées une seule fois. (je suis pas sur pour celle-ci)
+
+-----------Ex 3-----------
+Fonction sort_students :
+Une première boucle itère sur grades_number (noté n) avec une allocation mémoire de complexité O(1), soit O(n).
+Une deuxième boucle itère sur students_number (noté m) pour copier les notes n fois, ce qui donne une complexité O(n⋅m).
+Appel de la fonction bubble_sort sur un tableau de m éléments, avec une complexité O(m^2). 
+Cela donne une complexité totale de O(n⋅m^2).
+Une dernière boucle de complexité O(m) appelle la fonction find_rank_student.
+
+
+Fonction find_rank_student :
+Appelle bubble_sort avec une complexité O(m^2).
+Contient une boucle qui itère sur m, avec une complexité O(m).
+Complexité totale de la fonction O(m^2).
+Complexité globale de sort_students :
+La fonction find_rank_student est appelée m fois. Sa contribution est donc O(m⋅m^2)=O(m^3).
+
+Complexité finale de sort_students : O(n⋅m^2+m^3) = O(n * m^3)
+
+-----------Ex 4-----------
+-Tri individuel des sous-tableaux O(n*m^2) (m = longueur du sous-tableau , n= nombre de sous tableau)
+-Calcul de la somme de chaque sous-tableau (n*m)
+-Tri des sous-tableaux dans TriTableau (n^2*m)
+
+pour moi la complexité est : O(n^2*k) ( j'hésite avec O(n^2 * m + n * m^2) )
+et change selon le nombre de sous_tableaux et de la longeur des sous-tableaux
+
+note :
+code Aesthetic / malloc ( by code Aesthetic)
+
+import java.util.Arrays;
+
+

TriDeTableau.java

@@ -0,0 +1,63 @@
+import java.util.Arrays;
+
+public class TriDeTableau {
+
+    public static void main(String[] args) {
+        int[][] tableau = {
+                { 0, 3, 2 }, { 9, 4, 5 }, { 4, 1, 3 }
+        };
+
+        int[][] tableautrier = TriTableau(tableau);
+
+        for (int[] listTableau : tableautrier) {
+            System.out.println(Arrays.toString(listTableau));
+        }
+    }
+
+    public static int[][] TriTableau(int[][] tableau) {
+        // Tri individuel des sous-tableaux
+        for (int[] listTableau : tableau) {
+            TriDansTableau(listTableau);
+        }
+
+        // Tri des sous-tableaux en fonction de leur somme
+        boolean swap;
+        do {
+            swap = false;
+            for (int i = 1; i < tableau.length; i++) {
+                if (sommetableau(tableau[i - 1]) > sommetableau(tableau[i])) {
+
+                    int[] temp = tableau[i - 1];
+                    tableau[i - 1] = tableau[i];
+                    tableau[i] = temp;
+                    swap = true;
+                }
+            }
+        } while (swap);
+        return tableau;
+    }
+
+    public static void TriDansTableau(int[] tableau) {
+        boolean swap;
+        do {
+            swap = false;
+            for (int i = 1; i < tableau.length; i++) {
+                if (tableau[i - 1] > tableau[i]) {
+
+                    int temp = tableau[i - 1];
+                    tableau[i - 1] = tableau[i];
+                    tableau[i] = temp;
+                    swap = true;
+                }
+            }
+        } while (swap);
+    }
+
+    public static int sommetableau(int[] tableau) {
+        int somme = 0;
+        for (int chiffre : tableau) {
+            somme += chiffre;
+        }
+        return somme;
+    }
+}