[C ]erreur de segmentation dans une fonction

GenNseq(seq, seq2);

InsertionEnTete

seq=(liste**)malloc(20000 * sizeof(liste*)); 

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
/* 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 && i<size && (c=fgetc(fdesc))!=EOF )
		{
			if( isalpha(c))
			{
				buff[i]=c;
				i++;
			}
			else if( i>0 )
			{	/* 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\n");
			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\n", boucle);
			while(p != NULL)
			{
				printf("\t(%s : %d)\n", 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] == '\n')
            {
               res++;
            }
         }
      }
      fclose (F);
    //  printf ("%i\n", 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 \n",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\n",p->mot);
//
//   for(q=*seq; q!=NULL; q=q->suivant)
//      printf("%s\n",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\n",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\n", res);
		//printf("aaaaaaaaaaaaaaaaaaaaaaaa");


		clean_table(TableHash, res);
		printf("la liste filtrée\n");


	dump_table(TableHash);

	seq =(Liste **) malloc ( n *sizeof(Liste *)); // les tableau des toutes les Nseq
    seq[0]=NULL;


    for(i=0;i<TAILLEHASH;++i)
    {

        if(TableHash[i] != NULL)
        {
        for(p1=TableHash[i];p1!=NULL;p1=p1->suivant)
        {
            seq2=InsertionEnTete(seq2, p1->freq, p1->mot);

        }
//
//
	}
    }
    seq[0]=seq2;
    AfficherListe(seq[0]);
    printf ("fin d'affichage de la liste des 2 seq\n");
//    for(i=0; i<n-1; i++)
//    {

       seq[i+1]=GenNseq( seq2, seq[0]);

   // }

AfficherListe(seq[1]);
printf("----------------the end-----------------------");
 //



//Affiche_L(seq2, seq);



free(seq);

	free(TableHash);

	return 0;
}

Liste * GenNseq(Liste *seq2, Liste **seq)