+ * Un {@code HuffmanNode} peut être : + *
+ * Cette classe est une structure de données utilisée par {@code HuffmanTree} + * pour construire l'arbre de Huffman. + *
+ * + * @author Algassimou Pellel Diallo + * @version 1.1 + * @since 2025-12-17 + */ +public class HuffmanNode { - private HuffmanNode left; - private HuffmanNode right; + /** Valeur de la composante (cette valeur est appelée symbole, voir l'histoire de huffman, tres interressant) représentée par ce nœud (si feuille). c'est la part de la composante (rouge, verte ou bleue) dans la couleur d'un pixel. */ + private int value; + /** Fréquence du symbole (somme des fréquences des enfants). */ + private int frequence; + /** Fils gauche du nœud (null si feuille). */ + private HuffmanNode left; - public HuffmanNode(char v,int f){ - this.value = v; - this.frequence = f; - this.right = null; - this.left = null; - } + /** Fils droit du nœud (null si feuille). */ + private HuffmanNode right; + /** + * Construit un nœud feuille de Huffman. + *+ * Ce constructeur est utilisé pour représenter une valeur + * issue de la table de fréquences. + *
+ * + * @param value la valeur (symbole) représentée par ce nœud + * @param frequence la fréquence d'apparition de la valeur + */ + public HuffmanNode(int value, int frequence) { + this.value = value; + this.frequence = frequence; + this.left = null; + this.right = null; + } - public void setSonLeft(HuffmanNode lef){ - this.left = lef; - } + /** + * Construit un nœud interne de Huffman. + *+ * Ce constructeur est utilisé lors de la fusion de deux nœuds + * de plus faible fréquence lors de la construction de l'arbre. + *
+ * + * @param left le fils gauche + * @param right le fils droit + */ + public HuffmanNode(HuffmanNode left, HuffmanNode right) { + this.left = left; + this.right = right; + this.frequence = left.frequence + right.frequence; + } - public void setSonRight(HuffmanNode rig){ - this.right = rig; - } + /** + * Indique si ce nœud est une feuille. + * + * @return {@code true} si le nœud est une feuille, {@code false} sinon + */ + public boolean isLeaf() { + return this.left == null && this.right == null; + } - public boolean isLead(HuffmanNode f){ - // on est une feuille si on a pas de fils gauche et ni de fils droit ! - boolean b = true; + /** + * Retourne la fréquence du nœud. + * + * @return la fréquence + */ + public int getFrequence() { + return this.frequence; + } - if(this.left == null && this.right == null){ - b = true; - }else{ - b = false; + /** + * Retourne le fils gauche du nœud. + * + * @return le fils gauche + */ + public HuffmanNode getLeft() { + return this.left; + } + + /** + * Retourne le fils droit du nœud. + * + * @return le fils droit + */ + public HuffmanNode getRight() { + return this.right; + } + + /** + * Retourne la valeur représentée par ce nœud. + *+ * Cette méthode n'a de sens que si le nœud est une feuille. + *
+ * + * @return la valeur du symbole + */ + public int getValue() { + if (!this.isLeaf()) { + throw new IllegalStateException("La valeur n'est définie que pour les feuilles."); } - - return b; - } - - // ajouter d'autres méthode tel que les getters par exemple !!! -} \ No newline at end of file + return this.value; + } +} diff --git a/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java b/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java index 566797d..78bb997 100644 --- a/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java +++ b/src/fr/iutfbleau/sae/mhuffman/HuffmanTree.java @@ -1,36 +1,139 @@ -import java.util.*; +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. + *+ * 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. + *
+ * + *+ * 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. + *
+ * + *+ * 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. + *
+ * + *+ * 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. + *
+ * + * @author Algassimou Pellel Diallo + * @version 1.0 + * @since 2025-12-13 + */ +public class HuffmanTree { + + /** + * Racine de l'arbre de Huffman. + *+ * 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. + *
+ */ + private HuffmanNode root; + + /** + * Construit un arbre de Huffman. + *+ * 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. + *
+ * + *+ * 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. + *
+ */ + public HuffmanTree(int[] freq) { + // J'initialise la racine à null. + this.root = null; + + // je cree une collection de feuilles + + /////////////////////////////////// Voir si ya moyen doptimiser ////////////////////////////////////// + + List+ * Cette méthode permet d'accéder à la structure complète de l'arbre, + * notamment lors de la génération des codes ou du décodage des données. + *
+ * + * @return le nœud racine de l'arbre de Huffman + */ + public HuffmanNode getRoot() { + return root; + } + + public Map