Yûki - Compress

arbre_de_codage/arbre_binaire.c

@@ -8,7 +8,7 @@ arbre creer_arbre_vide (void)
   return NULL ;
 }
 
-arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd)
+arbre creer_arbre_huffman(int e, int p, arbre fg, arbre fd)
 {
   noeud * tmp = malloc(sizeof(noeud));
   tmp->elt=e;
@@ -30,7 +30,7 @@ arbre fils_droit(arbre b)
   return b->fils_droit;
 }
 
-Elt racine(arbre a)
+int racine(arbre a)
 {
   assert(!est_arbre_vide(a));
   return a->elt;
@@ -41,7 +41,7 @@ bool est_arbre_vide(arbre a)
   return (a == NULL) ;
 }
 
-arbre creer_feuille(Elt e, int p)
+arbre creer_feuille(int e, int p)
 {
   return creer_arbre_huffman(e, p, creer_arbre_vide(), creer_arbre_vide()) ;
 }

arbre_de_codage/arbre_binaire.h

@@ -1,10 +1,9 @@
 #ifndef __ARBRE_BINAIRE__
 #define __ARBRE_BINAIRE__
 
-typedef int Elt;
 typedef int bool;
 struct znoeud {
-  Elt elt ;
+  int elt ;
   int poids;
   struct znoeud *fils_gauche;
   struct znoeud *fils_droit; 
@@ -13,13 +12,13 @@ typedef struct znoeud noeud ;
 typedef struct znoeud * arbre;
 
 arbre creer_arbre_vide(void);
-arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd);
+arbre creer_arbre_huffman(int e, int p, arbre fg, arbre fd);
 arbre fils_gauche(arbre a);
 arbre fils_droit(arbre a);
-Elt racine(arbre a);
+int racine(arbre a);
 bool est_arbre_vide(arbre a);
 
-arbre creer_feuille(Elt e, int p) ;
+arbre creer_feuille(int e, int p) ;
 bool est_feuille(arbre a) ;
 char *arbre_rechercher(arbre a, char c, char*s);
 #endif

main_compress.c

@@ -2,11 +2,11 @@
 #include "arbre_de_codage/arbre_binaire.c"
 #define ASCII_EXT 256 
 
-arbre huffman(arbre H, int Tp[], int Tl[]);
-void frequence(int Tp[], int Tl[], FILE *file);
-void tri_tab(int T[],int T2[],int n);
-void afficher_tab(int Tp[], int Tl[], int n);
-void init_tab(int T[], int Elt, int n);
+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){
@@ -19,118 +19,110 @@ int main(int argc, char **argv){
     printf("\nErreur : Veuillez mettre en argument un nom de fichier à compresser (Ex: %s text.txt)\n",argv[0]);
     return -1;
   }
-  // Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
+  // 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;
   }
-  // Récupérer fréquence
-  int Tp[ASCII_EXT],Tl[ASCII_EXT];
-  init_tab(Tp,-1,ASCII_EXT);
-  init_tab(Tl,-1,ASCII_EXT);
-  int compteur;
-  compteur=0;
-  frequence(Tp,Tl,file);
-  // Tri
-  tri_tab(Tp,Tl,ASCII_EXT);
-  afficher_tab(Tp,Tl,ASCII_EXT);
+  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;
-  huff = huffman(creer_arbre_vide(),Tp,Tl);
+  printf("Huffman : \n");
+  //huff = huffman(T);
+  printf("Arbre :\n");
   return 0;
 }
 
-void init_tab(int T[], int Elt, int n){
+void init_tab(arbre T[], int Elt, int n){
   int i;
   for(i=0;i<n;i++){
-    T[i]=Elt;
+    T[i]=creer_feuille(Elt,Elt);
   }
 }
 
-void frequence(int Tp[], int Tl[], FILE *file){
+void frequence(arbre T, FILE *file){
   int c;
   while((c=fgetc(file))!=EOF){
-    if(Tl[c]!=-1){
-      Tp[c]++;
+    if(T[c].poids!=-1){
+      T[c].poids++;
     }
     else{
-      Tl[c]=c;
-      Tp[c]=1;
+      T[c].elt=c;
+      T[c].poids=1;
     }
   }
 }
 
-void tri_tab(int T[],int T2[],int n){
-    int i,j,tmp,tmp2;
-    for(i=0;i<n-1;i++){
-        for(j=i+1;j<n;j++){
-            if(T[i]>T[j]){
-            tmp=T[i];
-            tmp2=T2[i];
-            T[i]=T[j];
-            T2[i]=T2[j];
-            T[j]=tmp;
-            T2[j]=tmp2;
-             }
-        }
+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;
+      }
     }
-}
-
-void afficher_tab(int Tp[], int Tl[], int n){
-  printf("\n");
-  int i;
-  for (i=0;i<n;i++){
-    printf("T[%d] = %d (%d)\n",i,Tp[i],Tl[i]);
   }
 }
 
-int compteur_tab(int T[],int n){
-  int compteur,i;
+int compteur_tab(arbre T, int n){
+  int i,compteur;
   compteur=0;
   for(i=0;i<n;i++){
-    if(T[i]!=-1){
+    if(T[i].poids != -1){
       compteur++;
     }
   }
   return compteur;
 }
 
-int i_index_min_tab(int T[],int i,int n){
-  int index_min;
-  index_min=0;
-  int k;
-  for(k=1;k<n;k++){
-    if(T[k]<T[index_min]){
-      index_min=k;
-      i--;
-    }
-    if(i==0){
-      return index_min;
-    }
+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);
   }
-  return index_min;
 }
 
-arbre huffman(arbre H, int Tp[], int Tl[]){
-  /*
-    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
-  */
+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)
-  int i,compteur;
-  i=0;
-  compteur=compteur_tab(Tl,ASCII_EXT);
-  while(compteur != 1){
-    printf("\n Test n°%d \n",i++);
-    int l1,l2,p1,p2;
-    l1=Tl[i_index_min_tab(Tl,1,ASCII_EXT)];
-    p1=Tp[i_index_min_tab(Tl,1,ASCII_EXT)];
-    l2=Tl[i_index_min_tab(Tl,2,ASCII_EXT)];
-    p2=Tp[i_index_min_tab(Tl,2,ASCII_EXT)];
-    arbre fg,fd;
-    fg=creer_feuille(l1,p1);
-    fd=creer_feuille(l2,p2);
-    H=creer_arbre_huffman(0,p1+p2,fg,fd);
-    // ajouter le nouveau poid
-    compteur--;
+  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=
   }
-  return H;
 }