update tp-huffman

tp-huffman/hufftree.h

@@ -0,0 +1,98 @@
+/**************************************/
+/**       Les arbres de Huffman      **/
+/** Implémentation par des pointeurs **/
+/**************************************/
+
+#ifndef HUFFTREE_H_
+#define HUFFTREE_H_
+
+#include "alloc.h"
+#include "binheap.h"
+#include <stdbool.h>
+#include <stdio.h>
+
+/*******************************************/
+/* Type utilisé pour les arbres de Huffman */
+/*******************************************/
+
+// Chaque objet correspond à un noeud de l'arbre.
+// On identifie un arbre avec un pointeur vers son noeud racine.
+//
+// Cela explique pourquoi les fonctions manipulant les arbres prennent en
+// argument un pointeur vers un noeud, et que leur nom se termine soit par
+// _huffnode, soit par _hufftree.
+
+typedef struct huffnode {
+  // Fréquence
+  int freq;
+
+  // Octet codé par le noeud (significatif seulement si le noeud est une
+  // feuille)
+  int byte;
+
+  // Enfant gauche (NULL si pas de fils gauche)
+  struct huffnode *leftchild;
+
+  // Enfant droit (NULL si pas de fils droit)
+  struct huffnode *rightchild;
+} huffnode;
+
+/************************************/
+/* Primitives des arbres de Huffman */
+/************************************/
+
+// Création d'une feuille.
+// Les paramètres servent à initialiser les champs byte et freq (dans cet
+// ordre).
+huffnode *create_huffleaf(int byte, int freq);
+
+// Fusion de deux arbres non-vides en utilisant un nouveau noeud racine.
+// La fréquence du nouveau noeud sera la somme de celles de ses deux enfants
+// Le champ byte du nouveau noeud n'est pas significatif (car ce n'est pas une
+// feuille).
+huffnode *merge_hufftree(huffnode *pl, huffnode *pr);
+
+// Teste si un arbre est réduit à une seule feuille.
+// On doit tester si les deux enfants du noeud racine sont NULL
+bool isleaf_huffnode(huffnode *p);
+
+// Retourne la valeur de l'octet codé dans un noeud.
+// Ne doit être utilisé que sur les feuilles.
+int getbyte_huffnode(huffnode *p);
+
+// Retourne les enfants gauche et droit d'un noeud.
+huffnode *getleft_huffnode(huffnode *p);
+huffnode *getright_huffnode(huffnode *p);
+
+// Libération complète d'un arbre  de Huffman.
+void free_hufftree(huffnode *p);
+
+/**********************************************/
+/* Fonctions manipulant les arbres de Huffman */
+/**********************************************/
+
+// Fonction de comparaison entre deux arbres de Huffman à utiliser pour le tas
+// binaire. Les deux paramètres sont donc donnés par des void *. Il faut les
+// convertir ces pointeurs de façon appropriée dans la fonction
+// compare_hufftree.
+//
+// Le plus petit de deux arbres est celui dont la racine a la plus petite
+// fréquence.
+bool compare_hufftree(void *p1, void *p2);
+
+// Création de l'arbre de Huffman à partir du fichier à compresser.
+// Le fichier doit être ouvert en lecture.
+// L'algorithme est basé sur les files de priorités.
+huffnode *datafile_to_hufftree(FILE *input);
+
+// Écriture de l'arbre de Huffman dans le futur fichier compressé.
+// Le fichier doit être ouvert en lecture.
+// On stocke l'arbre par une représentation préfixe.
+void save_hufftree(huffnode *p, FILE *output);
+
+// Lecture de l'arbre de Huffman dans un fichier.
+// Le fichier doit être ouvert en lecture.
+// La tête de lecture doit être positionnée au début du codage de l'arbre.
+huffnode *read_hufftree(FILE *in);
+
+#endif