update

DEV.3.2/TP/test-dump/ExoUnExam.java

@@ -0,0 +1,57 @@
+public class ExoUnExam {
+    
+    public <T> T deplacerSaufMin(Deque<T> source, Deque<T> destination, Comparator<T> comparateur) {
+        if (source.isEmpty()) {
+            return null;
+        }
+
+        T min = source.removeFirst(); // 1. On prend le premier élément comme min provisoire
+        while (!source.isEmpty()) { // 2. On parcourt le reste de la pile
+            T candidat = source.removeFirst();
+            
+            // Si candidat est plus petit que min
+            if (comparateur.compare(candidat, min) < 0) {
+                // L'ancien min n'était pas le bon, on le déplace vers la destination
+                destination.addFirst(min);
+                // On met à jour le min
+                min = candidat;
+            } else {
+                // Le candidat n'est pas le min, on le déplace
+                destination.addFirst(candidat);
+            }
+        }
+        // 3. On retourne le minimum trouvé (il n'est pas dans la destination)
+        return min;
+    }
+
+    public <T> void trier(Deque<T> pile, Comparator<T> c) {
+    // Pile pour construire le résultat trié
+    Deque<T> pileTriee = new LinkedList<>();
+    // Pile temporaire pour stocker les éléments non-min
+    Deque<T> temp = new LinkedList<>();
+
+    while (!pile.isEmpty()) {
+        // 1. On extrait le min de 'pile', le reste va dans 'temp'
+        T min = deplacerSaufMin(pile, temp, c);
+        
+        // 2. On place le min dans notre pile finale (ici on empile, donc le plus petit sera au fond si on continue... 
+        // ATTENTION : Pour avoir le plus petit au SOMMET à la fin, il faudrait trouver le MAX d'abord. 
+        // Mais le sujet impose le tri par sélection du MINIMUM. 
+        // Donc on empile les minimums successifs : min1, min2...
+        // La pileTriee aura min1 au fond, min2 au dessus... minMax au sommet. C'est un tri décroissant au dépilement.
+        // Si on veut croissant au dépilement, il faudrait une autre logique, mais suivons la consigne stricte).
+        pileTriee.addFirst(min);
+
+        // 3. On remet tout de temp vers pile pour recommencer
+        while(!temp.isEmpty()) {
+            pile.addFirst(temp.removeFirst());
+        }
+    }
+
+    // 4. On remet tout dans la pile d'origine comme demandé ("la pile triée finale devra être la pile donnée en argument")
+    // Si pileTriee a [5, 4, 3, 2, 1] (1 au fond), en renversant on aura [1, 2, 3, 4, 5].
+    while(!pileTriee.isEmpty()) {
+        pile.addFirst(pileTriee.removeFirst());
+    }
+}
+}

DEV.3.2/TP/test-dump/TSTNode.java

@@ -0,0 +1,70 @@
+public class TSTNode { //class noeud
+    char caractere;
+    TSTNode gauche, milieu, droite;
+    boolean finDeMot; // L'oreille
+
+    public TSTNode(char c) {
+        this.caractere = c;
+        this.finDeMot = false;
+    }
+}
+
+public class ArbreTernaire { //class arbre
+    private TSTNode racine;
+
+    public ArbreTernaire() {
+        this.racine = null;
+    }
+    
+    // Les méthodes demandées iront ici...
+    public boolean contains(String s) {
+    return contains(racine, s, 0);
+    }
+
+    private boolean contains(TSTNode n, String s, int index) {
+        if (n == null) return false;
+
+        char c = s.charAt(index);
+
+        if (c < n.caractere) {
+            return contains(n.gauche, s, index);
+        } else if (c > n.caractere) {
+            return contains(n.droite, s, index);
+        } else {
+            // Lettre trouvée !
+            if (index == s.length() - 1) {
+                // C'était la dernière lettre du mot cherché
+                return n.finDeMot;
+            } else {
+                // On continue avec la lettre suivante dans le fils milieu
+                return contains(n.milieu, s, index + 1);
+            }
+        }
+    }
+
+    public int longest() {
+    return longest(racine, 0);
+    }
+
+    private int longest(TSTNode n, int profondeur) {
+        if (n == null) return 0;
+
+        // 1. Calculer la max longueur dans les sous-arbres gauche et droit
+        // (Note : aller à gauche/droite ne change pas la profondeur du mot courant)
+        int l = longest(n.gauche, profondeur);
+        int r = longest(n.droite, profondeur);
+
+        // 2. Calculer la longueur en continuant tout droit (milieu)
+        // Là, on consomme le caractère actuel, donc profondeur + 1
+        int m = longest(n.milieu, profondeur + 1);
+
+        // 3. Est-ce que le nœud actuel est une fin de mot ?
+        int currentLen = 0;
+        if (n.finDeMot) {
+            currentLen = profondeur + 1;
+        }
+
+        // On retourne le max de toutes les possibilités
+        return Math.max(currentLen, Math.max(m, Math.max(l, r)));
+    }
+}