Discussion :

[étoile de mer]

Bonjour àtous
jai un probleme avec cette fonction qui doit supprimer le 1er element de la table de hacahge.
elle nefonctionne pas: affiche des erreurs :
1--[Warning] passing arg 2 of `verifCondition2seq' from incompatible pointer type if( verifCondition2seq(TableHash[i]->mot, seq->mot )==1)
2- invalid initializer Liste tmp = TableHash;

3- invalid type argument of `->' TableHash = tmp->suivant;
4-incompatible type for argument 1 of `free' free(tmp);

je copte sur vous.
merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void elaguer (Liste *seq, Liste **TableHash ) {     
 Liste *tmp;   
  while( seq != NULL && verif_condition_2seq(TableHash->mot, seq->mot ){      
Liste tmp = TableHash;  
TableHash = tmp->suivant;    
  free(tmp);   
   printf (" bon"); 
}

[Médinoc]

On ne connait pas le prototype de verifCondition1seq
Tu as deux variables nommées tmp, et aucune n'est de type Liste** (le type de TableHash)
Je ne connais pas le type de Liste::suivant, mais ce n'est certainement pas Liste**...

[KindPlayer]

De un tu devrais mettre le detail de tes structures pour y voir plus clair.
Pour ce qui est du code, quand tu ecris TableHash= tmp->suivant ca ne va pas car TableHash est passé comme pointeur de pointeur et tmp->suivant est un simple pointeur. Donc tu dois le déréférencer. Idem quand tu écris: Liste tmp = TableHash. Ecris plutot Liste tmp= *TableHash.
Ensuite tu liberes tmp mais tu ne l'as pas alloué

[Lucien63]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Liste **TableHash;
/...
Liste tmp = TableHash;

Y a pas comme un problème ici ???!!!????

[étoile de mer]

De un tu devrais mettre le detail de tes structures pour y voir plus clair.
Pour ce qui est du code, quand tu ecris TableHash= tmp->suivant ca ne va pas car TableHash est passé comme pointeur de pointeur et tmp->suivant est un simple pointeur. Donc tu dois le déréférencer. Idem quand tu écris: Liste tmp = TableHash. Ecris plutot Liste tmp= *TableHash.
Ensuite tu liberes tmp mais tu ne l'as pas alloué

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
int verifCondition2seq(char *mot, Liste *seq)
{
    if(seq==NULL)
    return 0;
    Liste *tmp = seq;
 
      while(tmp != NULL)
    {
              if(chercher_mot(tmp->mot, mot))
               printf ("ok");
              return 1;
 
              tmp=tmp->suivant;
     }  
     return 0;
}  
 
(Liste *seq, Liste **TableHash )
{
     int i;
     for(i=0;i<TAILLEHASH;++i)
    if(TableHash[i] != NULL){
     Liste *tmp;
     printf(TableHash[i]->mot);
    if( verifCondition2seq(TableHash[i]->mot, seq->mot )==1)
    {
     Liste *tmp = TableHash[i];
     TableHash[i] = tmp->suivant;
    free(tmp);
     printf (" bon");
} 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "table_hash.h"
#define TAILLEHASH 307
 
 
int main(void)
{
 
  // Declaration des variables 
 int a;
  FILE *F;              // Descripteur du fichier texte
  char mot[100];        // variable utilisée pour stocker le mot en cours de lecture
  int i;                // variable utilisée lors du parcours de la TableHash
  unsigned int cle,pt;  // variables pour stocker les cles du mot en cours et la clé du caractère '.'
  char *temp;		// variable pour stocker le mot en cours de lecture
  char c;               // ??
  Liste **TableHash;    // tableau de liste
  TableHash = (Liste **) malloc (TAILLEHASH * sizeof(Liste *)); // allocation en memoire du tableau
  for(i=0;i<TAILLEHASH;++i) //  Initialisation des
    TableHash[i] = NULL;    //  pointeurs contenus dans le tableau 
 
  pt=hash_cle(".");     // calcul de la cle equivalent à un point
 
  printf("debut du programme \n----------------------------------\n");  
  F=fopen("C:\\Documents and Settings\\siril\\Bureau\\posmot\\essai.txt","r");  // ouverture du fichier texte
  if(F!= NULL)      // si le fichier existe
  {
  	  while(fscanf(F,"%s",mot)==1)     // boucle de lecture du fichier
 	  {
		  temp = (char*)mot;       // recuperation du mot lu 
	          cle = hash_cle(temp);    // calcul de la cle equivalente
		  if ( (cle!=pt ) && (!ChercherMotDansTableHash(TableHash,temp))) // si le mot n'est pas un point et qu'il n'est pas deja stocke
		  	TableHash[cle] = InsertionEnTete(TableHash[cle],temp);    // on l'insere en debut du tableau
	  }
	  fclose(F );  // on ferme le descripteur de fichier
	  F=fopen("C:\\Documents and Settings\\siril\\Bureau\\posmot\\essai.txt","r");  // on rouvre le descripteur de fichier pour revenir au debut
	  PosLigne(F,TableHash); // recherche des coordonnées des diferents mots extraits
          fclose(F );  // on ferme le descripteur de fichier
 
	  //filtrage 
	  printf("\nla liste non filtree :\n----------------------------------\n");
	  AfficherTableHash(TableHash); // affichage de la table NON FILTREE
 
	  printf("\nla liste filtree (2 occurrences au moins) :\n----------------------------------\n");
	  FiltreListe(TableHash,2);	// filtrage de la table
	  AfficherTableHash(TableHash); // affichage de la table FILTREE
 
	  //géneration des 2seq
	  Liste *seq=NULL;
	  Generer2seq(TableHash, 2, &seq);
	  printf("\nla liste des 2seq :\n----------------------------------\n");
	  AfficherListe(seq);
	  //printf("Chercher mot : ");
	  //scanf("%s",mot);
	  //if(cle = ChercherMotDansTableHash(TableHash,mot))
	  //  printf("%s existant dans le conteneur %u\n",mot,hash_cle(mot));
	  //else
	  //  printf("%s inexistant dans la table de hash\n");
	  //scanf("%c",c);
 
	  // elagage des séquence
	//AfficherTableHash(TableHash);
 
//	elaguer2seq(seq, TableHash);
 
verifCondition2seq("monde", seq->mot);
 
for(i=0; i<TAILLEHASH; i++)
 elaguer (seq, TableHash );
 
	  //printf("%i", a);
  }
  //}
  else printf("Le fichier texte n'existe pas");
 system("pause");
 
  return 0;
 
}

Bonjour , voila le main, et les 2 fonction qui ont une relation avec mon probleme actuel,
moi je dispose d'une table de hachage chainée qui contient des mots et leurs coordonnée, et une liste chainnée qui contient les sequences des mots (ensembles de mots)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
typedef struct c{
	int pos;
	int nl;
	struct c *suivant;
}Coordonnees;
 
typedef struct L{
	char mot[50];
	Coordonnees *c;
	struct L *suivant;
}Liste;

Bon , pour le moment faut parcourir le hash table et la liste pour verifier que pour chaque mot dans le hach tables est inclus dans la liste (verif conditon), si le mot verif cette condition faut le supprimer du hach table.
voila.
moi je bloque dans cette fonction de suppresiion.*merci

[Médinoc]

C'est ta conception qui génère trop de confusion.
Pour une liste chaînée, tu te retrouves facilement dans la m**** si tu confonds liste et chaînon.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
typedef struct chCoord {
	int pos;
	int nl;
	struct chCoord *suivant;
} ChainonCoordonnees;
 
typedef struct lstCoord {
	ChainonCoordonnees *premier;
} ListeCoordonnees;
 
typedef struct chMot {
	char mot[50];
	ListeCoordonnees coords;
	struct chMot *suivant;
} ChainonMot;
 
typedef struct lstMot {
	ChainonMot *premier;
} ListeMot;
 
typedef struct tblhMot {
	ListeMot * tabListes;
	size_t taille;
} TableHachageMot;

Avec ce code, tu peux écrire assez facilement une fonction pour supprimer le mot de la liste. Et tu peux le faire encore plus facilement si tu fais une liste doublement chaînée au lieu d'une liste simplement chaînée.

[étoile de mer]

C'est ta conception qui génère trop de confusion.
Pour une liste chaînée, tu te retrouves facilement dans la m**** si tu confonds liste et chaînon.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
typedef struct chCoord {
	int pos;
	int nl;
	struct chCoord *suivant;
} ChainonCoordonnees;
 
typedef struct lstCoord {
	ChainonCoordonnees *premier;
} ListeCoordonnees;
 
typedef struct chMot {
	char mot[50];
 
 
	ListeCoordonnees coords;
	struct chMot *suivant;
} ChainonMot;
 
typedef struct lstMot {
	ChainonMot *premier;
} ListeMot;
 
typedef struct tblhMot {
	ListeMot * tabListes;
	size_t taille;
} TableHachageMot;

Avec ce code, tu peux écrire assez facilement une fonction pour supprimer le mot de la liste. Et tu peux le faire encore plus facilement si tu fais une liste doublement chaînée au lieu d'une liste simplement chaînée.

je vais poster mon probleme en detail

[étoile de mer]

1- parcourir le texte pour extraire les mots, ainsi que les informations de position respectives.(num-ligne, position)
2-ajouter les mots à la table de hachage.
3- filtrer les mots selon leur nombre d'aapprition
3-generer les 2-sequences fréquents.
4- appliquer à ces derniers la technique d'elagage (condition de super sequence en arriere)
condition de super sequence en arriere : si 2seq ont le meme dernier item et qui ont les memes infos de position et la meme support (frequence) alors on ellimine la plus petite ( exple : (ae) et (e) ont les meme info de position et le meme support alors (e) est ellimiuné)).

ben , normallement à ce stade on a les 2sequ frequents elagués.
5-faire la jointure des 2 séq avec les 2/seq pour avoir les 3séq
6-filtrage des 3-seq
7-appliquer à ces derniers la technique d'elagage
toujours faire ce trvail : jointure +filtrage+elagage jusquà arriver à un stade où on peut pas faire la jointure comme par exple ( abcd) et (acef).
là on stoppe et liste tous les listes fermes frequents.(apres filtrage et elagage).
ctout

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
 
#include "table_hash.h"
#define TAILLEHASH 307
 
 
int main(void)
{
 
  // Declaration des variables 
 int a;
  FILE *F;              // Descripteur du fichier texte
  char mot[100];        // variable utilisée pour stocker le mot en cours de lecture
  int i;                // variable utilisée lors du parcours de la TableHash
  unsigned int cle,pt;  // variables pour stocker les cles du mot en cours et la clé du caractère '.'
  char *temp;		// variable pour stocker le mot en cours de lecture
  char c;               // ??
  Liste **TableHash;    // tableau de liste
  TableHash = (Liste **) malloc (TAILLEHASH * sizeof(Liste *)); // allocation en memoire du tableau
  for(i=0;i<TAILLEHASH;++i) //  Initialisation des
    TableHash[i] = NULL;    //  pointeurs contenus dans le tableau 
 
  pt=hash_cle(".");     // calcul de la cle equivalent à un point
 
  printf("debut du programme \n----------------------------------\n");  
  F=fopen("C:\\Users\\text.txt","r");  // ouverture du fichier texte
  if(F!= NULL)      // si le fichier existe
  {
  	  while(fscanf(F,"%s",mot)==1)     // boucle de lecture du fichier
 	  {
		  temp = (char*)mot;       // recuperation du mot lu 
	          cle = hash_cle(temp);    // calcul de la cle equivalente
		  if ( (cle!=pt ) && (!ChercherMotDansTableHash(TableHash,temp))) // si le mot n'est pas un point et qu'il n'est pas deja stocke
		  	TableHash[cle] = InsertionEnTete(TableHash[cle],temp);    // on l'insere en debut du tableau
	  }
	  fclose(F );  // on ferme le descripteur de fichier
	  F=fopen("C:\\Users\\text.txt","r");  // on rouvre le descripteur de fichier pour revenir au debut
	  PosLigne(F,TableHash); // recherche des coordonnées des diferents mots extraits
          fclose(F );  // on ferme le descripteur de fichier
 
	  //filtrage 
	  printf("\nla liste non filtree :\n----------------------------------\n");
	  AfficherTableHash(TableHash); // affichage de la table NON FILTREE
 
	  printf("\nla liste filtree (2 occurrences au moins) :\n----------------------------------\n");
	  FiltreListe(TableHash,2);	// filtrage de la table
	  AfficherTableHash(TableHash); // affichage de la table FILTREE
 
	  //géneration des 2seq
	  Liste *seq=NULL;
	  Generer2seq(TableHash, 2, &seq);
	  printf("\nla liste des 2seq :\n----------------------------------\n");
	  AfficherListe(seq);
	  //printf("Chercher mot : ");
	  //scanf("%s",mot);
	  //if(cle = ChercherMotDansTableHash(TableHash,mot))
	  //  printf("%s existant dans le conteneur %u\n",mot,hash_cle(mot));
	  //else
	  //  printf("%s inexistant dans la table de hash\n");
	  //scanf("%c",c);
 
	  // elagage des séquence
	//AfficherTableHash(TableHash);
 
	elaguer2seq(seq, TableHash);
 
 
	  //printf("%i", a);
  }
  //}
  else printf("Le fichier texte n'existe pas");
 system("pause");
 
  return 0;
 
}
 
 
void ParcourirElementTableHash(Liste **TableHash,char *mot){
  int cle;
  Liste *p;
  cle = hash_cle(mot);
 
  for(p=TableHash[0];p!=NULL;p=p->suivant)
    if(strcmp(mot,p->mot) == 0){
      printf("%s : ",mot);
      AfficherCoordonnees(p->c);
    }
}
 
 
 
 
 
 
 
Liste *InsertionEnTete(Liste *L,char *mot){
  Liste *nouveau;
  nouveau = (Liste *) malloc (sizeof(Liste));
  strcpy(nouveau->mot,mot);
  nouveau->suivant = L;
  nouveau->c = NULL;
  return nouveau;
}
 
Coordonnees *InsertionEnTeteCoordonnee(Coordonnees *C,int nl ,int pos){
  Coordonnees *nouveau;
  nouveau = (Coordonnees *) malloc (sizeof(Coordonnees));
  nouveau->pos = pos;
  nouveau->nl = nl;
  nouveau->suivant = C;
  return nouveau;
}
 
void AfficherListe(Liste *L){
  Liste *p;
  for(p=L;p!=NULL;p=p->suivant){
    AfficheMot(p->mot);
 
    AfficherCoordonnees(p->c);
  }
}
 
void AfficherCoordonnees(Coordonnees *C){
  Coordonnees *p;
  for(p=C;p!=NULL;p=p->suivant)
	  printf(" (%d,%d) ",p->nl,p->pos);
  printf("\n");
}
 
void AfficheMot(char *mot){
     char *espace;
     espace =" ";
  printf("%s",mot );
  printf("%s",espace);
 
 
}
 
unsigned int hash_cle(char *mot){
  unsigned int val = 0;
  for(;*mot!='\0';++mot)
    val = *mot + 31 * val;
  return val % TAILLEHASH;
}
 
void AfficherTableHash(Liste **TableHash){
  int i;
  for(i=0;i<TAILLEHASH;++i)
    if(TableHash[i] != NULL){
      printf("Conteneur %d \n",i);
      AfficherListe(TableHash[i]);
      printf("----------------------------------\n");
    }
}
 
unsigned int ChercherMotDansTableHash(Liste **TableHash,char *mot){
 
  Liste *p;
  unsigned int cle;
 
  cle = hash_cle(mot);
  for(p=TableHash[cle];p!=NULL;p=p->suivant)
    if(strcmp(p->mot,mot)==0)
      return 1;
  return 0;
}
 
void FiltreListe(Liste **TableHash, int seuil)
{
  Liste *p ,*last;
  Coordonnees *c;
  int i,supp=0,nb=0;
  for(i=0;i<TAILLEHASH;++i)
    if(TableHash[i] != NULL){
     nb=0;
     last=TableHash[i];
     for(p=TableHash[i];p!=NULL;p=p->suivant){
      supp=0;
      nb++;
      for(c=p->c;c!=NULL;c=c->suivant)
	     supp++;
 
     if( supp <seuil){ // mot n'est pas frequent
       if (last==p) // cas du première mot
         {
            TableHash[i]=p->suivant;
            last=p->suivant;
         }
       else
          last->suivant=p->suivant;
       nb--;
    }else
   last=p;
   }
   if (nb==0)
      TableHash[i] = NULL;
  }
}
 
void Generer2seq(Liste **TableHash, int seuil, Liste **seq){
 
  Liste *p1, *p2, *ss,*t;
  Coordonnees *c1,*c2;
  int i,j,supp1=0,supp2=0,nb=0;
  char s1[50], s2[50],*t1,*t2;
  char *stmp1,*stmp2;
 
  ss=*seq;
  printf("\nconstruction des 2seq \n---------------\n");
  for(i=0;i<TAILLEHASH;++i)
    if(TableHash[i] != NULL)
     for(p1=TableHash[i];p1!=NULL;p1=p1->suivant)
         for(j=i;j<TAILLEHASH;++j)
             if(TableHash[j] != NULL){
                if (j==i)
                    t=p1;
                    else
                    t=TableHash[j];
                for(p2=t;p2!=NULL;p2=p2->suivant){
 
                       if (strcmp(p1->mot,p2->mot)!=0){   // si 2 mots differents trouvés
                        Liste *tmp1=NULL, *tmp2=NULL;
 
                        strcpy(s1,p1->mot);
                        strcpy(s2,p2->mot);
                        stmp1 = strcat(s1," ");
                        stmp2 = strcat(s2," ");
 
                        t1=strcat(stmp1,p2->mot);
                        t2=strcat(stmp2,p1->mot);
                        tmp1=InsertionEnTete(tmp1,stmp1);
                        tmp2=InsertionEnTete(tmp2,stmp2);
 
                        printf("creation TMP1 et TMP2 : %s ,%s\n",stmp1,stmp2);
                        supp1=0;supp2=0;
                        for(c1=p1->c;c1!=NULL;c1=c1->suivant)  // calcule de supp
                         for(c2=p2->c;c2!=NULL;c2=c2->suivant){
                           if (c1->nl == c2->nl){
                             if(c1->pos < c2->pos){
                                 tmp1->c=InsertionEnTeteCoordonnee(tmp1->c,c1->nl ,c2->pos);    
                                 supp1++;
                                 }
                             else{
                                 tmp2->c=InsertionEnTeteCoordonnee(tmp2->c,c1->nl ,c1->pos);
                                 supp2++;
                                 }
                             }
                         }   // fin calcul supp
                         if(supp1>=seuil){
                            //printf("%d ",supp1);
                            if (*seq==NULL)
                              *seq=tmp1;
                            else  
                              ss->suivant=tmp1;
                            ss=tmp1;
                          //printf("%s : OK1\n",tmp1->mot);
                         }
                         if(supp2>=seuil){
                            //printf("%d ",supp2);
                            if (*seq==NULL)
                              *seq=tmp2;
                            else  
                              ss->suivant=tmp2;
                            ss=tmp2;
                          //printf("%s : OK2\n",tmp2->mot);
                        }
                    } // fin de traitement des mot
                 //printf("fin");
                 }
             }
             printf("////fin calcule 2seq\n");
}
 
 int chercher_mot(const char *phrase,const char *mot){
    int last;
    const size_t size = strlen(mot);
    char *find = strstr(phrase,mot);
    char *p;
 
    while(find){
        // le mot a été trouvé, mais est ce le dernier mot ?
        if(strlen(find) == size) return 1;
        else{ // le mot est peut être en dernière position mais suivi de caractères autre que des mots (ponctuation...)
            last = 1; // 1 si mot est bien le dernier dans la séquence, 0 sinon
            for(p = &(find[size]);*p != '\0';++p){
                if (isalpha(*p)){ // on a trouvé un caractère alphanumérique derrière donc ça ne va pas
                    last = 0;
                    break;
                }
            }
            // le mot n'est pas suivi de caractère alphanumérique donc c'est bon
            if (last) return 1;
        }
        find = strstr(&(find[1]),mot);
    }
    return 0;
}
 
void elaguer2seq(Liste *L, Liste **TableHash)
{
  Liste *p;
  Liste *q;
  char *mot;
  int i=0;
  int a;
  Liste *maillon_temp; 
  Liste *last;
  printf(" seq : %s\n",L->mot);
//printf("TableHash : %s\n",TableHash[1]->mot);
last=TableHash[i];
     for(p=TableHash[i];p!=NULL;p=p->suivant){
 //if(TableHash[i] != NULL)
   //printf("TableHash : %s\n",TableHash[i]->mot);
         if  (chercher_mot(TableHash[i]->mot,p->mot)==0)
         printf("%s","condition vérifiée");
          TableHash[i]=p->suivant;
            last=p->suivant;
 
 
//maillon_temp=TableHash[i]; 
//TableHash[i]=TableHash[i]->suivant ;
//free(maillon_temp); 
   // supprimerMot(p->mot);  
     AfficherTableHash(TableHash);
     //printf("TableHash : %s\n",TableHash[i]->mot);
}
 
 
//AfficherTableHash(TableHash);
 // for(p=L;p!=NULL;p=p->suivant){
   // AfficherTableHash(TableHash); 
   //   for(q=TableHash ;q!=NULL;q=q->suivant){   
   //      printf ("%s", "aaaaaaaaaaaaaaaaaaaaaaa");   
   //          printf ("%s", q->mot);
   //          
    //         }                    
  //}
}
 
 
 
 
void PosLigne(FILE *F,Liste **TableHash){
  char s[50];
  int nl,pos,i;
  Liste *p;
  nl=pos=1;
 
  while(fscanf(F,"%s",s)==1){
    for(i=0;i<TAILLEHASH;++i)
      if(TableHash[i]!=NULL)
        for(p=TableHash[i];p!=NULL;p=p->suivant)
          if(strcmp(p->mot,s)==0)
            p->c=InsertionEnTeteCoordonnee(p->c,nl ,pos);
    if(fgetc(F)=='\n'){
      ++nl;
      pos=0;
    }
    ++pos;
  }
  printf("\n");
}

merci

[KindPlayer]

Heu ou se situe le problème? Parce que je pense pas que quelqu'un va lire tout ton code qui ne semble pas trivial algorithmiquement. Tu as essayé de compiler?

[étoile de mer]

Heu ou se situe le problème? Parce que je pense pas que quelqu'un va lire tout ton code qui ne semble pas trivial algorithmiquement. Tu as essayé de compiler?

oui , bien sûr
mon probleme est dans cette fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void elaguer2seq(Liste *L, Liste **TableHash)
{
  Liste *p;
  Liste *q;
  char *mot;
  int i=0;
  int a;
  Liste *maillon_temp; 
  Liste *last;
  printf(" seq : %s\n",L->mot);
//printf("TableHash : %s\n",TableHash[1]->mot);
last=TableHash[i];
     for(p=TableHash[i];p!=NULL;p=p->suivant){
 //if(TableHash[i] != NULL)
   //printf("TableHash : %s\n",TableHash[i]->mot);
         if  (chercher_mot(TableHash[i]->mot,p->mot)==0)
         printf("%s","condition vérifiée");
          TableHash[i]=p->suivant;
            last=p->suivant;
 
 
//maillon_temp=TableHash[i]; 
//TableHash[i]=TableHash[i]->suivant ;
//free(maillon_temp); 
   // supprimerMot(p->mot);  
     AfficherTableHash(TableHash);
     //printf("TableHash : %s\n",TableHash[i]->mot);
}
 
 
//AfficherTableHash(TableHash);
 // for(p=L;p!=NULL;p=p->suivant){
   // AfficherTableHash(TableHash); 
   //   for(q=TableHash ;q!=NULL;q=q->suivant){   
   //      printf ("%s", "aaaaaaaaaaaaaaaaaaaaaaa");   
   //          printf ("%s", q->mot);
   //          
    //         }                    
  //}
}

elliminer le 1ere elemnt de la table de hachage,
bon je fais le parcours de la table de hachage, pour chaque element entete je teste par rapport à tous les element de la liste chainéeavec la fonction(verf condition), si c bon je supprime le 1er elemnt de la table ?
tu vois?


j'ai du mal à supprimer le 1ere element du hach table.

[Médinoc]

Je pense que tu dois faire attention, entre ton p=p->suivant et ta destruction de l'objet (qui est actuellement en commentaire).

[étoile de mer]

Je pense que tu dois faire attention, entre ton p=p->suivant et ta destruction de l'objet (qui est actuellement en commentaire).

le principe est juste?

[Médinoc]

J'ai du mal à voir, il y a trop de lignes en commentaire dont je ne sais que croire.
Mais je vois un problème, en tout cas:

• Si la condition n'est pas satisfaite, on passe au second mot
• Si le second mot satisfait la condition, c'est quand même le premier qu'on supprime.

[étoile de mer]

J'ai du mal à voir, il y a trop de lignes en commentaire dont je ne sais que croire.
Mais je vois un problème, en tout cas:

• Si la condition n'est pas satisfaite, on passe au second mot
• Si le second mot satisfait la condition, c'est quand même le premier qu'on supprime.

oui c ca
tu sais comment faire coté implémentation?
merci

[KindPlayer]

Jsuis pas sur de comprendre ce que tu veux faire, mais pour supprimer l'element en tete de ta table, ce que tu as mis en commentaire me semble bon, a part qu'il faut liberer "mot" avant de liberer le maillon.

[Médinoc]

Oui: Le plus simple, c'est de se balader avec un Liste** pour savoir quel pointeur on doit modifier quand on supprime un mot.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Liste** GetPtrPremier(Liste **ppListe)
{
	return ppListe;
}
 
Liste** GetPtrSuivant(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		return &(pMot->suivant);
	}
}
 
Liste * GetMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL)
		return NULL;
	return *ppMot;
}
 
Liste * DetacheMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		*ppMot = pMot->suivant;
		pMot->suivant = NULL;
		return pMot;
	}
}
 
int SupprimeMotPointePar(Liste **ppMot)
{
	Liste *pMot = DetacheMotPointePar(ppMot);
	if(pMot==NULL)
		return -1;
 
	supprimeMot(pMot);
	return 0;
}

Et comment on l'utilise dans ton parcours:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Liste **ppMot;
int bDejaAvance = 0;
for(ppMot = GetPtrPremier(&TableHash[i]) ; ppMot = (bDejaAvance ? ppMot : GetPtrSuivant(ppMot)), bDejaAvance=0 ; GetMotPointePar(ppMot)!=NULL)
{
	if( condition... )
	{
		/*blabla*/
		Liste *pMot = GetMotPointePar(ppMot);
		/*...*/
 
		/* On supprime le mot */
		SupprimeMotPointePar(ppMot);
		bDejaAvance = 1;
	}
}

L'entier nommé bDejaAvance est nécessaire, car si on supprime le mot, ppMot pointera alors sur le suivant: Il ne faut pas le sauter...

Edit: Correction sur cette ligne:
for(ppMot = GetPtrPremier(&TableHash[ i ]) ; ppMot = (bDejaAvance ? ppMot : GetPtrSuivant(ppMot)), bDejaAvance=0 ; GetMotPointePar(ppMot)!=NULL)

[étoile de mer]

Jsuis pas sur de comprendre ce que tu veux faire, mais pour supprimer l'element en tete de ta table, ce que tu as mis en commentaire me semble bon, a part qu'il faut liberer "mot" avant de liberer le maillon.

comme ca il n'elague pas il fait rien!!

[étoile de mer]

Oui: Le plus simple, c'est de se balader avec un Liste** pour savoir quel pointeur on doit modifier quand on supprime un mot.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Liste** GetPtrPremier(Liste **ppListe)
{
	return ppListe;
}
 
Liste** GetPtrSuivant(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		return &(pMot->suivant);
	}
}
 
Liste * GetMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL)
		return NULL;
	return *ppMot;
}
 
Liste * DetacheMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		*ppMot = pMot->suivant;
		pMot->suivant = NULL;
		return pMot;
	}
}
 
int SupprimeMotPointePar(Liste **ppMot)
{
	Liste *pMot = DetacheMotPointePar(ppMot);
	if(pMot==NULL)
		return -1;
 
	supprimeMot(pMot);
	return 0;
}

Et comment on l'utilise dans ton parcours:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Liste **ppMot;
int bDejaAvance = 0;
for(ppMot = GetPtrPremier(&TableHash[i]) ; ppMot = (bDejaAvance ? 0 : GetPtrSuivant(ppMot)), bDejaAvance=0 ; GetMotPointePar(ppMot)!=NULL)
{
	if( condition... )
	{
		/*blabla*/
		Liste *pMot = GetMotPointePar(ppMot);
		/*...*/
 
		/* On supprime le mot */
		SupprimeMotPointePar(ppMot);
		bDejaAvance = 1;
	}
}

L'entier nommé bDejaAvance est nécessaire, car si on supprime le mot, ppMot pointera alors sur le suivant: Il ne faut pas le sauter...

Merci Medinoc,
tu peux m'eclaircir, un peu plus ce que tu as fait en texto, svp
merci
PS: moi jai un une table de hachage qui a chaque fois elle prend en entre son 1erelemnt et va le comaprer avec les autres element de la liste.

[Médinoc]

PS: moi jai un une table de hachage qui a chaque fois elle prend en entre son 1erelemnt et va le comaprer avec les autres element de la liste.

Ben ça, c'est à mettre dans le code de la condition, non?

[étoile de mer]

Oui: Le plus simple, c'est de se balader avec un Liste** pour savoir quel pointeur on doit modifier quand on supprime un mot.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Liste** GetPtrPremier(Liste **ppListe)
{
	return ppListe;
}
 
Liste** GetPtrSuivant(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		return &(pMot->suivant);
	}
}
 
Liste * GetMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL)
		return NULL;
	return *ppMot;
}
 
Liste * DetacheMotPointePar(Liste **ppMot)
{
	if(ppMot==NULL || *ppMot==NULL)
		return NULL;
 
	{
		Liste *pMot = *ppMot;
		*ppMot = pMot->suivant;
		pMot->suivant = NULL;
		return pMot;
	}
}
 
int SupprimeMotPointePar(Liste **ppMot)
{
	Liste *pMot = DetacheMotPointePar(ppMot);
	if(pMot==NULL)
		return -1;
 
	supprimeMot(pMot);
	return 0;
}

Et comment on l'utilise dans ton parcours:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Liste **ppMot;
int bDejaAvance = 0;
for(ppMot = GetPtrPremier(&TableHash[i]) ; ppMot = (bDejaAvance ? 0 : GetPtrSuivant(ppMot)), bDejaAvance=0 ; GetMotPointePar(ppMot)!=NULL)
{
	if( condition... )
	{
		/*blabla*/
		Liste *pMot = GetMotPointePar(ppMot);
		/*...*/
 
		/* On supprime le mot */
		SupprimeMotPointePar(ppMot);
		bDejaAvance = 1;
	}
}

L'entier nommé bDejaAvance est nécessaire, car si on supprime le mot, ppMot pointera alors sur le suivant: Il ne faut pas le sauter...

on fait quoi dans cette fonction :supprimeMot(pMot);
for(ppMot = GetPtrPremier(&TableHash[i]) ; ppMot = (bDejaAvance ? 0 : GetPtrSuivant(ppMot)), bDejaAvance=0 ; GetMotPointePar(ppMot)!=NULL)

je comprends pas svp
merci