tvolleri / ima3_projet_pa_2019

Commit e475e825cfa25c416d33a1cbd79c375b487bffe3

Authored by vsalingu
1 parent d6caeeb7

Modifs fontion print

Showing 1 changed file with 81 additions and 92 deletions   Show diff stats
Inline Side-by-side
... ... @@ -21,10 +21,12 @@ void init_dico()
21 21 arbre=NULL;
22 22 }
23 23 */
24   -ptarbre rech(ptarbre arbre, char lettre)
  24 +ptarbre rech(ptarbre arbre_ori, 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 + ptarbre arbre;
  29 + arbre=arbre_ori;
28 30 printf("rech adr abre deb %p \n", arbre);
29 31 if (arbre!=NULL)
30 32 {
... ... @@ -39,11 +41,56 @@ ptarbre rech(ptarbre arbre, char lettre)
39 41 printf("retourne adr %p lettre %c\n", arbre, arbre->lettre);
40 42 return arbre;
41 43 }
  44 +void print_tout(struct cell *arbre, int cpt, char *debut_mot)
  45 +{
  46 + //Return si aucune lettre stockée
  47 + if(arbre==NULL){
  48 + return;
  49 + }
  50 +
  51 + printf("%c", arbre->lettre);
  52 +
  53 +
  54 + //Si fin de mot, retour à la ligne
  55 + if(arbre->fin_mot == true){
  56 + printf("\n");
  57 +
  58 + //Si fin de mot mais encore des lettres dans 'Son' (-> merci mercier), on affiche la base commune
  59 + if (arbre->fils != NULL){
  60 + debut_mot[cpt] = arbre->lettre;
  61 + printf("%s", debut_mot);
  62 + }
  63 + }
  64 +
  65 + //On avance dans Son, on stock la lettre dans début_mot
  66 + debut_mot[cpt] = arbre->lettre;
  67 + cpt ++;
  68 +
  69 +
  70 + //On print Son
  71 + print_tout(arbre->fils, cpt, debut_mot);
  72 +
  73 + //On remonte l'arbre, on enleve une lettre de la racine commune
  74 + cpt --;
  75 + debut_mot[cpt] = '\0';
  76 +
  77 +
  78 + //Si lettre dans arbre Brother -> nouveau mot -> Retour à la ligne (changement de mot)
  79 + if(arbre->suivant != NULL){
  80 +
  81 + //On imprime alors la racine commune
  82 + printf("%s", debut_mot);
  83 + }
  84 +
  85 + //On print
  86 + print_tout(arbre->suivant, cpt, debut_mot);
  87 +}
42 88  
43 89 void init_dico(ptarbre* parbre, char lettre)
44 90 {
45 91 (*parbre)=malloc(sizeof(cell));
46 92 (*parbre)->fils=malloc(sizeof(cell));
  93 + (*parbre)->fils->lettre= '\0'; // Permet de savoir qu'il n'y a pas de lettre dans l'étage en dessous pour différencier s'il faut utiliser ajout tete ou ajout dico
47 94 (*parbre)->suivant=NULL;
48 95 (*parbre)->lettre=lettre;
49 96 (*parbre)->fin_mot=false;
... ... @@ -67,8 +114,8 @@ void ajout_dico(ptarbre *parbre, ptarbre *parbresuiv, char lettre)
67 114 (*parbresuiv)->fils->suivant=NULL;
68 115 (*parbresuiv)->suivant=NULL;
69 116 (*parbresuiv)->fin_mot=false;
70   - (*parbre)->lettre=lettre;
71   - printf("ajout lettre : %c à %p \n",(*parbre)->lettre, parbre);
  117 + (*parbresuiv)->lettre=lettre;
  118 + printf("ajout lettre : %c à %p \n",(*parbresuiv)->lettre, parbresuiv);
72 119 }
73 120  
74 121 void affiche_dico(ptarbre arbre, int n_lettre, char mot[])
... ... @@ -82,18 +129,21 @@ void affiche_dico(ptarbre arbre, int n_lettre, char mot[])
82 129 {
83 130 if (arbre->fils != NULL)
84 131 {
85   - printf("%c",arbre->lettre);
86 132 mot[n_lettre]=arbre->lettre;
87 133 n_lettre++;
88   - affiche_dico(arbre->fils,n_lettre,mot);
89 134 }
90   - printf("\n");
  135 +
  136 + printf("%c",arbre->lettre);
  137 + affiche_dico(arbre->fils,n_lettre,mot);
  138 + if (arbre->fin_mot)
  139 + printf("\n");
91 140 if (arbre->suivant != NULL)
92 141 {
93   - printf("%s",mot);
94   - affiche_dico(arbre->suivant, n_lettre, mot);
  142 + printf("%s",mot);
  143 + // mot[n_lettre]=arbre->lettre;
95 144 }
96   - mot[n_lettre]=0;
  145 + affiche_dico(arbre->suivant, n_lettre, mot);
  146 + mot[n_lettre]='\0';
97 147 n_lettre--;
98 148  
99 149 }
... ... @@ -114,6 +164,18 @@ void free_tree(cell **ptr_tree)
114 164 }
115 165 }
116 166  
  167 +void print_suiv(ptarbre arbre)
  168 +{
  169 + if (arbre!=NULL)
  170 + {
  171 + while(arbre->suivant!=NULL)
  172 + {printf("-%c_", arbre->lettre);
  173 + arbre=arbre->suivant;
  174 + }
  175 + }
  176 + printf("\n");
  177 +}
  178 +
117 179 void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec, FILE* fp)
118 180 {
119 181  
... ... @@ -136,6 +198,7 @@ void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec,
136 198 {
137 199 printf("arbre null\n");
138 200 init_dico(parbre,c);
  201 + (*parbre_prec)=(*parbre);
139 202 (*parbre)=(*parbre)->fils;
140 203 }
141 204  
... ... @@ -147,14 +210,15 @@ void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec,
147 210 if (rec->lettre!=c)
148 211 {
149 212  
150   - if (rec==(*parbre)) // 1ere lettre de la liste
  213 + if (rec==(*parbre) && rec->lettre=='\0') // 1ere lettre de la liste
151 214 {
152 215 printf("1ere lettre\n");
153 216 ajout_dico_tete(parbre,c);
  217 + (*parbre_prec)=(*parbre);
154 218 (*parbre)=(*parbre)->fils;
155 219 }
156 220  
157   - if (rec->suivant==NULL)
  221 + else if (rec->suivant==NULL && rec->lettre!='\0')
158 222 {
159 223  
160 224 printf("rech suiv = NUll \n");
... ... @@ -169,7 +233,7 @@ void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec,
169 233 else
170 234 {// Cas où le début du mot existe déjà et qu'on le complète
171 235 //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);
  236 + printf("lettre trouvee %c\n", rec->lettre);
173 237 (*parbre_prec)=(*parbre);
174 238 (*parbre)=rec->fils; // On va à l'étage d'après pour former le mot dans l'arbre
175 239 //
... ... @@ -182,11 +246,12 @@ void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec,
182 246 printf("c==n \n");
183 247 if ((*parbre_originel)!=NULL)
184 248 {
185   - printf("%c \n", (*parbre_prec)->lettre);
  249 + printf("adr arbre prec %p et lettre %c \n", (*parbre_prec),(*parbre_prec)->lettre);
186 250 (*parbre_prec)->fin_mot=true; // Cette lettre est la dernière du mot
187 251 }
188 252 // affiche_dico((*parbre_originel),n_lettre,mot);
189 253 printf("remise à 0\n");
  254 + print_suiv((*parbre));
190 255 printf("avant egal arbre %p arbre ori %p \n", (*parbre), (*parbre_originel));
191 256 (*parbre)=(*parbre_originel); // On revient en haut de l'arbre pour commencer un nouveau mot
192 257 printf("apres egal arbre %p arbre ori %p \n", (*parbre), (*parbre_originel));
... ... @@ -197,11 +262,10 @@ void cons_arbre(ptarbre *parbre_originel, ptarbre *parbre, ptarbre *parbre_prec,
197 262  
198 263 int main()
199 264 {
200   - char mot[30];
  265 + char mot[30]="";
201 266 int n_lettre=0;
202 267 ptarbre arbre_originel,arbre,arbre_prec;
203 268 arbre_originel=NULL;
204   - printf("adr arbre _ori %p\n", &arbre_originel);
205 269 arbre=NULL;
206 270 // Ouvrir fichier
207 271 FILE *fp = fopen("words1.txt","r");
... ... @@ -210,85 +274,10 @@ int main()
210 274 else
211 275 printf("words1 accessible \n",fp);
212 276 cons_arbre(&arbre_originel, &arbre, &arbre_prec,fp);
213   - /* while (fscanf(fp,"%c",&c)!= EOF) // lecture de tout le fichier
214   - {
215   - if (c != '\n')
216   - {
217   - if (arbre_originel==NULL) // Cas où c'est le premier mot premiere lettre
218   - {
219   - printf("arbre =NULL \n");
220   - init_dico(&arbre_originel,c);
221   - printf("lettre arbre :%c \n",arbre_originel->lettre);
222   - arbre_prec=arbre_originel;
223   - arbre=arbre_originel->fils;
224   - }
225   - else if (arbre==NULL) // premier mot de l'arbre
226   - {
227   - init_dico(&arbre,c);
228   - arbre=arbre->fils;
229   - }
230   -
231   - else // Cas où le dico n'est pas vide
232   - {
233   - // printf("lettre arbre :%c \n",arbre->lettre);
234   - printf(" c: %c\n", c);
235   - rec=rech(arbre,c);
236   - if (rec->lettre!=c)
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   - {
248   -
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   - }
256   - }
257   -
258   - else
259   - {// Cas où le début du mot existe déjà et qu'on le complète
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);
262   - arbre_prec=arbre;
263   - arbre=rec->fils; // On va à l'étage d'après pour former le mot dans l'arbre
264   - //
265   - }
266   -
267   -
268   - }
269   - }
270   - else {
271   - printf("c=='\ n' \n");
272   - if (arbre_originel!=NULL)
273   - {
274   - printf("%c \n", arbre_prec->lettre);
275   - arbre_prec->fin_mot=true; // Cette lettre est la dernière du mot
276   - }
277   -
278   - affiche_dico(arbre_originel,n_lettre,mot);
279   - printf("remise à 0\n");
280   - printf("avant egal arbre %p arbre ori %p \n", arbre, arbre_originel);
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);
283   - }
284   - //arbre=arbre_originel;
285   - }
286   - */
287   - // printf("arbre originel lettre %c \n", arbre_originel->fils->lettre);
288   - affiche_dico(arbre_originel,n_lettre,mot);
  277 + //affiche_dico(arbre_originel,n_lettre,mot);
  278 + print_tout(arbre_originel,n_lettre, mot);
289 279 free_tree(&arbre);
290 280 fclose(fp);
291 281  
292   -
293 282 return 0;
294 283 }
... ...