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

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;

/**
 * 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>
 *
 * <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>
 *
 * <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
 */
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;

    /**
     * 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>
     *
     * <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>
     */
    public HuffmanTree(int[] freq) {
		// J'initialise la racine à null.
		this.root = null;

		// je cree  une collection de feuilles	
		List<HuffmanNode> feuilles = new ArrayList<>();

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

		// 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


		// 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;
    }



}