Generation des codes Huffman

src/fr/iutfbleau/sae/mhuffman/CanonicalCode.java

@@ -1,8 +1,10 @@
+package fr.iutfbleau.sae.mhuffman;
+
 import java.util.*;
 
 public class CanonicalCode{
 	private Map<Character,Integer> codeLenghts;
-	private Map<Character,Integer> CanonicalCodes;
+	private Map<Character,Integer> canonicalCodes;
 
 
 
@@ -16,3 +18,5 @@ public class CanonicalCode{
 		return 0;
 	}
 }
+
+

src/fr/iutfbleau/sae/mhuffman/HuffmanNode.java

@@ -1,3 +1,5 @@
+package fr.iutfbleau.sae.mhuffman;
+
 /**
  * Représente un nœud de l'arbre de Huffman.
  * <p>

src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java

@@ -1,11 +1,11 @@
 package fr.iutfbleau.sae.mhuffman;
-
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+
 /**
  * Implémente un arbre de Huffman utilisé pour la compression de données.
  * <p>
@@ -38,7 +38,7 @@ import java.util.Map;
  * dédiés.
  * </p>
  *
- * @author Algassimou Pellel Diallo
+ * @author Algassimou Pellel Diallo,Ayoub Anhdire
  * @version 1.0
  * @since 2025-12-13
  */
@@ -54,6 +54,18 @@ public class HuffmanTree {
      */
     private HuffmanNode root;
 
+    /**
+     * Dictionnaire pour enregistrer les codes Huffman
+    */
+    private Map<Integer,String> codes;
+
+    /**
+     * Chaine de caracteres qui va nous permettre de sauvegader le code Huffman
+     * Permet en d'autres termes de construire la chaine de 1 et de 0
+    */
+    
+    private String chaineCarac;
+    
     /**
      * Construit un arbre de Huffman.
      * <p>
@@ -77,6 +89,8 @@ public class HuffmanTree {
 
 		/////////////////////////////////// Voir si ya moyen doptimiser //////////////////////////////////////
 
+		// tu pourrait utiliser une PriorityQueue pour placer selon les fréquences comme dit dans l'énoncé !!!!
+	
 		List<HuffmanNode> feuilles = new ArrayList<>();
 
 		// pour chaque valeur(symbole) dans la table de frequence
@@ -90,7 +104,7 @@ public class HuffmanTree {
 			}
 		}
 
-		// On tri les feuilles par frequence croissante jutilie un comparator qui compare la vareur retournee par getFrequence de chaque feuille
+		// On tri les feuilles par frequence croissante j'utilise un comparator qui compare la valeur retournee par getFrequence de chaque feuille
 		// Referencement de methode avec ::
 		feuilles.sort(Comparator.comparingInt(HuffmanNode::getFrequence));
 		// flemme de faire un algo de tri alors que java le fait tres bien a voir a la fin si je vais coder une liste chainee avec un tri par insertion personnalise
@@ -109,7 +123,7 @@ public class HuffmanTree {
 			// j'insère le nœud parent dans la collection à la bonne position pour maintenir l'ordre (plus performant qu'un tri complet à chaque itération)
 			int index = 0;
 			// tant que l'index est dans les limites et que la frequence du noeud à l'index est inférieure à celle du parent
-			while (index < feuilles.size()&& feuilles.get(index).getFrequence() < parent.getFrequence()) {
+			while (index < feuilles.size() && feuilles.get(index).getFrequence() < parent.getFrequence()) {
 				index++;
 			}
 			feuilles.add(index, parent);
@@ -133,22 +147,50 @@ public class HuffmanTree {
         return root;
     }
 
+    /**
+     * @return Map on stockera les codes Huffman sous forme de dictionnaire 
+    */
 
 	public Map<Integer,String> generateCodes(){ 
-		// methode recursive : appliquer à chaque branche de l'abre , chaque feuille !!!
-		// 1 - trouver cas de base + comment generer les codes : 
-
-		/*
-		il nous faut differencier plusieurs cas si c'est la racine de l'abre 
-		et surtout si on met zero ou 1 selon si le fils droit ou gauche 
-
+		/**
+		 * Le but de cette méthode est de pouvoir generer les codes Huffman à partir de l'arbre : 
+		 * Les branches prendront comme valeur 1 ou 0 selon differents cas : 
+		 * 	1 - si on saute vers un fils droit 
+		 *  0 - si on saute vers un fils gauche.
+		 * On construit les codes qui partent de la racine jusqu'à notre objectif
 		*/
-		// le type des clés et valeurs sont susceptibles de changer : 
-		Map<Integer,String> dictionnaire = new HashMap<>();
 
+		this.codes = new HashMap<>();
+		this.chaineCarac = new String();
 
-
-
-		return dictionnaire;
+		if(root.isLeaf()){
+			codes.put(root.getValue(),chaineCarac);
+			return codes;
 		}
+
+		HuffmanNode temp = root;
+
+    	if (root.getLeft() != null) {
+        root = root.getLeft();
+        chaineCarac = chaineCarac + "0";
+        generateCodes();
+        // on retire le dernier bit lorsqu'on remonte car sinon les codes seront faussés
+        chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
+    	}
+
+    	if (temp.getRight() != null) {
+        root = temp.getRight();
+        chaineCarac = chaineCarac + "1";
+        generateCodes();
+        chaineCarac = chaineCarac.substring(0, chaineCarac.length() - 1);
+    	}
+
+    
+    	root = temp;
+		return codes;
+
+}
+
+
+
 }