[C ]erreur de segmentation dans une fonction Fermé

Question

Bonjour,j"ai un probleme dans ma focntion :
l'idée de base c'est que j'ai une liste chainée seq2 et une autre seq , je vais parcourir les 2 tout en faisant la comparaison pour chaque element de la liste si le dernier mot =au 1er .
si c'est le cas je vais creer un nouvelle liste qui va contenir la concatenation des 2 mots (des 2 liste).
voila le code :
/* permettra d'utiliser partout la meme valeur:*/
#define C_TAILLE_MOT 50
typedef struct L
{
	int freq;
	char mot[C_TAILLE_MOT];
 
	struct L *suivant;
} Liste;
 
/* Prototypes des fonctions pour que ce soit plus clair */
/* Assymetrie dans les arguments pour montrer que le premier,
est const et on y touche pas alors que le second est le buffer temporaire
*/
char* GetFirstWord(const char* sentence, char* buffer);
char* GetLastWord(const char* sentence, char* buffer);
 
Liste * GenNseq(Liste *seq2, Liste *seq);
 
Liste * GenNseq(Liste *seq2, Liste *seq)
{
   Liste *p;
   Liste *q;
   char * mot;
   char * mot1;
   char *first;
   char *last;
   char buff1[C_TAILLE_MOT];/* pas besoin de malloc car 50 est une petite taille et ca s'ajuste avec Liste::mot */
   char buff2[C_TAILLE_MOT];/* deux buffer temporaire: un pour chaque liste!*/
   Liste *pNouvelleListe;/* pour creer la liste*/
   Liste *pCourant;
 
   pNouvelleListe=NULL;
   for(p=seq2; p!=NULL; p=p->suivant)
   {
      mot=p->mot;
      if(mot){
         first=GetFirstWord(mot, buff1);
         for(q=seq; q!=NULL; q=q->suivant)
         {
            mot1 =q->mot;
            if(mot1){
               last=GetLastWord(mot1, buff2);
               if(strncmp(first, last,C_TAILLE_MOT)==0)
               { 
                  printf("similaires!!!!");
                  pCourant = malloc(sizeof(Liste));
                  pCourant->freq = 1;
                  strncpy(pCourant->mot,first,C_TAILLE_MOT);
                  pCourant->suivant = pNouvelleListe;
                  pNouvelleListe = pCourant;
               }
            }
         }
      }
   }
 
   return pNouvelleListe;
}
 
char* GetFirstWord(const char* sentence, char* buffer)
{
  char* pch;
 
  strncpy(buffer, sentence,C_TAILLE_MOT);
 
  pch = strtok(buffer," ,.-");
  /* si (pch==NULL) ca veut dire que le premier mot est le total de sentence */
  return buffer;
}
 
char* GetLastWord(const char* sentence, char* buffer)
{
  char* res;
  char* pch;
 
  strncpy(buffer, sentence,C_TAILLE_MOT);
 
  res = NULL;
  pch = strtok(buffer," ,.-");
  while (pch != NULL)
  {
    res = pch;
    pch = strtok (NULL, " ,.-");
  }
 
  if (res == NULL)
  {/* C'est qu'on n'est pas rentre dans la boucle while -> donc le premier mot = l'ensemble de sentence */
    res = buffer;
  }
  return res;
}
 
merci à vous
j'attends vos reponses

beslae · Answer

Excuse moi stroumpf, je sais que c est dure d etre tout bleu, tout petit, et d'etre sur qu on sé bien exprimer alors que c est vraiment pas le KKAAAAA !
"
si le dernier mot =au 1er !!??!! le dernier mot de quel liste ? le premier mot de quel liste ? on concaténe quoi et quoi ?? !! ou est l erreur ?  quelle ligne ??

"

stroumpf · Answer

typedef struct L
{
	int freq;
	char mot[C_TAILLE_MOT];


	struct L *suivant;
} Liste;
j'ai 2 liste chainée seq et seq2, chacune 2 contient des phrases exemple
seq : bonjour le, le monde, ma famille
seq2: bonjour le, le monde, famille  ma
on parcourt les 2liste et pour chaque element on verifier si le dernier mot ==au 1er
ona ma famille et famille ma verifie bien la condition donc on mat "ma famille ma " dans une nouvelle liste chainee.
ben voila beslae
j'espere que je suis pas k***** comme ta dit!!

beslae · Answer

Je te rassure, ce n est toujours pas le KAAA ! sinon je vai essayer de m adapter un peu a ton mode de communication, je crois qu il faudra aussi que j envisage de m y mettre vu le nombre des stroumpf sur ce genre de forum !!

donc :
strncmp(first, last,C_TAILLE_MOT)==0
se traduit :
comparer si first et last sont les meme
strncomp("famille ma", "ma famille", 50) n est jamais 0 !!

ceci d'une part, d'une autre, je comprend pas tes  strtok(buffer," ,.-"); !!

stroumpf · Answer

merci beslae, les daux focntion getforstword et getlastword marchent nikel, donc l'erreur n'est pas là, l'erreu est dans GenNseq, une erreur d'allocation de memoire

beslae · Answer

et ca donne quoi gcc comme erreur exactement ?

stroumpf · Answer

erreur de segmentation^^

lami20j · Answer

Salut,

mets en commentaire ta fonction GenNseq

mets cette fonction dans ton codevoid Affiche_L(Liste *seq2, Liste *seq)
{
   Liste *p;
   Liste *q;
   for(p=seq2; p!=NULL; p=p->suivant)
      printf("%s
",p->mot);

   for(q=seq; q!=NULL; q=q->suivant)
      printf("%s
",q->mot);
}compile est exécute ensuite dit si tu se passe bien

stroumpf · Answer

seq2 est une liste chainée ainsi que seq est un tableau de liste chainé

lami20j · Answer

Re,

d'accord
donc en fait il s'agit des pointeurs de pointeurs, c'est pour ça que tu as une erreur de segmentation ici

Liste * GenNseq(Liste *seq2, Liste *seq);

je vais revoir ta fonction

stroumpf · Answer

Liste * GenNseq(Liste **seq2, Liste **seq)
{
   Liste *p;
   Liste *q;
   char * mot=(char*)malloc(60*sizeof(char));
   char * mot1= (char*)malloc(60*sizeof(char));
   char *last;
   char *first;
   char buff1[C_TAILLE_MOT];/* pas besoin de malloc car 50 est une petite taille et ca s'ajuste avec Liste::mot */
   char buff2[C_TAILLE_MOT];/* deux buffer temporaire: un pour chaque liste!*/
   Liste *pNouvelleListe;/* pour creer la liste*/
   Liste *pCourant;
//   mot =(char*)malloc(60*sizeof(char));
  //    mot1 =malloc(60*sizeof(char));


   pNouvelleListe=NULL;

   for(p=*seq2; p!=NULL; p=p->suivant)
   {
      mot=p->mot;

      printf("%s", mot);
      if(mot){
         first=GetFirstWord(mot, buff1);
         printf("%s", first);
         for(q=*seq; q!=NULL; q=q->suivant)
         {
            mot1 =q->mot;
            if(mot1){
               last=GetLastWord(mot1, buff2);
               printf("%s", last);
               if(strncmp(first, last,C_TAILLE_MOT)==0)
               {
                  printf("similaires!!!!");
                  pCourant = malloc(sizeof(Liste));
                  pCourant->freq = 1;
                  strncpy(pCourant->mot,first,C_TAILLE_MOT);
                  pCourant->suivant = pNouvelleListe;
                  pNouvelleListe = pCourant;
               }
            }
         }
      }
   }

free(mot);
free(mot1);
   return pNouvelleListe;
}

meme comme ca sa plante

lami20j · Answer

Re, 

tu veux arrêter d'afficher à chaque fois ton code

que sa plante on le sait depuis le début

donc soit claire

seq2 c'est quoi????
seq c'est quoi????

on ne mets pas les étoiles comme sur les gâteux 
il faut savoir avec exactitude le type que tu dois utiliser.

lami20j · Answer

Re,

non c'est une simple liste chainée
decidé c'est bon ^^

En ce cas le prototype de ta fonction doit être (si j'ai bien compris)

Liste * GenNseq(Liste *seq2, Liste **seq)

seq2 - liste chaînée
seq - table de hash

c'est bien ça?

stroumpf · Answer

oui, 
seq2 est une liste chainée qui contient les mots, et seq est un tableau de liste chaine qui va contenier des liste chainée .
voilà

lami20j · Answer

Et tu veux vérifier pour chaque mot de seq2 tout les mots de seq (les listes dans le tableau de listes) 
C'est ça?

stroumpf · Answer

oui je vais verifier pour chaque mot de seq et de seq 2
si le dernier mot de seq est egale au 1er de seq alors on cree une nouvelle liste qui cva contenier le mot resultat de la concatenation et on va mettre cette nouvelle liste dans seq[1](2eme case)

lami20j · Answer

Attends, tu mélanges tout.

si le dernier mot de seq est egale au 1er de seq 

tu voulais dire

si le dernier mot de chaque liste de seq égal au 1er de seq2

Tu as obtenu comment le seq (le tableau de liste)??
Il a combien des listes dans ton tableau??

Puisque en fait ton algorithme seraPour chaque mot de la liste seq2
  Cherche le first
    Pour chaque mot de chaque liste du tableau de liste seq
       Cherche last
         Si last égal first Alors
           Affiche "Similaire"
           Allouer NouveauElement
           NouveauElement->freq = 1
           copier(NouveauElement->mot,first)
           NouveauElement->suivant = pNouvelleListe
           pNouvelleListe = NouveauElement
        Fin Si
    Fin Pour
Fin Pour

stroumpf · Answer

chaque elemnt de la liste  seq 2 contient une suite de mot
"bonjour les "
la meme chose pour seq: en fait jai mis dans la 1ere case des seq la liste des 2 
apres je vais comparer pour chaque elemnt de seq2 si le 1er mot =dernier mot des seq[0]
"bonjour les " et" bonjour les"
on a les <>bonjour donc pas de concatenation
ainsi de suite
si on a parexemple: "bonjour les " et "les amis " donc on va creer une liste chaine qui va contenir 'bonjour les amis" et on va la mettre dans seq [1]
voila 
et ainsi de suite

lami20j · Answer

la meme chose pour seq:

Non, ce n'est pas la même chose.
Tu as dit que seq c'est un tableau de listes.

Lit mont algorithme

Chaque élément de seq c'est une liste

Donc tu ne peux pas dire 

chaque elemnt de la liste seq 2 contient une suite de mot
"bonjour les "
la meme chose pour seq: 

en revanche tu peux dire

chaque elemnt de la liste seq 2 contient une suite de mot
"bonjour les "
et chaque element du chaque liste du tableau seq
Ca ne m'intéresse pas ton histoire avec "bonjour les" ;-)

Ce que tu dois de décider c'est où on cherche
Si seq2 c'est juste une liste et seq un tableau alors l'algo que je t'ai donné doit être bon
Sinon, alors tu dois mieux expliquer ce que tu veux obtenir, et sans mélanger les choses

Tu vois seulement la partie finale (les mots) que tu dois comparer.

Mais ce qui nous intéresse pour l'instant ce n'est pas ça.
Où les chercher nous intéresse.

Donc comme je te l'ai déjà dit. Si tu cherches dans un tableau de liste, alors le mot sera chercher par la fonction, dans chaque liste (élément du tableau).

stroumpf · Answer

merci Lami, 
voila nos input; 
seq 2 qui va contenir des liste de portion de phrase(2mots)
et ona seq qui est un tableau vide 
on a rempli la 1ere case du tableau par la liste des seq2 (copier)
et puis on va tenter de remplir les autres case du tableau
pour rempli la case 2
on concatene les portions de pharse de seq 2 et  de seq[0] qui ont la meme 1er et dernier mot
on met le resultat dans la case suivante seq[1]
voilà

lami20j · Answer

Re,

quelque chose comme ça
Liste * GenNseq(Liste *seq2, Liste **seq)
{
   Liste *p;
   Liste *q;
   int i;
   char * mot;
   char * mot1;
   char *first;
   char *last;
   char buff1[C_TAILLE_MOT];/* pas besoin de malloc car 50 est une petite taille et ca s'ajuste avec Liste::mot */
   char buff2[C_TAILLE_MOT];/* deux buffer temporaire: un pour chaque liste!*/
   Liste *pNouvelleListe;/* pour creer la liste*/
   Liste *pCourant;

   pNouvelleListe=NULL;
   for(p=seq2; p!=NULL; p=p->suivant){
      mot=p->mot;
      if(mot){
         first=GetFirstWord(mot, buff1);
         for(i=0;i<20000;++i){ // pour chaque élément (liste) de seq
           for(q=seq[i]; q!=NULL; q=q->suivant){ // seq[i] - element(liste) de seq
             mot1 =q->mot;
             if(mot1){
               last=GetLastWord(mot1, buff2);
               if(strncmp(first, last,C_TAILLE_MOT)==0){
                 printf("similaires!!!!");
                 pCourant = malloc(sizeof(Liste));
                 pCourant->freq = 1;
                 strncpy(pCourant->mot,first,C_TAILLE_MOT);
                 pCourant->suivant = pNouvelleListe;
                 pNouvelleListe = pCourant;
               }
             }
           }
         }
      }
   }
   return pNouvelleListe;
}

stroumpf · Answer

ok

lami20j · Answer

Je n'ai pas dit 

GenNseq(seq[i], seq2);


maisGenNseq(seq, seq2);

lami20j · Answer

Affiche ta fonctionInsertionEnTete

lami20j · Answer

C'est quoi ça??

seq[0]=seq2;

Pourquoi tu fait pointer le 1er élément de ton tableau sur la liste seq2?

D'après ta fonction InsertionEnTete, seq[0] ....... contient des chaines donc si tu fait pointer seq[0] sur seq2 alors tu as perdu le 1ère chaîne (celle sur laquelle seq[0] pointais avant cette affectation bizarre)

lami20j · Answer

Je ne vois pas où et comment tu remplis ton tableau de listes **seq

lami20j · Answer

seq[0]=seq2;
simplement qu'on rempli un tableau 

tu remplis tout simplement le 1er élément du tableau avec le liste que tu veux comparer (pas très logique)
il te reste 19999 cases alloués mais non utilisés

stroumpf · Answer

au debut remplir  seulement la 1ere case qui va contenir la liste seq2
et puis on compare at on remple seq[1] et puis seq[2], ...

lami20j · Answer

au debut remplir seulement la 1ere case qui va contenir la liste seq2 
pourquoi faire la comparaison avec elle même.
je ne comprends pas du tout.


Comment ça remplir au fur à mesure?!

Remplis d'abord ton tableau et ensuite tu pourras faire tes comparaisons.

Ton algo n'est pas claire du tout.

stroumpf · Answer

seq2: ab, ac,ad,bc, bd seq[0]: ab, ac, ad, bc, bd on a ces 2 liste , on compare element par element , on trouve ab et bc(drniermot(seq)==premier mot(seq2))->donc on creer une nouvelle liste "abc" qu'on va la stocker dans seq[1] ab et bd (derniermot(seq)==premier mot(seq2))->donc on creer une nouvelle liste "abd" qu'on va la stocker dans seq[1] sachant que a, b,c,d sont des mots voila donc seq [1] va contenir la liste chaine : abc, abd là on s'arrete car drniermot(abc)<>"a" et"b" aussi (abd)<>"a" et "b"" voilà je pense que c'est clair avec ce mini exemple ^^

stroumpf · Answer

c'est pas de cete facon qu'on rempli un tableau par la liste seq2?
seq[0]=seq2;

lami20j · Answer

abc cest la phrase d'une seule cellule
on va mettre abc et abc (2cellule) dans la meme case,

je ne comprends pas
et n'oublie pas quand tu parles des cases en fait tu parles des listes (vu que une case c'est une liste)

et cncernant l'allocation dynamique je connais pas comment faire :(

Tu l'as déjà fait.
Voir la fonction InsertionEnTete qui à chaque nouveau élément alloue un nouveau espace

Voir aussi la fonction qui crée ta Table de Hash.
D'après toi, c'est quoi une table table de hash?

Je vais te dire.
C'est un tableau de listes chaînée dans ton cas, avec l'insertion en utilisant une fonction de hash
La seule différence entre ta table de listes et ta Table de hash, c'est que pour l'insertion tu n'utiliseras pas une fonction de hash, bref tu ne vas pas gérer les collisions.

ca devient de plus en plus compliqué le projet:'(
Je le sais.
Mais le pire c'est que tu as éparpillé tes messages au lieu de rester sur un seul fil avec peut être des liens vers la suite.

Donc c'est seulement toi qui sait exactement l'évolution de ton projet ;-(

stroumpf · Answer

merci LAmi

stroumpf · Answer

comme ca on fait l'allocation dynamique du tableau ;
seq=(liste**)malloc(sizeof(liste*));
?

lami20j · Answer

Re,

si tu ne connais pas d'avance le nombre d'éléments du tableau alors tu es obligé de choisir une taille assez grande assez grande comme tu l'as déjà fait avec 20000seq=(liste**)malloc(20000 * sizeof(liste*)); 

mais il faut voir si tu as vraiment besoin de ça

pourquoi ne fait tu d'abord un algo et ensuite commencer écrire le code?
analyse bien ton problème :
- ce que tu as en entrée
- ce que tu veux obtenir

ça te permettra de choisir la structure de données mieux adapter pour tes besoins

Je ne parle qu'au mode général, vu que je ne connais pas l'évolution de ton projet ni ce que tu veux obtenir à la fin

lami20j · Answer

Re,

ça veut dire que le programme fonctionne?!
c'est déjà un pas en avant, vu qu'au début il plantais

stroumpf · Answer

oui, mais jai elliminet la boucle regarde #include #include #include #include /* permettra d'utiliser partout la meme valeur:*/ #define C_TAILLE_MOT 100 #define BUFFSIZE 64 #define FNAME "d:\out.txt" #define TAILLEHASH 300 #define C_TAILLE_MAX_PHRASE 100 #define Seuil 0.0000001 typedef struct L { int freq; char mot[C_TAILLE_MOT]; struct L *suivant; } Liste; /* Prototypes des fonctions pour que ce soit plus clair */ /* Assymetrie dans les arguments pour montrer que le premier, est const et on y touche pas alors que le second est le buffer temporaire */ char* GetFirstWord(const char* sentence, char* buffer); char* GetLastWord(const char* sentence, char* buffer); Liste * GenNseq(Liste *seq2, Liste **seq); char* get_word(FILE *fdesc, char *buff, size_t size) { char *ret=NULL; if( fdesc!=NULL && buff!=NULL && size>0 ) { int c; size_t i=0; while( ret==NULL && i0 ) { /* mot */ buff[i]='\0'; ret=buff; } } } return ret; } unsigned int hash_cle(const char * mot) { unsigned int val = 0; for(; *mot != '\0'; ++mot) { val = *mot + 31 * val; } return val % TAILLEHASH; } void insere_th(Liste **TableHash, const char *mot) { unsigned int idx = hash_cle(mot); Liste *p = TableHash[idx]; while(p != NULL) { if(strcmp(p->mot, mot) == 0) { /* le mot est trouve */ break; } p =p->suivant; } if(p == NULL) { /* le mot n'existe pas, insertion de celui ci */ p = (Liste *)malloc(sizeof(Liste)); if(p == NULL) { /* erreur d'allocation de memoire */ printf("Erreur d'allocation mémoire "); exit(0); } /* initialisation de la structure */ p->freq = 0; strncpy(p->mot, mot, sizeof(p->mot)); /* creation des coordonnees */ /* mise a jour des liens, insertion en debut de liste */ p->suivant = TableHash[idx]; TableHash[idx] = p; //return; } p->freq++; } void dump_table(Liste **TableHash) { int boucle; for( boucle = 0; boucle != TAILLEHASH; boucle++) { Liste *p = TableHash[boucle]; if(p != NULL) { printf("hash=%d ", boucle); while(p != NULL) { printf(" (%s : %d) ", p->mot, p->freq); p = p->suivant; } } } } int numligne (FILE *F) { int res=0; F = fopen (FNAME, "r"); if (F != NULL) { char buffer[BUFSIZ]; int nb_read; while ((nb_read = fread (buffer, 1, sizeof buffer, F)) > 0) { int i; for (i = 0; i < nb_read; i++) { if (buffer[i] == ' ') { res++; } } } fclose (F); // printf ("%i ", res); } else { perror (FNAME); } return res; } void clean_table(Liste **TableHash, int NombreLigne ) { int boucle; float suup; for( boucle = 0; boucle != TAILLEHASH; boucle++) { Liste *premier_valide = NULL; Liste *q = TableHash[boucle]; while(q != NULL) { suup = (float)(q->freq) / (float)(NombreLigne); if(suup < Seuil) { /* supprime l'element */ Liste *tmp = q->suivant; /* -mo- libere(q); n'est pas déclarée */ q = tmp; } else { if(premier_valide == NULL) { premier_valide = q; } q = q->suivant; } } TableHash[boucle] = premier_valide; } } Liste *InsertionEnTete(Liste *L, int freq, char *mot){ Liste *nouveau; nouveau = (Liste *) malloc (sizeof(Liste)); nouveau->freq = freq; strcpy(nouveau->mot,mot); nouveau->suivant = L; return nouveau; } void AfficherListe(Liste *L){ Liste *p; for(p=L;p!=NULL;p=p->suivant){ printf("%s ",p->mot); printf("%d : ",p->freq); } } char* GetFirstWord(const char* sentence, char* buffer) { { char* pch; strcpy(buffer, sentence); pch = strtok(buffer," ,.-"); if (pch == NULL) { buffer[0] = 0; pch = buffer; } return pch; } } char* GetLastWord(const char* sentence, char* buffer) { char* res; char* pch; strncpy(buffer, sentence,C_TAILLE_MOT); res = NULL; pch = strtok(buffer," ,.-"); while (pch != NULL) { res = pch; pch = strtok (NULL, " ,.-"); } if (res == NULL) {/* C'est qu'on n'est pas rentre dans la boucle while -> donc le premier mot = l'ensemble de sentence */ res = buffer; } return res; } Liste * GenNseq(Liste *seq2, Liste **seq) { Liste *p; Liste *q; int i; char * mot; char * mot1; char *first; char *last; char buff1[C_TAILLE_MOT];/* pas besoin de malloc car 50 est une petite taille et ca s'ajuste avec Liste::mot */ char buff2[C_TAILLE_MOT];/* deux buffer temporaire: un pour chaque liste!*/ Liste *pNouvelleListe;/* pour creer la liste*/ Liste *pCourant; pNouvelleListe=NULL; for(p=seq2; p!=NULL; p=p->suivant){ mot=p->mot; if(mot){ first=GetFirstWord(mot, buff1); //for(i=0;i<39;++i){ // pour chaque élément (liste) de seq for(q=seq; q!=NULL; q=q->suivant){ // seq[i] - element(liste) de seq mot1 =q->mot; if(mot1){ //printf("%s", mot1); last=GetLastWord(mot1, buff2); if(strncmp(first, last,C_TAILLE_MOT)==0){ //printf("similaires!!!!"); pCourant = malloc(sizeof(Liste)); pCourant->freq = 1; strncpy(pCourant->mot,first,C_TAILLE_MOT); pCourant->suivant = pNouvelleListe; pNouvelleListe = pCourant; } } } } } return pNouvelleListe; } //void Affiche_L(Liste **seq2, Liste **seq) //{ // Liste *p; // Liste *q; // for(p=*seq2; p!=NULL; p=p->suivant) // printf("%s ",p->mot); // // for(q=*seq; q!=NULL; q=q->suivant) // printf("%s ",q->mot); //} int main(void) { Liste **seq; Liste *seq2=NULL; int res; FILE *fdesc=fopen(FNAME,"r"); Liste *TableHash[TAILLEHASH]; Liste *p1; int i; int n=400000; for(i = 0; i < TAILLEHASH; ++i) { TableHash[i] = NULL; } if( fdesc ) { char buff[BUFFSIZE]; char prec[BUFFSIZE]; if( get_word(fdesc,prec,BUFFSIZE) ) { while( get_word(fdesc, buff, BUFFSIZE) ) { //printf("%s %s ",prec,buff); char s3[BUFFSIZE * 2]; sprintf(s3, "%s %s", prec, buff); puts(s3); strncpy( prec,buff,BUFFSIZE); insere_th(TableHash,s3); } } } dump_table(TableHash); res = numligne(fdesc); printf("%d ", res); //printf("aaaaaaaaaaaaaaaaaaaaaaaa"); clean_table(TableHash, res); printf("la liste filtrée "); dump_table(TableHash); seq =(Liste **) malloc ( n *sizeof(Liste *)); // les tableau des toutes les Nseq seq[0]=NULL; for(i=0;isuivant) { seq2=InsertionEnTete(seq2, p1->freq, p1->mot); } // // } } seq[0]=seq2; AfficherListe(seq[0]); printf ("fin d'affichage de la liste des 2 seq "); // for(i=0; i

lami20j · Answer

oui

mais jai elliminet la boucle 

donc tu devais commencer par dire que ton problème est résolu à ce niveau
donc c'était une histoire de déclaration de prototype de la fonction qui plantait au niveau de l'erreur de segmentation

lami20j · Answer

Ta fonction ne teste que le 1er élément du tableau.

lami20j · Answer

Ton appelle de fonction n'est pas correct

seq[i+1]=GenNseq( seq2, seq[0]);

regarde ton prototype de la fonctionListe * GenNseq(Liste *seq2, Liste **seq)donc le deuxième paramètre c'est un pointeur de pointeurs

Dans ton appelle le deuxième paramètre est un pointeur 

En plus i n'est pas initialisé.

Comme je te l'ai déjà dit dans ta fonction tu ne traite que le 1er terme du tableau

Même si tu fais une affectation à i+1 tu ne le  traite jamais dans la fonction.

écrit l'algo de la fonction pour voir

stroumpf · Answer

j'ai testé simplement avec cette instruction : seq[1]=GenNseq( seq2, seq[0]);
voila l'algo:

pour i de 0 à n faire    //parcourir le tableau
{
parcourir la liste de la case i
parcourir la liste de seq2
verifier pour chaque element de seq et pour chaque element de seq2
    si premier mot de seq2 == dernier mot de seq
   si sont egaux  alors 
      concatene (mot des seq avec premier mot de seq2 )=>C
      copier C dans une nouvelle liste chainne 
      mettre liste chainne dans seq[i+1]
finci
finsi
fin pour 
voila l'algo

lami20j · Answer

Je pense que tu n'as pas lu mon message précédent 

j'ai testé simplement avec cette instruction : seq[1]=GenNseq( seq2, seq[0]); 

ce n'est pas bon ça

stroumpf · Answer

comme ca alors : seq[1]=GenNseq( seq2, seq);?

lami20j · Answer

Si je prends ton algo en fait ça donne ça

Le 1er élément de seq pointe sur seq2

Pour chaque élément de seq2
   Pour chaque élément de seq (il n'y a que le 1er qui pointe sur quelque chose les autres 19999 point sur n'importe quoi)

    ...........................

Si jamais dans main tu fait
Pour i=0 jusqu'au 20000 en fait ta boucle dans la fonction se fera dans la manière suivante

La 1ère fois elle  passe une fois pour le 1er élément (et pour les autres 19999 ?!)

La 2ème fois elle passera 2 fois .............

La 3ème fois elle  passera 3 fois ..................


.............;


La 20000 elle passera 20000 fois .................

Je te laisse calculer combien des fois ta boucle s'exécutera

Ton algo n'es pas bon je pense

stroumpf · Answer

je pense pas: #include #include #include #include /* permettra d'utiliser partout la meme valeur:*/ #define C_TAILLE_MOT 100 #define BUFFSIZE 64 #define FNAME "d:\test.txt" #define TAILLEHASH 300 #define C_TAILLE_MAX_PHRASE 100 #define Seuil 0.0000001 typedef struct L { int freq; char mot[C_TAILLE_MOT]; struct L *suivant; } Liste; /* Prototypes des fonctions pour que ce soit plus clair */ /* Assymetrie dans les arguments pour montrer que le premier, est const et on y touche pas alors que le second est le buffer temporaire */ char* GetFirstWord(const char* sentence, char* buffer); char* GetLastWord(const char* sentence, char* buffer); Liste * GenNseq(Liste *seq2, Liste **seq); char* get_word(FILE *fdesc, char *buff, size_t size) { char *ret=NULL; if( fdesc!=NULL && buff!=NULL && size>0 ) { int c; size_t i=0; while( ret==NULL && i0 ) { /* mot */ buff[i]='\0'; ret=buff; } } } return ret; } unsigned int hash_cle(const char * mot) { unsigned int val = 0; for(; *mot != '\0'; ++mot) { val = *mot + 31 * val; } return val % TAILLEHASH; } void insere_th(Liste **TableHash, const char *mot) { unsigned int idx = hash_cle(mot); Liste *p = TableHash[idx]; while(p != NULL) { if(strcmp(p->mot, mot) == 0) { /* le mot est trouve */ break; } p =p->suivant; } if(p == NULL) { /* le mot n'existe pas, insertion de celui ci */ p = (Liste *)malloc(sizeof(Liste)); if(p == NULL) { /* erreur d'allocation de memoire */ printf("Erreur d'allocation mémoire "); exit(0); } /* initialisation de la structure */ p->freq = 0; strncpy(p->mot, mot, sizeof(p->mot)); /* creation des coordonnees */ /* mise a jour des liens, insertion en debut de liste */ p->suivant = TableHash[idx]; TableHash[idx] = p; //return; } p->freq++; } void dump_table(Liste **TableHash) { int boucle; for( boucle = 0; boucle != TAILLEHASH; boucle++) { Liste *p = TableHash[boucle]; if(p != NULL) { printf("hash=%d ", boucle); while(p != NULL) { printf(" (%s : %d) ", p->mot, p->freq); p = p->suivant; } } } } int numligne (FILE *F) { int res=0; F = fopen (FNAME, "r"); if (F != NULL) { char buffer[BUFSIZ]; int nb_read; while ((nb_read = fread (buffer, 1, sizeof buffer, F)) > 0) { int i; for (i = 0; i < nb_read; i++) { if (buffer[i] == ' ') { res++; } } } fclose (F); // printf ("%i ", res); } else { perror (FNAME); } return res; } void clean_table(Liste **TableHash, int NombreLigne ) { int boucle; float suup; for( boucle = 0; boucle != TAILLEHASH; boucle++) { Liste *premier_valide = NULL; Liste *q = TableHash[boucle]; while(q != NULL) { suup = (float)(q->freq) / (float)(NombreLigne); if(suup < Seuil) { /* supprime l'element */ Liste *tmp = q->suivant; /* -mo- libere(q); n'est pas déclarée */ q = tmp; } else { if(premier_valide == NULL) { premier_valide = q; } q = q->suivant; } } TableHash[boucle] = premier_valide; } } Liste *InsertionEnTete(Liste *L, int freq, char *mot){ Liste *nouveau; nouveau = (Liste *) malloc (sizeof(Liste)); nouveau->freq = freq; strcpy(nouveau->mot,mot); nouveau->suivant = L; return nouveau; } void AfficherListe(Liste *L){ Liste *p; for(p=L;p!=NULL;p=p->suivant){ printf("%s ",p->mot); printf("%d : ",p->freq); } } char* GetFirstWord(const char* sentence, char* buffer) { { char* pch; strcpy(buffer, sentence); pch = strtok(buffer," ,.-"); if (pch == NULL) { buffer[0] = 0; pch = buffer; } return pch; } } char* GetLastWord(const char* sentence, char* buffer) { char* res; char* pch; strncpy(buffer, sentence,C_TAILLE_MOT); res = NULL; pch = strtok(buffer," ,.-"); while (pch != NULL) { res = pch; pch = strtok (NULL, " ,.-"); } if (res == NULL) {/* C'est qu'on n'est pas rentre dans la boucle while -> donc le premier mot = l'ensemble de sentence */ res = buffer; } return res; } Liste * GenNseq(Liste *seq2, Liste **seq) { Liste *p; Liste *q; int i; char * mot; char * mot1; char *first; char *last; char buff1[C_TAILLE_MOT];/* pas besoin de malloc car 50 est une petite taille et ca s'ajuste avec Liste::mot */ char buff2[C_TAILLE_MOT];/* deux buffer temporaire: un pour chaque liste!*/ Liste *pNouvelleListe;/* pour creer la liste*/ Liste *pCourant; pNouvelleListe=NULL; for(p=seq2; p!=NULL; p=p->suivant){ mot=p->mot; if(mot){ first=GetFirstWord(mot, buff1); //for(i=0;i<39;++i){ // pour chaque élément (liste) de seq for(q=seq; q!=NULL; q=q->suivant){ // seq[i] - element(liste) de seq mot1 =q->mot; if(mot1){ printf("%s", mot1); last=GetLastWord(mot1, buff2); if(strncmp(first, last,C_TAILLE_MOT)==0){ printf("similaires!!!!"); pCourant = malloc(sizeof(Liste)); pCourant->freq = 1; strncpy(pCourant->mot,first,C_TAILLE_MOT); pCourant->suivant = pNouvelleListe; pNouvelleListe = pCourant; } } } } } return pNouvelleListe; } //void Affiche_L(Liste **seq2, Liste **seq) //{ // Liste *p; // Liste *q; // for(p=*seq2; p!=NULL; p=p->suivant) // printf("%s ",p->mot); // // for(q=*seq; q!=NULL; q=q->suivant) // printf("%s ",q->mot); //} int main(void) { Liste **seq; Liste *seq2=NULL; int res; FILE *fdesc=fopen(FNAME,"r"); Liste *TableHash[TAILLEHASH]; Liste *p1; int i; int n=400000; for(i = 0; i < TAILLEHASH; ++i) { TableHash[i] = NULL; } if( fdesc ) { char buff[BUFFSIZE]; char prec[BUFFSIZE]; if( get_word(fdesc,prec,BUFFSIZE) ) { while( get_word(fdesc, buff, BUFFSIZE) ) { //printf("%s %s ",prec,buff); char s3[BUFFSIZE * 2]; sprintf(s3, "%s %s", prec, buff); puts(s3); strncpy( prec,buff,BUFFSIZE); insere_th(TableHash,s3); } } } dump_table(TableHash); res = numligne(fdesc); printf("%d ", res); //printf("aaaaaaaaaaaaaaaaaaaaaaaa"); clean_table(TableHash, res); printf("la liste filtrée "); dump_table(TableHash); seq =(Liste **) malloc ( n *sizeof(Liste *)); // les tableau des toutes les Nseq seq[0]=NULL; for(i=0;isuivant) { seq2=InsertionEnTete(seq2, p1->freq, p1->mot); } // // } } seq[0]=seq2; AfficherListe(seq[0]); printf ("fin d'affichage de la liste des 2 seq "); // for(i=0; i

lami20j · Answer

Je vois que tu ne comprends pas

           for(q=seq; q!=NULL; q=q->suivant){ // seq[i] - element(liste) de seq
             mot1 =q->mot;
             if(mot1){
                 printf("%s", mot1);
               last=GetLastWord(mot1, buff2);
               if(strncmp(first, last,C_TAILLE_MOT)==0){
                printf("similaires!!!!");
                 pCourant = malloc(sizeof(Liste));
                 pCourant->freq = 1;
                 strncpy(pCourant->mot,first,C_TAILLE_MOT);
                 pCourant->suivant = pNouvelleListe;
                 pNouvelleListe = pCourant;
               }

Cette partie de code ne teste que le 1er élément de ton tableau de liste dont le seq[0] c'est tout
seq étant l'adresse du 1er élément du tableau de pointeurs

vraiment tordu ta façon de vouloir créer le **seq

stroumpf · Answer

ta une idée plus optimiseé pour parcourir les 2 liste en comparant les elements ?
moi je vois , je vois seulement cette methode :(

stroumpf · Answer

apres 1heure de run il se plante :(
je sais pas pourquoi

[C ]erreur de segmentation dans une fonction

47 réponses

Discussions similaires