diff --git a/Compress.c b/Compress.c
new file mode 100644
index 0000000..1278400
--- /dev/null
+++ b/Compress.c
@@ -0,0 +1,425 @@
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include<stdlib.h>
+#include "gestion_des_fichiers/gestion_fichiers.h"
+#include "main_compress.h"
+#include "arbre_de_codage/arbre_binaire.h"
+#ifdef DEBUG
+#define DEBUG 1
+#endif
+
+#define ASCII_EXT 256
+
+// main_compress.c [nom_du_fichier_a_compresser]
+/*#########################################################################################################*/
+
+/*                               Partie Fonction pour compression                                          */
+
+/*#########################################################################################################*/
+
+void init_tab(arbre T[], int n){
+  int i;
+  for(i=0;i<n;i++){
+    T[i]=creer_feuille(-1,-1);
+  }
+}
+
+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;
+  arbre 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 (%c)\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();
+  int i;
+  i=0;
+  while(T[i]->poids==-1){
+    i++;
+  }
+  int Index;
+  Index=i;
+  while(Index<ASCII_EXT-1){
+    arbre tmp=malloc(sizeof(noeud*));
+    tmp->elt=NULL;
+    tmp->fils_gauche=T[Index];
+    tmp->fils_droit=T[Index+1];
+    tmp->poids=T[Index]->poids +T[Index+1]->poids;
+    T[Index+1]=tmp;
+    printf("%d (%c | %c)\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
+    Index++;
+    tri_tab(T,ASCII_EXT);
+  }
+  return T[Index];
+}
+
+void get_lexique(FILE *file, plex Code[], arbre huff){
+  int c_int;
+  char c_char;
+  rewind(file);
+  while((c_int=fgetc(file))!=EOF){
+    c_char = c_int;
+    if(Code[c_int]->lettre!=c_char){
+      Code[c_int]->lettre=c_char;
+      char s[9]="";
+      int f[1]={0};
+      arbre_rechercher(huff,c_char,s,0,f);
+      printf("Code %c : %s\n",c_int,s);
+      Code[c_int]->code=s;
+    }
+  }
+}
+
+void init_codage(plex Code[], int n){
+  int i;
+  for(i=0;i<n;i++){
+    lex * tmp = malloc(sizeof(lex));
+    tmp->code=NULL;
+    tmp->lettre=NULL;
+    Code[i]=tmp;
+  }
+}
+
+/*#########################################################################################################*/
+
+/*                                  Partie Gestion de fichiers                                             */
+
+/*#########################################################################################################*/
+
+
+Bin_file *Ouv_Bit(char *p,char mode)
+{
+    Bin_file *A;
+    A=malloc(sizeof(Bin_file));                                 //On libère l'espace suffisant pour un élèment de type Bin_files
+    A->mode=mode;                                               //On récupére le mode d'ouverture du fichier et on le rentre dansle struct
+    if(mode=='r')                                               //suivant le mode (écriturer w ou lecture r) on va ouvrir le fichier a l'aide de fopen et on 
+    {                                                           //enregistre cela dans lestruct Bin_files
+        A->file=fopen(p,"rb");
+    }
+    else
+    {
+        A->file=fopen(p,"wb");
+    }
+    A->record_length=0;                                         //On va ensuite initialiser tous les élèments du struct.
+    A->i_record=0;
+    A->i_octet=0;
+    A->nb_octets=0;
+    return A;
+}
+
+void Ec_Bit(Bin_file *output,char bit)                              // On veux une fonction capable d'écrire un bit dans un fichier
+{
+    unsigned char octet,b;                                          // On utilise deux variables octet et b qui vont permettre de récupérer les élèmets a écrire.
+    int i;
+    
+    output->octet[output->i_octet]=bit;                             // On va mettre le premier élèment du tableau octet de la struct Bin_file a la valeur de bit
+    output->i_octet++;                                              //On incremente aussi i_octet pour ne pas réecrire surcette valeur 
+    if (output->i_octet==8)                                         //Si le tableau octet est plein on va aller écire dans le tableau record
+    {                                                          
+        octet=0;                                                    //on passe octet a 0 et b a 0x80 soit 1000 0000
+        b=0x80;                                                     // cela permet de toujoursgarder 1 en bit de poids fort dans b apre les décalages a droite
+        for(i=0;i<8;i++)                                        
+        {
+            if(output->octet[i]=='1')                               //si on a un '1' dans le tableau octet on va mettre dans octet le résultats de octet ou b
+            {
+                octet=octet|b;                                      // On va alors creer une "copie" du tableau octet dans octet 
+            }
+            b=b>>1;
+        }
+        output->i_octet=0;                      
+        output->record[output->i_record]=octet;                     // On va apres le for remetre i_octet a 0 puis on passe dans record la valeur du char octet pour conserver
+        output->i_record++;                                         //ce que l'on veut écrire
+        output->nb_octets++;                                        //On incrémente aussi i record pour passer a l'élèment suivant et nb_octets car on en a traiter un autre
+        if(output->i_record==BLOCK_SIZE)                            //On vérifie ensuite que record qui sert de buffer soit plein avant d'écrire sont contenue.
+        {
+            fwrite(output->record,1,BLOCK_SIZE,output->file);
+            output->i_record=0;                                     //si on éceit on reinitialise i record pour passer auxélèments suivant
+        }
+    }
+
+}
+
+
+char Lec_Bit(Bin_file*input)
+{
+    char bit;                                                                   //On veut lire un fichier bit a bit. Pourcela on va vérifier si la record length est nul ou non
+    unsigned char x, b=0x80;                                                    // Ici on déclare de char, x va permettre de récupérer un octet de record
+                                                                                // b vas servir de masque. Il nous permettra de savoir quelle valeur possède les bits des élèment de record
+    int i;                                                                      //i est un compteur utiliser pour les boucles for
+
+
+    if (input->record_length==0){                                               // Si le buffer (record),est vide on va aller chercher lesélèments du fichier                               
+    
+        input->record_length = fread(input->record,1,BLOCK_SIZE,input->file);   //Pour cela on récupère dans record_length le nombre d'élèment de input-file et on les écrit dans record                
+        input->i_record=0;                                                      //On réinitialise l'indice de record pour recommencerdepuis le début.                                           
+        
+        x = input->record[input->i_record] ;                                    //On réupère la valeurde record[i_record] dans x 
+        for(i=0;i<8;i++) {
+            if(x&b) input->octet[i]='1';                                        //On va alors tester les bits de x grace a x&b. Cela permet de renvoyer 1 si lesdeux bits sont a 1 
+            else input->octet[i]='0';                                           // si le test est vrai on ajoute le char 1 dans octet sinon 0
+            b=b>>1;                                                             //On décale ensuite b de 1 bit a droite pourconserver le 1 a l'endroit que l'on veut tester
+        }
+        input->octet[8]=0;                                                      //On passe le derneir élèment de octet a 0 pour marquer la fin de chaine de caractère 
+        input->i_record++;                                                      //on incrémente i record  pour aller a l'élèment suivant on réinitialise i_octet et 
+        input->i_octet=0;
+        input->nb_octets=input->nb_octets+input->record_length;                 //On ajoute la taille du record dans nb_octets pour conserver le bon nombred'élèment traité
+    }
+
+    bit=input->octet[input->i_octet];                                           //On passe alors bit a la valeur de octet[0]
+    input->i_octet++;                                                           //on incrémente ensuite le compteur
+    if(input->i_octet==8){                                                      // Si on a écrit huit bit dans octet on va aller tester l'élèment suivant de record
+        x = input->record[input->i_record] ;
+        for(i=0;i<8;i++) {
+            if(x&b) input->octet[i]='1';
+            else input->octet[i]='0';
+            b=b>>1;
+        }
+        input->octet[8]=0;
+        input->i_record++;
+        input->i_octet=0;;
+        if(input->i_record==BLOCK_SIZE){                                         //si on a parcouru tous le buffer on repasse a 0 la longueur
+            input->record_length=0;        
+        } 
+    }
+    return bit;                                                                 // on renvoie le bit 
+}
+
+
+int Ferm_Bit(Bin_file *fichier)
+{
+    unsigned char octet,b;                                                      // On déclare deux unsigned char octet et b qui auront la même utilité que dans Ec_Bit
+    int nb_octets=fichier->nb_octets;                                   
+    
+    if(fichier->mode="w")                                                       // Si le fichier a été ouvert en mode écriture on va aller écrire la fin du buffer  
+    {                                                                           // dans le fichier. 
+        if(fichier->i_octet!=0)                                                 //Pour cela on répète le même principe que dans Ec_Bit
+        {
+            octet=0;
+            b=0x80;
+            int i;
+            for(i=0;i<fichier->i_octet;i++)
+            {
+                if(fichier->octet[i]=='1')
+                {
+                    octet=octet|b;
+                }
+                b=b>>1;
+            }
+            fichier->record[fichier->i_record]=octet;
+            fichier->i_record++;
+            nb_octets++;
+        }
+        if(fichier->i_record!=0)
+        {
+            fwrite(fichier->record,1,BLOCK_SIZE,fichier->file);
+        }
+    }
+    fclose(fichier->file);                                                      //On ferme ensuite le fichier et on libère l'espace occupé par le srtuct Bin_File.
+    free(fichier);
+    return nb_octets;
+}
+
+/*#########################################################################################################*/
+
+/*                                     Partie Arbre binaire                                                */
+
+/*#########################################################################################################*/
+
+
+arbre creer_arbre_vide (void)
+{
+  return NULL ;
+}
+
+arbre creer_arbre_huffman(Elt e, int p, arbre fg, arbre fd)
+{
+  noeud * tmp = malloc(sizeof(noeud));
+  tmp->elt=e;
+  tmp->poids=p;
+  tmp->fils_gauche=fg;
+  tmp->fils_droit=fd;
+  return tmp;
+}
+
+arbre fils_gauche(arbre a)
+{
+  assert(!est_arbre_vide(a));
+  return a->fils_gauche;
+}
+
+arbre fils_droit(arbre b)
+{
+  assert(!est_arbre_vide(b));
+  return b->fils_droit;
+}
+
+Elt racine(arbre a)
+{
+  assert(!est_arbre_vide(a));
+  return a->elt;
+}
+
+bool est_arbre_vide(arbre a)
+{
+  return (a == NULL) ;
+}
+
+arbre creer_feuille(Elt e, int p)
+{
+  return creer_arbre_huffman(e, p, creer_arbre_vide(), creer_arbre_vide()) ;
+}
+
+bool est_feuille(arbre a)
+{
+  if (est_arbre_vide(a))
+    return 0 ;
+  return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
+}
+
+void free_noeud(arbre a)
+{
+  assert(!est_arbre_vide(a));
+  free(a);
+}
+
+void free_arbre(arbre a)
+{
+  if(!est_arbre_vide(a)){
+    free_arbre(fils_gauche(a));
+    free_arbre(fils_droit(a));
+    free(a);
+  }
+}
+
+void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]){
+  /*
+    De ce que j'ai testé, ça marche de temps en temps même en ne changeant pas le caractère recherché, je pense qu'il y a un problème avec VSCode encore une fois LOL (Yûki)
+  */
+  #ifdef DEBUG
+    printf("\nDEBUG ARBRE RECHERCHER : \n");
+    printf("  est_arbre_vide(a) : %d\n",est_arbre_vide(a));
+    printf("  est_feuille(a) : %d\n",est_feuille(a));
+    printf("  racine(a) : %c\n",racine(a));
+    printf("  c : %c\n",c);
+    printf("  est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
+    printf("  est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
+    printf("  S : %s\n",s);
+    printf("--FIN DEBUG ARBRE RECHERCHER--\n");
+  #endif
+  
+  if(!est_arbre_vide(a)){
+    if((a->fils_gauche==NULL)&&(a->fils_droit==NULL)&&(racine(a)==c)){
+      found[0]=1;
+      s[s_len]='\0';
+      return ;
+    }
+    if(!est_arbre_vide(fils_gauche(a))&&(found[0]==0)){
+      s[s_len]='0';
+      arbre_rechercher(fils_gauche(a),c,s,s_len+1,found);
+    }
+    if(!est_arbre_vide(fils_droit(a))&&(found[0]==0)){
+      s[s_len]='1';
+      arbre_rechercher(fils_droit(a),c,s,s_len+1,found);
+    }
+    
+  }
+}
+
+/*#########################################################################################################*/
+
+/*                                                  Main                                                   */
+
+/*#########################################################################################################*/
+
+
+int main(int argc, char **argv){
+  Bin_file *p;
+  char *filename = argv[1];
+  char mode= 'r';
+
+  // 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'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
+  else if(!(p=Ouv_Bit(filename,mode))){
+    printf("\nErreur : Fichier %s inexistant\n",filename);
+    return -2;
+  }
+  printf("Tableau : \n");
+  arbre N[ASCII_EXT];          // Initialisation de l'arbre
+
+  printf("Tableau initialisé -1: \n");
+  init_tab(N,ASCII_EXT);   // On initialise l'arbre avec des poids de -1
+
+  printf("Tableau get freq : \n");
+  
+  frequence(N,p->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(N);
+  
+  printf("Arbre :\n");
+  int found[1]={0};
+  plex Codage[ASCII_EXT];
+  init_codage(Codage,ASCII_EXT);
+  get_lexique(p->file, Codage,huff);
+  Ferm_Bit(p);
+  
+  return 0;
+}
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 5f31453..bfc585f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,19 +1,19 @@
 CC = gcc
 CCOPTS = -Wall
 
-all: main
+all: main_compress
 
-arbre_naire.o:	arbre_naire.c arbre_naire.h
-	${CC} ${CCOPTS} -c arbre_naire.c
+arbre_binaire.o:	arbre_de_codage/arbre_binaire.c arbre_de_codage/arbre_binaire.h
+	${CC} ${CCOPTS} -c arbre_de_codage/arbre_binaire.c
 
-arbre_binaire.o:	arbre_binaire.c arbre_binaire.h
-	${CC} ${CCOPTS} -c arbre_binaire.c
+gestion_fichiers.o:	gestion_des_fichiers/gestion_fichiers.c gestion_des_fichiers/gestion_fichiers.h
+	${CC} ${CCOPTS} -c gestion_des_fichiers/gestion_fichiers.c
 
-main.o:	main.c
-	${CC} ${CCOPTS} -c main.c
+main_compress.o:	main_compress.c
+	${CC} ${CCOPTS} -c main_compress.c
 
-main:	main.o arbre_naire.o arbre_binaire.o
-	${CC} ${CCOPTS} -o main main.o arbre_naire.o arbre_binaire.o
+main_compress:	main_compress.o arbre_binaire.o gestion_fichiers.o
+	${CC} ${CCOPTS} -o main_compress main_compress.o arbre_binaire.o gestion_fichiers.o
 
 clean:
-	rm *.o ; rm main
+	rm *.o ; rm main_compress
diff --git a/arbre_de_codage/arbre_binaire.c b/arbre_de_codage/arbre_binaire.c
index bf0df88..a37b109 100644
--- a/arbre_de_codage/arbre_binaire.c
+++ b/arbre_de_codage/arbre_binaire.c
@@ -3,9 +3,8 @@
 #include <assert.h>
 #include <string.h>
 #include "arbre_binaire.h"
-#ifdef DEBUG
 #define DEBUG 1
-#endif
+
 arbre creer_arbre_vide (void)
 {
   return NULL ;
@@ -51,8 +50,9 @@ arbre creer_feuille(Elt e, int p)
 
 bool est_feuille(arbre a)
 {
-  if (est_arbre_vide(a))
-    return 0 ;
+  if(est_arbre_vide(a)){
+    return 0;
+  }
   return (est_arbre_vide(a->fils_gauche) && est_arbre_vide(a->fils_droit)) ;
 }
 
@@ -75,21 +75,29 @@ void arbre_rechercher(arbre a, Elt c, char s[], int s_len, int found[]){
   /*
     De ce que j'ai testé, ça marche de temps en temps même en ne changeant pas le caractère recherché, je pense qu'il y a un problème avec VSCode encore une fois LOL (Yûki)
   */
+  /*
   #ifdef DEBUG
     printf("\nDEBUG ARBRE RECHERCHER : \n");
     printf("  est_arbre_vide(a) : %d\n",est_arbre_vide(a));
-    printf("  est_feuille(a) : %d\n",est_feuille(a));
-    printf("  racine(a) : %c\n",racine(a));
-    printf("  c : %c\n",c);
-    printf("  est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
-    printf("  est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
-    printf("  S : %s\n",s);
-    printf("--FIN DEBUG ARBRE RECHERCHER--\n");
+    if(!est_arbre_vide(a)){
+      printf("  est_feuille(a) : %d\n",(est_feuille(a)));
+      printf("  racine(a) : %c\n",racine(a));
+      printf("  c : %c\n",c);
+      printf("  est_arbre_vide(fils_gauche(a)) : %d\n",est_arbre_vide(fils_gauche(a)));
+      printf("  est_arbre_vide(fils_droit(a)) : %d\n",est_arbre_vide(fils_droit(a)));
+      printf("  S : %s\n",s);
+      printf("--FIN DEBUG ARBRE RECHERCHER--\n");
+    }
+    else{
+      printf("ARBRE VIDE\n");
+    }
   #endif
-  
+  */
   if(!est_arbre_vide(a)){
-    if((a->fils_gauche==NULL&&a->fils_droit==NULL)&&racine(a)==c){
+    printf("Racine : %c",racine(a));
+    if(racine(a)==c){
       found[0]=1;
+      s[s_len]='\0';
       return ;
     }
     if(!est_arbre_vide(fils_gauche(a))&&(found[0]==0)){
diff --git a/arbre_de_codage/arbre_binaire.h b/arbre_de_codage/arbre_binaire.h
index b7649a9..3918a90 100644
--- a/arbre_de_codage/arbre_binaire.h
+++ b/arbre_de_codage/arbre_binaire.h
@@ -1,7 +1,7 @@
 #ifndef __ARBRE_BINAIRE__
 #define __ARBRE_BINAIRE__
 
-typedef char Elt;
+typedef int Elt;
 typedef int bool;
 struct znoeud {
   char elt ;
diff --git a/gestion_des_fichiers/gestion_fichiers.h b/gestion_des_fichiers/gestion_fichiers.h
index 9ef940d..323c956 100644
--- a/gestion_des_fichiers/gestion_fichiers.h
+++ b/gestion_des_fichiers/gestion_fichiers.h
@@ -6,9 +6,8 @@
 #include <stdio.h>
 #define BLOCK_SIZE 128                  //il faut changer sa valeur pour les tests avec blocsize = nb d'octet qu'on veut écrire
 
-typedef struct
-{
-    FILE*file;                          // Identificateur fichier
+struct zBin_file{
+    FILE *file;                          // Identificateur fichier
     char mode;                          //Mode de lecture r ou w
     unsigned char record[BLOCK_SIZE];   //Tampon pour lire ou écrire
     int record_length;                  //nombre d'élèments du tampon
@@ -17,7 +16,9 @@ typedef struct
     int i_octet;                        //indice dansl'octet
     int nb_octets;                      //Nb octet lis/écrit
     
-}Bin_file;
+};
+typedef struct zBin_file Bin_file;
+typedef struct zBin_file pBin_file;
 
 Bin_file *Ouv_bit(char *p,char mode);
 
diff --git a/gestion_des_fichiers/test.txt b/gestion_des_fichiers/test.txt
index 5ebc423..a85c42e 100644
--- a/gestion_des_fichiers/test.txt
+++ b/gestion_des_fichiers/test.txt
@@ -1 +1 @@
-mon code C est le meilleure : int myfunction(arbre ahah){printf("coucou");pointeur->quipointe;}
\ No newline at end of file
+abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ1234567890-_()[]{},. 
\ No newline at end of file
diff --git a/main_compress.c b/main_compress.c
index ebf7810..5413a49 100644
--- a/main_compress.c
+++ b/main_compress.c
@@ -1,12 +1,11 @@
 #include <stdio.h>
+#include <string.h>
 #include "arbre_de_codage/arbre_binaire.c"
-#define ASCII_EXT 256 
+#include "main_compress.h"
+#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 n);
 
 // main_compress.c [nom_du_fichier_a_compresser]
 int main(int argc, char **argv){
@@ -19,7 +18,7 @@ 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'o(uverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
+  // Vérification de l'ouverture du fichier en mode lecture binaire !! FONCTION A MODIFIER
   else if(!(file=fopen(filename,mode))){
     printf("\nErreur : Fichier %s inexistant\n",filename);
     return -2;
@@ -34,14 +33,14 @@ int main(int argc, char **argv){
   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(N);
-  
-  // Récupération du code de chaque charactere
+
+ // Récupération du code de chaque charactere
   printf("Code : \n");
-  char s[80]="";
+  char s[10]="";
   int f[1]={0};
   char search='-';
   arbre_rechercher(huff,search,s,0,f);
@@ -51,7 +50,14 @@ int main(int argc, char **argv){
   else{
     printf("\nPas Trouve\n");
   }
+  plex Codage[ASCII_EXT];
+  rewind(file);
+  init_codage(Codage,ASCII_EXT);
+  get_lexique(file, Codage,huff);
   printf("\nFIN TEST\n");
+
+
+
   return 0;
 }
 
@@ -62,6 +68,16 @@ void init_tab(arbre T[], int n){
   }
 }
 
+void init_codage(plex Code[], int n){
+  int i;
+  for(i=0;i<n;i++){
+    lex * tmp = malloc(sizeof(lex));
+    tmp->code=NULL;
+    tmp->lettre=0;
+    Code[i]=tmp;
+  }
+}
+
 void frequence(arbre T[], FILE *file){
   int c;
   while((c=fgetc(file))!=EOF){
@@ -104,13 +120,13 @@ 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);
+    printf("T[%d] = %d (%c)\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();
@@ -123,14 +139,30 @@ arbre huffman(arbre T[]){
   Index=i;
   while(Index<ASCII_EXT-1){
     arbre tmp=malloc(sizeof(noeud*));
-    tmp->elt=-1;
+    tmp->elt=0;
     tmp->fils_gauche=T[Index];
     tmp->fils_droit=T[Index+1];
     tmp->poids=T[Index]->poids +T[Index+1]->poids;
     T[Index+1]=tmp;
-    printf("%d %c %c\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
+    printf("%d (%c | %c)\n",tmp->poids,tmp->fils_gauche->elt,tmp->fils_droit->elt);
     Index++;
     tri_tab(T,ASCII_EXT);
   }
   return T[Index];
-}
\ No newline at end of file
+}
+
+void get_lexique(FILE *file, plex Code[], arbre huff){
+  int c_int;
+  char c_char;
+  while((c_int=fgetc(file))!=EOF){
+    c_char = c_int;
+    if(Code[c_int]->lettre!=c_char){
+      Code[c_int]->lettre=c_char;
+      char s[9]="";
+      int f[1]={0};
+      arbre_rechercher(huff,c_char,s,0,f);
+      printf("Code %c : %s\n",c_int,s);
+      Code[c_int]->code=s;
+    }
+  }
+}
diff --git a/main_compress.h b/main_compress.h
new file mode 100644
index 0000000..21a0b47
--- /dev/null
+++ b/main_compress.h
@@ -0,0 +1,21 @@
+#ifndef __MAIN_COMPRESS__
+#define __MAIN_COMPRESS__
+#include "arbre_de_codage/arbre_binaire.h"
+#include <stdio.h>
+
+struct lexique{
+    char lettre;
+    char *code;
+};
+typedef struct lexique lex;
+typedef struct lexique* plex;
+
+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 n);
+void init_codage(plex Code[], int n);
+void get_lexique(FILE *file, plex Code[], arbre huff);
+
+#endif
\ No newline at end of file