Commit 04b8ce9413659e8801a705e286ccdba433e5689d
1 parent
fb82dc55
Modification de la strcutre, ajout d'un bool pour savoir si l'enchainement des l…
…ettres correspond à un mot valide, ajout fonction affichage
Showing
9 changed files
with
192 additions
and
28 deletions
Show diff stats
No preview for this file type
No preview for this file type
1 | 1 | #include <stdio.h> |
2 | 2 | #include <stdlib.h> |
3 | +#include <stdbool.h> | |
3 | 4 | |
4 | 5 | |
5 | 6 | typedef struct cell* ptarbre; |
... | ... | @@ -7,8 +8,9 @@ typedef struct cell* ptcellule; |
7 | 8 | |
8 | 9 | typedef struct cell { |
9 | 10 | char lettre; |
10 | - ptarbre arbre; // Descend d'un étage dans le mot (lettre suivante du mot) | |
11 | + ptarbre fils; // Descend d'un étage dans le mot (lettre suivante du mot) | |
11 | 12 | ptcellule suivant; // Lettre suivante stockée à l'étage arbre en (ieme position) |
13 | + bool fin_mot; | |
12 | 14 | } cell; |
13 | 15 | |
14 | 16 | /* Pas utile |
... | ... | @@ -20,21 +22,27 @@ void init_dico() |
20 | 22 | */ |
21 | 23 | ptarbre rech(ptarbre arbre, char lettre) |
22 | 24 | // recherche une lettre en ième position (correspondant à arbre) |
23 | -// Retourne l'adresse de l'abre contenant la lettre à cette position | |
25 | +// Retourne l'adresse de l'arbre contenant la lettre à cette position | |
24 | 26 | { |
25 | - while((arbre!=NULL) && (arbre->lettre != lettre)) | |
27 | + if (arbre!=NULL) | |
26 | 28 | { |
27 | - printf("lettre : %c lettre cherchee : %c\n", (arbre->lettre),lettre); | |
28 | - arbre=arbre->suivant; | |
29 | + printf("arbre lettre %c \n", arbre->lettre); | |
30 | + while ((arbre->suivant!=NULL) && (arbre->lettre != lettre)) | |
31 | + { | |
32 | + printf("lettre : %c lettre cherchee : %c adr arbre %p \n", arbre->lettre,lettre, arbre); | |
33 | + arbre=(arbre->suivant); | |
34 | + } | |
29 | 35 | } |
30 | 36 | return arbre; |
31 | 37 | } |
32 | 38 | void init_dico(ptarbre *parbre, char lettre) |
33 | 39 | { |
34 | 40 | (*parbre)=malloc(sizeof(cell)); |
35 | - (*parbre)->arbre=malloc(sizeof(cell)); | |
41 | + (*parbre)->fils=malloc(sizeof(cell)); | |
42 | + (*parbre)->fils->suivant=NULL; | |
36 | 43 | (*parbre)->suivant=NULL; |
37 | 44 | (*parbre)->lettre=lettre; |
45 | + (*parbre)->fin_mot=false; | |
38 | 46 | printf("init dico\n"); |
39 | 47 | } |
40 | 48 | |
... | ... | @@ -42,23 +50,57 @@ void ajout_dico(ptarbre *parbre, ptarbre *parbresuiv, char lettre) |
42 | 50 | { |
43 | 51 | *parbresuiv=malloc(sizeof(cell)); |
44 | 52 | (*parbre)->suivant=*parbresuiv; // On relie la nouvelle lettre à l'avant dernière lettre |
45 | - (*parbresuiv)->arbre=malloc(sizeof(cell)); | |
53 | + (*parbresuiv)->fils=malloc(sizeof(cell)); | |
54 | + (*parbresuiv)->fils->suivant=NULL; | |
46 | 55 | (*parbresuiv)->suivant=NULL; |
56 | + (*parbresuiv)->fin_mot=false; | |
47 | 57 | (*parbresuiv)->lettre=lettre; |
48 | - printf("ajout lettre : %c \n",(*parbresuiv)->lettre); | |
58 | + printf("ajout lettre : %c à %p \n",(*parbresuiv)->lettre, parbresuiv); | |
49 | 59 | } |
50 | 60 | |
51 | 61 | void affiche_dico(ptarbre arbre) |
52 | 62 | // affiche tout le dictionnaire à partir de l'arbre (donc le numéro de lettre) sélectionné |
53 | 63 | { |
54 | - | |
64 | + if(arbre == NULL) | |
65 | + { | |
66 | + return; | |
67 | + } | |
68 | + else | |
69 | + { | |
70 | + if (arbre->fils!=NULL) | |
71 | + { | |
72 | + printf("%c\n", (arbre->lettre)); | |
73 | + while(arbre->suivant !=NULL) | |
74 | + { | |
75 | + printf("%c\n", (arbre->lettre)); | |
76 | + affiche_dico(arbre->fils); | |
77 | + arbre=arbre->suivant; | |
78 | + } | |
79 | + } | |
80 | + } | |
81 | + | |
55 | 82 | } |
56 | - | |
83 | + | |
84 | +void free_tree(cell **ptr_tree) | |
85 | +{ | |
86 | + if ((*ptr_tree)==NULL) | |
87 | + printf("L'arbre est vide\n"); | |
88 | + else | |
89 | + { | |
90 | + if ((*ptr_tree)->fils!=NULL) | |
91 | + free_tree(&((*ptr_tree)->fils)); | |
92 | + if ((*ptr_tree)->suivant!=NULL) | |
93 | + free_tree(&(*ptr_tree)->suivant); | |
94 | + free(*ptr_tree); | |
95 | + } | |
96 | +} | |
97 | + | |
57 | 98 | |
58 | 99 | int main() |
59 | 100 | { |
60 | - ptarbre arbre_originel,arbre; | |
101 | + ptarbre arbre_originel,arbre,arbre_prec; | |
61 | 102 | arbre_originel=NULL; |
103 | + arbre=NULL; | |
62 | 104 | char c,t; |
63 | 105 | ptarbre rec; |
64 | 106 | // Ouvrir fichier |
... | ... | @@ -70,50 +112,62 @@ int main() |
70 | 112 | |
71 | 113 | while (fscanf(fp,"%c",&c)!= EOF) // lecture de tout le fichier |
72 | 114 | { |
73 | - // while (fscanf(fp,"%d",&c)!='\n') // Tant que le mot n'est pas fini, on ajoute les lettres à la suite | |
74 | - // { | |
75 | 115 | if (c != '\n') |
76 | 116 | { |
77 | 117 | if (arbre_originel==NULL) // Cas où c'est le premier mot |
78 | 118 | { |
79 | 119 | printf("arbre =NULL \n"); |
80 | 120 | init_dico(&arbre_originel,c); |
81 | - | |
82 | - arbre=arbre_originel->arbre; | |
121 | + printf("lettre arbre :%c \n",arbre_originel->lettre); | |
122 | + arbre_prec=arbre_originel; | |
123 | + arbre=arbre_originel->fils; | |
83 | 124 | } |
84 | 125 | |
85 | 126 | else // Cas où le dico n'est pas vide |
86 | 127 | { |
128 | + printf("lettre arbre :%c \n",arbre->lettre); | |
87 | 129 | printf(" c: %c\n", c); |
88 | 130 | rec=rech(arbre,c); |
89 | - printf("adr rech %p\n",rech(arbre,c)); | |
90 | - | |
91 | - if (rec==NULL) | |
131 | + | |
132 | + if (rec->suivant==NULL && rec->lettre!=c) | |
92 | 133 | { |
93 | - printf("rech = NUll \n"); | |
134 | + | |
135 | + printf("rech suiv = NUll \n"); | |
94 | 136 | ajout_dico(&(arbre),&(rec),c); |
95 | - arbre=rec->arbre; | |
137 | + // printf("ajout de : %c à %p et fils :%p\n", rec->lettre, rec, rec->fils); | |
138 | + arbre_prec=arbre; | |
139 | + arbre=rec->fils; | |
96 | 140 | } |
97 | 141 | |
98 | 142 | |
99 | 143 | else |
100 | 144 | {// Cas où le début du mot existe déjà et qu'on le complète |
101 | - printf("rech pas null\n"); | |
102 | - arbre=rec->arbre; // On va à l'étage d'après pour former le mot dans l'arbre | |
103 | - // affiche_dico(arbre); | |
145 | + printf("rech suiv pas null rec lettre %c\n", rec->lettre); | |
146 | + arbre_prec=arbre; | |
147 | + arbre=rec->fils; // On va à l'étage d'après pour former le mot dans l'arbre | |
148 | + // | |
104 | 149 | } |
105 | 150 | |
106 | - // printf("lettre %c \n",arbre->lettre); | |
151 | + | |
107 | 152 | } |
108 | 153 | } |
109 | 154 | else { |
155 | + printf("else\n"); | |
156 | + if (arbre_originel!=NULL) | |
157 | + { | |
158 | + printf("%c \n", arbre_prec->lettre); | |
159 | + arbre_prec->fin_mot=true; // Cette lettre est la dernière du mot | |
160 | + } | |
161 | + | |
162 | + affiche_dico(arbre_originel); | |
110 | 163 | printf("remise à 0\n"); |
111 | - arbre=arbre_originel; | |
164 | + arbre=arbre_originel; // On revient en haut de l'arbre pour commencer un nouveau mot | |
112 | 165 | } |
113 | - //arbre=arbre_originel; // On revient en haut de l'arbre pour commencer un nouveau mot | |
166 | + //arbre=arbre_originel; | |
114 | 167 | } |
115 | - | |
116 | - | |
168 | + printf("arbre originel lettre %c \n", arbre_originel->fils->lettre); | |
169 | + affiche_dico(arbre_originel); | |
170 | + free_tree(&arbre); | |
117 | 171 | fclose(fp); |
118 | 172 | |
119 | 173 | ... | ... |
... | ... | @@ -0,0 +1,95 @@ |
1 | +#include <stdio.h> | |
2 | +#include <stdlib.h> | |
3 | + | |
4 | + | |
5 | +typedef struct cell* ptarbre; | |
6 | +typedef struct cell* ptcellule; | |
7 | + | |
8 | +typedef struct cell { | |
9 | + int lettre; | |
10 | + ptarbre arbre; // Descend d'un étage dans le mot (lettre suivante du mot) | |
11 | + ptcellule suivant; // Lettre suivante stockée à l'étage arbre en (ieme position) | |
12 | +} cell; | |
13 | + | |
14 | +/* Pas utile | |
15 | +void init_dico() | |
16 | +{ | |
17 | + ptarbre arbre; | |
18 | + arbre=NULL; | |
19 | +} | |
20 | +*/ | |
21 | +ptarbre rech(ptarbre arbre, int lettre) | |
22 | +// recherche une lettre en ième position (correspondant à arbre) | |
23 | +// Retourne l'adresse de l'abre contenant la lettre à cette position | |
24 | +{ | |
25 | + while((arbre!=NULL) && (arbre->lettre != lettre)) | |
26 | + arbre=arbre->suivant; | |
27 | + return arbre; | |
28 | +} | |
29 | +void ajout_dico(ptarbre arbre, int lettre) | |
30 | +{ | |
31 | + arbre=malloc(sizeof(cell)); | |
32 | + arbre->lettre=lettre; | |
33 | + arbre->arbre=NULL; | |
34 | + arbre->suivant=NULL; | |
35 | +} | |
36 | + | |
37 | +void affiche_dico(ptarbre arbre) | |
38 | +// affiche tout le dictionnaire à partir de l'arbre (donc le numéro de lettre) sélectionné | |
39 | +{ | |
40 | + | |
41 | +} | |
42 | + | |
43 | + | |
44 | +int main() | |
45 | +{ | |
46 | + ptarbre arbre_originel,arbre; | |
47 | + arbre_originel=NULL; | |
48 | + arbre_originel=malloc(sizeof(cell)); | |
49 | + arbre=malloc(sizeof(cell)); | |
50 | + arbre->lettre = 0; | |
51 | + arbre->suivant = NULL; | |
52 | + arbre->arbre = NULL; | |
53 | + //arbre=arbre_originel; | |
54 | + char c; | |
55 | + // Ouvrir fichier | |
56 | + FILE *fp = fopen("words1","r"); | |
57 | + if (fp==NULL) | |
58 | + printf("words1 inaccessible ",fp); | |
59 | + else | |
60 | + printf("words1 accessible n",fp); | |
61 | + | |
62 | + while (fscanf(fp,"%d",&c)!= EOF) // lecture de tout le fichier | |
63 | + { | |
64 | + // while (fscanf(fp,"%d",&c)!='\n') // Tant que le mot n'est pas fini, on ajoute les lettres à la suite | |
65 | + // { | |
66 | + if (c != '\n') { | |
67 | + printf("%d\n", c); | |
68 | + if (rech(arbre,c)==NULL) // Cas où c'est un nouveau mot | |
69 | + { | |
70 | + ajout_dico(arbre,c); | |
71 | + } | |
72 | + else | |
73 | + { | |
74 | + while (rech(arbre,c)!=NULL) // Cas où le début du mot existe déjà et qu'on le complète | |
75 | + { | |
76 | + | |
77 | + arbre=rech(arbre,c)->arbre; // On va à l'étage d'après pour former le mot dans l'arbre | |
78 | + // affiche_dico(arbre); | |
79 | + } | |
80 | + // ajout_dico(arbre,c); | |
81 | + // printf("%c",arbre->lettre); | |
82 | + } | |
83 | + } | |
84 | + else { | |
85 | + arbre=arbre_originel; | |
86 | + } | |
87 | + //arbre=arbre_originel; // On revient en haut de l'arbre pour commencer un nouveau mot | |
88 | + } | |
89 | + | |
90 | + | |
91 | + fclose(fp); | |
92 | + | |
93 | + | |
94 | + return 0; | |
95 | +} | ... | ... |
No preview for this file type