128 lines
3.1 KiB
C
128 lines
3.1 KiB
C
#include <stdio.h>
|
|
#include "arbre_de_codage/arbre_binaire.c"
|
|
#define ASCII_EXT 256
|
|
|
|
arbre huffman(arbre T);
|
|
void frequence(arbre T, FILE *file);
|
|
void tri_tab(arbre T,int n);
|
|
void afficher_tab(arbre T, int n);
|
|
void init_tab(arbre T, int Elt, int n);
|
|
|
|
// main_compress.c [nom_du_fichier_a_compresser]
|
|
int main(int argc, char **argv){
|
|
FILE *file;
|
|
const char *filename = argv[1];
|
|
const char *mode= "rb";
|
|
// Vérification de l'existance du second argument (Nom du fichier à compresser)
|
|
printf("Argc : %d\n",argc);
|
|
if(argc != 2){
|
|
printf("\nErreur : Veuillez mettre en argument un nom de fichier à compresser (Ex: %s text.txt)\n",argv[0]);
|
|
return -1;
|
|
}
|
|
// Vérification de l'o(uverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
|
|
else if(!(file=fopen(filename,mode))){
|
|
printf("\nErreur : Fichier %s inexistant\n",filename);
|
|
return -2;
|
|
}
|
|
printf("Tableau : \n");
|
|
arbre N = malloc(ASCII_EXT*sizeof(noeud)); // Initialisation de l'arbre
|
|
printf("Tableau initialisé -1: \n");
|
|
init_tab(N,-1,ASCII_EXT); // On initialise l'arbre avec des poids de -1
|
|
printf("Tableau get freq : \n");
|
|
frequence(N,file); // On récupère la fréquence d'apparition des lettres du fichiers
|
|
printf("Tableau tri : \n");
|
|
tri_tab(N,ASCII_EXT); // On fait un tri à bulle sur ce tableau
|
|
printf("Tableau affichage : \n");
|
|
afficher_tab(N,ASCII_EXT);
|
|
|
|
arbre huff;
|
|
printf("Huffman : \n");
|
|
//huff = huffman(T);
|
|
printf("Arbre :\n");
|
|
return 0;
|
|
}
|
|
|
|
void init_tab(arbre T[], int Elt, int n){
|
|
int i;
|
|
for(i=0;i<n;i++){
|
|
T[i]=creer_feuille(Elt,Elt);
|
|
}
|
|
}
|
|
|
|
void frequence(arbre T, FILE *file){
|
|
int c;
|
|
while((c=fgetc(file))!=EOF){
|
|
if(T[c].poids!=-1){
|
|
T[c].poids++;
|
|
}
|
|
else{
|
|
T[c].elt=c;
|
|
T[c].poids=1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void tri_tab(arbre T,int n){
|
|
int i,j;
|
|
noeud tmp;
|
|
for(i=0;i<n-1;i++){
|
|
for(j=i+1;j<n;j++){
|
|
if(T[i].poids>T[j].poids){
|
|
tmp=T[i];
|
|
T[i]=T[j];
|
|
T[j]=tmp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int compteur_tab(arbre T, int n){
|
|
int i,compteur;
|
|
compteur=0;
|
|
for(i=0;i<n;i++){
|
|
if(T[i].poids != -1){
|
|
compteur++;
|
|
}
|
|
}
|
|
return compteur;
|
|
}
|
|
|
|
void afficher_tab(arbre T, int n){
|
|
printf("\n");
|
|
int i;
|
|
for (i=0;i<n;i++){
|
|
printf("T[%d] = %d (%d)\n",i,T[i].poids,T[i].elt);
|
|
}
|
|
}
|
|
|
|
arbre huffman(arbre T){
|
|
// Création de l'arbre de codage de Huffman en considérant une liste avec les fréquences d'apparition des caractères ordonnée croissante
|
|
|
|
// récupérer les deux plus petits poids (cf : deux premieres occurences)
|
|
arbre H = malloc(sizeof(arbre));
|
|
H=creer_arbre_vide();
|
|
while(compteur_tab(T,ASCII_EXT)>1){
|
|
// Récupération des plus faibles poids
|
|
int i;
|
|
i=0;
|
|
while(T[i].poids!=-1){
|
|
i++;
|
|
}
|
|
arbre tmp;k
|
|
tmp1=creer_arbre_vide();
|
|
tmp2=creer_arbre_vide();
|
|
tmp3=creer_arbre_vide();
|
|
int newpoids;
|
|
newpoids=T[i].poids+T[i+1].poids;
|
|
tmp->fils_gauche=creer_feuille(T[i].elt,T[i].poids);
|
|
tmp->fils_droit=creer_feuille(T[i+1].elt,T[i+1].poids);
|
|
tmp->poids=newpoids;
|
|
|
|
T[i].poids=-1;
|
|
T[i].elt=-1;
|
|
T[i+1].poids=newpoids;
|
|
T[i+1].elt=-1;
|
|
tri_tab(T,ASCII_EXT);
|
|
H=
|
|
}
|
|
}
|