prog-c/tp-huffman/hufftree.c

#include "hufftree.h"
#include "error.h"
#include <stdlib.h>

/************************************/
/* Primitives des arbres de Huffman */
/************************************/

/* Création d'une feuille */
huffnode *create_huffleaf(int byte, int freq) {
  huffnode *h = malloc(sizeof(huffnode));
  h -> freq = 0;
  h -> byte = 0;
  h -> leftchild = NULL;
  h -> rightchild = NULL;
  return h;
}

/* Fusion de deux arbres avec un nouveau noeud racine */
huffnode *merge_hufftree(huffnode *pl, huffnode *pr) {
    huffnode *h = create_huffleaf(0, pl->freq + pr->freq);
    h->leftchild = pl;
    h->rightchild = pr;
    return h;
}

/* Teste si un noeud est une feuille */
bool isleaf_huffnode(huffnode *p) {
    return p->leftchild == NULL && p->rightchild == NULL;
}

/* Retourne la valeur de l'octet correspondant à un noeud */
int getbyte_huffnode(huffnode *p) {
  if (isleaf_huffnode(p)) {
      ERROR("getbyte_huffnode: noeud feuille attendu\n");
      exit(1);
  }
  return p->byte;
}

/* Retournent les fils d'un noeud */

huffnode *getleft_huffnode(huffnode *p) {
  if (isleaf_huffnode(p)) {
      ERROR("getleft_huffnode: noeud interne attendu\n");
      exit(1);
  }
  return p->leftchild;
}
huffnode *getright_huffnode(huffnode *p) {
    if (isleaf_huffnode(p)) {
          ERROR("getright_huffnode: noeud interne attendu\n");
          exit(1);
      }
  return p->rightchild;
}

/* Libération d'un arbre */

void free_hufftree(huffnode *p) {
  if (p == NULL) return;
  free_hufftree(p -> leftchild);
  free_hufftree(p -> rightchild);
  free(p);
}

/**********************************************/
/* Fonctions manipulant les arbres de Huffman */
/**********************************************/

/* Comparaison de deux arbres */
bool compare_hufftree(void *p1, void *p2) {
    huffnode *v1 = (huffnode*)p1;
    huffnode *v2 = (huffnode*)p2;
    if (v1 == NULL || v2 == NULL) {
        ERROR("compare_hufftree: NULL pointeur\n");
        exit(1);
    }
    return v1->freq < v2->freq;
}

/* Création de l'arbre de Huffman à partir du fichier à compresser */
huffnode *datafile_to_hufftree(FILE *input) {
  /* Phase 1: création du tableau de fréquences */

  int *tab = malloc(256 * sizeof(int));

  /* Phase 2: intialisation de la file de priorité à partir du tableau de
   * fréquences */

  // À écrire

  /* Phase 3: création de l'arbre de Huffman à partir de la file de priorités */

  // À écrire

  return NULL;
}

/* Écriture de l'arbre de Huffman dans le futur fichier compressé */
void save_hufftree(huffnode *p, FILE *f) {
  // À écrire
}

/* Lecture de l'arbre de Huffman dans le fichier compressé */
huffnode *read_hufftree(FILE *f) {
  // À écrire
  return NULL;
}