tvolleri / ima3_projet_pa_2019

Commit d6caeeb7857e4be123b85c561a0deba7c360366a

Authored by vsalingu
1 parent 73e92d24

fonction cons_arbre pour libérer le main

Showing 1 changed file with 136 additions and 25 deletions   Show diff stats
Inline Side-by-side
... ... @@ -25,26 +25,38 @@ ptarbre rech(ptarbre arbre, char lettre)
25 25 // recherche une lettre en ième position (correspondant à arbre)
26 26 // Retourne l'adresse de l'arbre contenant la lettre à cette position
27 27 {
  28 + printf("rech adr abre deb %p \n", arbre);
28 29 if (arbre!=NULL)
29 30 {
30 31 printf("arbre lettre %c \n", arbre->lettre);
31 32 while ((arbre->suivant!=NULL) && (arbre->lettre != lettre))
32 33 {
33   - printf("lettre : %c lettre cherchee : %c adr arbre %p \n", arbre->lettre,lettre, arbre);
  34 + printf("lettre : %c lettre cherchee : %c adr arbre %p \n", arbre->lettre,lettre, arbre);
34 35 arbre=(arbre->suivant);
  36 + printf("adr arbre while %p \n", arbre);
35 37 }
36 38 }
  39 + printf("retourne adr %p lettre %c\n", arbre, arbre->lettre);
37 40 return arbre;
38 41 }
39   -void init_dico(ptarbre *parbre, char lettre)
  42 +
  43 +void init_dico(ptarbre* parbre, char lettre)
40 44 {
41 45 (*parbre)=malloc(sizeof(cell));
42 46 (*parbre)->fils=malloc(sizeof(cell));
  47 + (*parbre)->suivant=NULL;
  48 + (*parbre)->lettre=lettre;
  49 + (*parbre)->fin_mot=false;
  50 +}
  51 +
  52 +void ajout_dico_tete(ptarbre *parbre, char lettre)
  53 +{
  54 + (*parbre)->fils=malloc(sizeof(cell));
43 55 (*parbre)->fils->suivant=NULL;
44 56 (*parbre)->suivant=NULL;
45 57 (*parbre)->lettre=lettre;
46 58 (*parbre)->fin_mot=false;
47   - printf("init dico\n");
  59 + printf("ajout dico tete adr %p\n",(* parbre));
48 60 }
49 61  
50 62 void ajout_dico(ptarbre *parbre, ptarbre *parbresuiv, char lettre)
... ... @@ -55,8 +67,8 @@ void ajout_dico(ptarbre *parbre, ptarbre *parbresuiv, char lettre)
55 67 (*parbresuiv)->fils->suivant=NULL;
56 68 (*parbresuiv)->suivant=NULL;
57 69 (*parbresuiv)->fin_mot=false;
58   - (*parbresuiv)->lettre=lettre;
59   - printf("ajout lettre : %c à %p \n",(*parbresuiv)->lettre, parbresuiv);
  70 + (*parbre)->lettre=lettre;
  71 + printf("ajout lettre : %c à %p \n",(*parbre)->lettre, parbre);
60 72 }
61 73  
62 74 void affiche_dico(ptarbre arbre, int n_lettre, char mot[])
... ... @@ -75,7 +87,7 @@ void affiche_dico(ptarbre arbre, int n_lettre, char mot[])
75 87 n_lettre++;
76 88 affiche_dico(arbre->fils,n_lettre,mot);
77 89 }
78   - printf("\n");
  90 + printf("\n");
79 91 if (arbre->suivant != NULL)
80 92 {
81 93 printf("%s",mot);
... ... @@ -102,55 +114,151 @@ void free_tree(cell **ptr_tree)
102 114 }
103 115 }
104 116  
  117 +void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec, FILE* fp)
  118 +{
  119 +
  120 + char c,t;
  121 + ptarbre rec;
  122 + while (fscanf(fp,"%c",&c)!= EOF) // lecture de tout le fichier
  123 + {
  124 + printf("c= %c \n",c);
  125 + if (c != '\n')
  126 + {
  127 + if ((*parbre_originel)==NULL) // Cas où c'est le premier mot premiere lettre
  128 + {
  129 + printf("arbre ori =NULL \n");
  130 + init_dico(parbre_originel,c);
  131 + printf("lettre arbre :%c \n",(*parbre_originel)->lettre);
  132 + (*parbre_prec)=(*parbre_originel);
  133 + (*parbre)=(*parbre_originel)->fils;
  134 + }
  135 + else if ((*parbre)==NULL) // premier mot de l'arbre
  136 + {
  137 + printf("arbre null\n");
  138 + init_dico(parbre,c);
  139 + (*parbre)=(*parbre)->fils;
  140 + }
  141 +
  142 + else // Cas où le dico n'est pas vide
  143 + {
  144 + // printf("lettre arbre :%c \n",arbre->lettre);
  145 + printf(" dico pas vide c: %c\n", c);
  146 + rec=rech((*parbre),c);
  147 + if (rec->lettre!=c)
  148 + {
  149 +
  150 + if (rec==(*parbre)) // 1ere lettre de la liste
  151 + {
  152 + printf("1ere lettre\n");
  153 + ajout_dico_tete(parbre,c);
  154 + (*parbre)=(*parbre)->fils;
  155 + }
  156 +
  157 + if (rec->suivant==NULL)
  158 + {
  159 +
  160 + printf("rech suiv = NUll \n");
  161 + ajout_dico(&(rec),&(rec->suivant),c);
  162 +
  163 + // printf("ajout de : %c à %p et fils :%p\n", rec->lettre, rec, rec->fils);
  164 + (*parbre_prec)=(*parbre);
  165 + (*parbre)=rec->suivant->fils;
  166 + }
  167 + }
  168 +
  169 + else
  170 + {// Cas où le début du mot existe déjà et qu'on le complète
  171 + //printf("rech lettre =lettre rec lettre %c rec lettre fils %c%c\n", rec->lettre, rec->fils->lettre);
  172 + // printf("adr rec %p adr rec fils %p\n", rec, rec->fils);
  173 + (*parbre_prec)=(*parbre);
  174 + (*parbre)=rec->fils; // On va à l'étage d'après pour former le mot dans l'arbre
  175 + //
  176 + }
  177 +
  178 +
  179 + }
  180 + }
  181 + else {
  182 + printf("c==n \n");
  183 + if ((*parbre_originel)!=NULL)
  184 + {
  185 + printf("%c \n", (*parbre_prec)->lettre);
  186 + (*parbre_prec)->fin_mot=true; // Cette lettre est la dernière du mot
  187 + }
  188 + // affiche_dico((*parbre_originel),n_lettre,mot);
  189 + printf("remise à 0\n");
  190 + printf("avant egal arbre %p arbre ori %p \n", (*parbre), (*parbre_originel));
  191 + (*parbre)=(*parbre_originel); // On revient en haut de l'arbre pour commencer un nouveau mot
  192 + printf("apres egal arbre %p arbre ori %p \n", (*parbre), (*parbre_originel));
  193 + }
  194 + //arbre=arbre_originel;
  195 + }
  196 +}
105 197  
106 198 int main()
107 199 {
  200 + char mot[30];
  201 + int n_lettre=0;
108 202 ptarbre arbre_originel,arbre,arbre_prec;
109 203 arbre_originel=NULL;
  204 + printf("adr arbre _ori %p\n", &arbre_originel);
110 205 arbre=NULL;
111   - char c,t, mot[30];
112   - int n_lettre=0;
113   - ptarbre rec;
114 206 // Ouvrir fichier
115 207 FILE *fp = fopen("words1.txt","r");
116 208 if (fp==NULL)
117 209 printf("words1 inaccessible \n",fp);
118 210 else
119 211 printf("words1 accessible \n",fp);
120   -
121   - while (fscanf(fp,"%c",&c)!= EOF) // lecture de tout le fichier
  212 + cons_arbre(&arbre_originel, &arbre, &arbre_prec,fp);
  213 + /* while (fscanf(fp,"%c",&c)!= EOF) // lecture de tout le fichier
122 214 {
123 215 if (c != '\n')
124 216 {
125   - if (arbre_originel==NULL) // Cas où c'est le premier mot
  217 + if (arbre_originel==NULL) // Cas où c'est le premier mot premiere lettre
126 218 {
127 219 printf("arbre =NULL \n");
128 220 init_dico(&arbre_originel,c);
129 221 printf("lettre arbre :%c \n",arbre_originel->lettre);
130 222 arbre_prec=arbre_originel;
131 223 arbre=arbre_originel->fils;
132   - }
  224 + }
  225 + else if (arbre==NULL) // premier mot de l'arbre
  226 + {
  227 + init_dico(&arbre,c);
  228 + arbre=arbre->fils;
  229 + }
133 230  
134 231 else // Cas où le dico n'est pas vide
135 232 {
136   - printf("lettre arbre :%c \n",arbre->lettre);
  233 + // printf("lettre arbre :%c \n",arbre->lettre);
137 234 printf(" c: %c\n", c);
138 235 rec=rech(arbre,c);
139   -
140   - if (rec->suivant==NULL && rec->lettre!=c)
  236 + if (rec->lettre!=c)
141 237 {
  238 +
  239 + if (rec==arbre) // 1ere lettre de la liste
  240 + {
  241 + printf("1ere lettre\n");
  242 + ajout_dico_tete(&arbre,c);
  243 + arbre=arbre->fils;
  244 + }
  245 +
  246 + if (rec->suivant==NULL)
  247 + {
142 248  
143   - printf("rech suiv = NUll \n");
144   - ajout_dico(&(arbre),&(rec->suivant),c);
145   - // printf("ajout de : %c à %p et fils :%p\n", rec->lettre, rec, rec->fils);
146   - arbre_prec=arbre;
147   - arbre=rec->suivant->fils;
  249 + printf("rech suiv = NUll \n");
  250 + ajout_dico(&(rec),&(rec->suivant),c);
  251 +
  252 + // printf("ajout de : %c à %p et fils :%p\n", rec->lettre, rec, rec->fils);
  253 + arbre_prec=arbre;
  254 + arbre=rec->suivant->fils;
  255 + }
148 256 }
149   -
150 257  
151 258 else
152 259 {// Cas où le début du mot existe déjà et qu'on le complète
153   - printf("rech suiv pas null rec lettre %c\n", rec->lettre);
  260 + //printf("rech lettre =lettre rec lettre %c rec lettre fils %c%c\n", rec->lettre, rec->fils->lettre);
  261 + // printf("adr rec %p adr rec fils %p\n", rec, rec->fils);
154 262 arbre_prec=arbre;
155 263 arbre=rec->fils; // On va à l'étage d'après pour former le mot dans l'arbre
156 264 //
... ... @@ -160,7 +268,7 @@ int main()
160 268 }
161 269 }
162 270 else {
163   - printf("else\n");
  271 + printf("c=='\ n' \n");
164 272 if (arbre_originel!=NULL)
165 273 {
166 274 printf("%c \n", arbre_prec->lettre);
... ... @@ -169,11 +277,14 @@ int main()
169 277  
170 278 affiche_dico(arbre_originel,n_lettre,mot);
171 279 printf("remise à 0\n");
  280 + printf("avant egal arbre %p arbre ori %p \n", arbre, arbre_originel);
172 281 arbre=arbre_originel; // On revient en haut de l'arbre pour commencer un nouveau mot
  282 + printf("apres egal arbre %p arbre ori %p \n", arbre, arbre_originel);
173 283 }
174 284 //arbre=arbre_originel;
175 285 }
176   - printf("arbre originel lettre %c \n", arbre_originel->fils->lettre);
  286 + */
  287 + // printf("arbre originel lettre %c \n", arbre_originel->fils->lettre);
177 288 affiche_dico(arbre_originel,n_lettre,mot);
178 289 free_tree(&arbre);
179 290 fclose(fp);
... ...