test - dump file added

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