sae fini les gars

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

@@ -1,181 +1,114 @@
 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;
-import fr.iutfbleau.sae.util.HuffmanNode;
+import java.util.PriorityQueue;
 
 /**
- * Implémente un arbre de Huffman utilisé pour la compression de données.
- * <p>
- * La classe {@code HuffmanTree} est chargée de représenter la structure
- * de l'arbre de Huffman et de générer les codes binaires associés aux symboles.
- * Elle s'appuie sur la classe {@link HuffmanNode} pour représenter les nœuds
- * de l'arbre.
- * </p>
+ * 
+ * Cette classe construit un arbre de Huffman à partir d'un tableau
+ * de fréquences. Une fois l'arbre construit, elle permet aussi de
+ * générer les codes Huffman associés à chaque symbole.
  *
- * <p>
- * L'arbre est construit à partir des fréquences des symboles calculées
- * en amont (par exemple à l'aide d'une {@code FrequencyTable}).
- * Chaque symbole est d'abord représenté par une feuille, puis les nœuds
- * sont combinés progressivement selon l'algorithme de Huffman afin
- * d'obtenir un arbre binaire optimal.
- * </p>
+ * Le principe est le suivant :
+ * - chaque symbole non nul devient une feuille avec sa fréquence
+ * - on fusionne toujours les deux plus petites fréquences
+ * - on obtient une racine unique
+ * - un parcours de l'arbre permet ensuite de fabriquer les codes
  *
- * <p>
- * Une fois l'arbre construit, celui-ci est parcouru afin de générer une
- * table de correspondance associant à chaque symbole un code binaire unique.
- * Les symboles les plus fréquents se retrouvent plus proches de la racine
- * et possèdent donc des codes plus courts, ce qui permet de réduire
- * la taille des données compressées.
- * </p>
- *
- * <p>
- * Cette classe ne s'occupe pas de la lecture ou de l'écriture des bits.
- * Elle fournit uniquement la structure et les informations nécessaires
- * à la compression, qui sont ensuite exploitées par des flux binaires
- * dédiés.
- * </p>
- *
- * @author Algassimou Pellel Diallo,Ayoub Anhdire
- * @version 1.0
- * @since 2025-12-13
+ * Les codes sont construits en descendant l'arbre :
+ * aller à gauche ajoute "0", aller à droite ajoute "1".
  */
 public class HuffmanTree {
 
-    /**
-     * Racine de l'arbre de Huffman.
-     * <p>
-     * Ce nœud est le résultat final de la construction de l'arbre et constitue
-     * le point de départ pour la génération des codes binaires ainsi que
-     * pour le décodage des données compressées.
-     * </p>
-     */
     private HuffmanNode root;
+    private Map<Integer, String> codes;
 
     /**
-     * Dictionnaire pour enregistrer les codes Huffman
-    */
-   	// j'ai retirer le static car chaque arbre a ses propres codes et j'utilise string plutot que int pour stocker les codes car on construit une chaine de 0 et de 1
-    private Map<Integer, String> codes; 
-
-    
-    /**
-     * Construit un arbre de Huffman.
-     * <p>
-     * Le constructeur est responsable de l'initialisation de la structure
-     * de l'arbre. En pratique, il combine les nœuds feuilles représentant
-     * les symboles par ordre croissant de fréquence jusqu'à obtenir un
-     * unique nœud racine.
-     * </p>
+     * Construit l'arbre de Huffman à partir d'un tableau de fréquences.
      *
-     * <p>
-     * Les détails de la construction (structure de données utilisée,
-     * ordre des fusions, etc.) sont volontairement séparés de la logique
-     * de génération des codes.
-     * </p>
+     * @param freq tableau contenant la fréquence de chaque symbole (0 à 255)
      */
     public HuffmanTree(int[] freq) {
-		// J'initialise la racine à null.
-		this.root = null;
 
-		// je cree  une collection de feuilles	
-		List<HuffmanNode> feuilles = new ArrayList<>();
+        this.root = null;
 
-		// pour chaque valeur(symbole) dans la table de frequence
-		for (int i = 0; i < freq.length; i++) {
-			// si la frequence est superieure a 0 , on cree une feuille
-			if (freq[i] > 0) {
-				// pour la valeur (symbole) i avec frequence freq[i], on cree une feuille
-				HuffmanNode feuille = new HuffmanNode(i, freq[i]);
-				// on ajoute la feuille à la collection
-				feuilles.add(feuille);
-			}
-		}
+        // Création de la file de priorité avec le comparateur
+        ComparateurHuffmanNode cmp = new ComparateurHuffmanNode();
+        PriorityQueue<HuffmanNode> feuilles = new PriorityQueue<>(cmp);
 
-		// 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
+        // Ajout des feuilles
+        for (int i = 0; i < freq.length; i++) {
+            if (freq[i] > 0) {
+                feuilles.add(new HuffmanNode(i, freq[i]));
+            }
+        }       
+     
 
+        // Fusion des nœuds (feuille) jusqu'à obtenir la racine
+        while (feuilles.size() > 1) {
+            HuffmanNode left = feuilles.poll();
+            HuffmanNode right = feuilles.poll();
+            HuffmanNode parent = new HuffmanNode(left, right);
+            feuilles.add(parent);
+        }
 
-		// Fusion des nœuds jusqu'à obtenir la racine
-		// Tant qu'il y a plus d'une feuille dans la collection
-		while (feuilles.size() > 1) {
-			// je prends les deux feuilles de plus faible fréquence
-			HuffmanNode left = feuilles.remove(0);
-			HuffmanNode right = feuilles.remove(0);
-
-			// je crée un nœud interne en les combinant
-			HuffmanNode parent = new HuffmanNode(left, right);
-
-			// 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()) {
-				index++;
-			}
-			feuilles.add(index, parent);
-		}
-
-		// a la fin il ne reste qu'un seul noeud : la racine de l'arbre
-		this.root = feuilles.get(0);
-	}
-	
-	// Méthode pour générer les codes Huffman à partir de l'arbre
-	// pourquoi string et pas int ? car on va construire une chaine de 0 et de 1
-	/**
-     * @return Map on stockera les codes Huffman sous forme de dictionnaire 
-    */ 
-	public Map<Integer,String> generateCodes() {
-		/**
-		 * 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
-		*/
-		this.codes = new HashMap<>(); 
-		// je lance la methode recursive avec une chaine vide qui va se remplir au fur et à mesure
-		generateCodesRec(this.root, "");
-		return codes;
-	}
-
-
-   
-	private void generateCodesRec(HuffmanNode node, String prefiixe) {
-		// Cas de base: si le noeud est une feuille, on ajoute le code au dictionnaire
-		if (node.isLeaf()) {
-			if (prefiixe.length() > 0){
-				this.codes.put(node.getValue(), prefiixe);
-			}else{
-				this.codes.put(node.getValue(), "0");
-			}
-			return;
-		}
-
-		//Case general : sinon on continue a parcourir l'arbre
-		// On va a gauche en ajoutant "0" au code
-		generateCodesRec(node.getLeft(), prefiixe + "0");
-		// On va a droite en ajoutant "1" au code
-		generateCodesRec(node.getRight(), prefiixe + "1");
-	}
-
-	/**
-	 * @return Dictionnaire des codes Huffman
-	*/
-	public Map<Integer,String> getCodes(){
-		return codes;
-	}
-
-    /**
-     * @return le nœud racine de l'arbre de Huffman
-     */
-    public HuffmanNode getRoot() {
-        return root;
+        this.root = feuilles.poll();
     }
 
+    /**
+     * Lance la génération des codes Huffman en parcourant l'arbre.
+     *
+     * @return une map associant chaque symbole à son code Huffman
+     */
+    public Map<Integer, String> generateCodes() {
+        this.codes = new HashMap<>();
+        generateCodesRec(this.root, "");
+        return this.codes;
+    }
 
+    /**
+     * Méthode récursive qui construit les codes Huffman.
+     *
+     * @param node nœud courant
+     * @param prefixe code accumulé (suite de 0 et de 1)
+     */
+    private void generateCodesRec(HuffmanNode node, String prefixe) {
 
+        // Cas feuille : on ajoute le code
+        if (node.isLeaf()) {
+
+            if (prefixe.length() > 0) {
+                this.codes.put(node.getValue(), prefixe);
+            } else {
+                // Cas spécial : un seul symbole dans l'arbre
+                this.codes.put(node.getValue(), "0");
+            }
+            return;
+        }
+
+        // Descendre à gauche s
+        generateCodesRec(node.getLeft(), prefixe + "0");
+
+        // Descendre à droite
+        generateCodesRec(node.getRight(), prefixe + "1");
+    }
+
+    /**
+     * Permet de récupérer la racine de l'arbre.
+     *
+     * @return la racine de l'arbre de Huffman
+     */
+    public HuffmanNode getRoot() {
+        return this.root;
+    }
+
+    /**
+     * Retourne les codes Huffman générés.
+     *
+     * @return une map symbole code
+     */
+    public Map<Integer, String> getCodes() {
+        return this.codes;
+    }
 }