Probleme de erreur de segmentation

Bonjour,

Je vous remercie de votre attention.

Voila, j'ai un gros soucie de segmentation fault que je n'arrive pas à résoudre depuis un bon bout de temps et je vous serais reconnaissant de bien vouloir m'aider.

J'utilise des structure de type :

typedef struct cour
{
char nom [15];
char prenom [15];
int dossard ;
int t_cumule ;
}coureur;

typedef struct elem
{
coureur donnee;
struct elem* suiv;
}element;

typedef struct list
{
element* debut;
element* fin;
element* courant;
}liste;

et à chaque fois que j'utilise des pointeurs du genre :
while (p_liste->courant->suiv != NULL) ou liste_init->debut = NULL ,... j'ai une erreur de segmentation.

Je les utilise dans des différentes fonctions.

Voici mon code au complet : (la fonction principal n'est pas fini, c'est juste pour tester qu'il n'y a pas d'erreur)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct cour
{
char nom [15];
char prenom [15];
int dossard ;
int t_cumule ;
}coureur;

typedef struct elem
{
coureur donnee;
struct elem* suiv;
}element;

typedef struct list
{
element* debut;
element* fin;
element* courant;
}liste;

void init_liste (liste* liste_init);
void inserer_coureur (coureur p_coureur, liste* p_liste);
void aller_debut (liste* p_liste);
void avancer (liste* p_liste);
void fin (liste* p_liste);
element coureur_courant (liste* p_liste);
void effacer_courant (liste* p_liste);
void affiche_liste (liste* p_liste);

coureur* creer_coureur ();
int ajouter_temps ( coureur* n_coureur );
void affiche_coureur ( coureur* a_coureur );

coureur* creer_coureur (void)
{
coureur* nouveau;

nouveau = malloc (sizeof (coureur));

printf ("entrer le nom du coureur\n");
scanf ("%s",nouveau->nom);

printf ("entre le prenom du coureur\n");
scanf ("%s",nouveau->prenom);

printf ("entrer le numero du dossard\n");
scanf ("%d",&(nouveau->dossard));

nouveau->t_cumule = 0;

return nouveau;
}

int ajouter_temps ( coureur* n_coureur )
{
int val_jour;

printf ("entrer le temps de l'etape du jour en seconde\n");
scanf ("%d",&val_jour);

return (n_coureur->t_cumule) = (n_coureur->t_cumule) + (val_jour);
}

void affiche_coureur ( coureur* a_coureur )
{
int heure=0, minute=0, seconde=0;

heure = (a_coureur->t_cumule) / 3600 ;
minute = ( (a_coureur->t_cumule) - (heure * 3600 ) ) / 60;
seconde = (a_coureur->t_cumule) - ( (heure * 3600)+(minute * 60) );

printf ("\nnom : %s\nprenom : %s\ndossard : %d\ntemps cumule : %dh %dm %ds\n",a_coureur->nom,a_coureur->prenom,a_coureur->dossard,heure,minute,seconde);

}

void init_liste (liste* liste_init)
{
liste_init->debut = NULL;
liste_init->fin = NULL;
//liste_init->courant = NULL;
}

/*insertion en queue de liste */
void inserer_coureur (coureur p_coureur, liste* p_liste)
{
element* nouveau;

nouveau = (element*) malloc(sizeof(element));
nouveau->suiv=NULL;
nouveau->donnee=p_coureur;

if (p_liste->debut == NULL)
{
nouveau->suiv=p_liste->debut ;
nouveau->donnee=p_coureur;
p_liste->debut = nouveau;
}

else
{
while (p_liste->courant->suiv != NULL)
{
p_liste->courant = p_liste->courant->suiv;
/*mise a jour champs*/
nouveau->suiv = p_liste->courant->suiv;
nouveau->donnee = p_coureur;
/*mise a jour de la queue*/
p_liste->courant->suiv=nouveau;
}
}
}

void aller_debut (liste* p_liste)
{
if (p_liste!=NULL)
{
p_liste->fin = p_liste->debut->suiv;
}
}

void avancer (liste* p_liste)
{
if ( (p_liste!=NULL)&&(p_liste->fin!=NULL) )
{
p_liste->fin = p_liste->fin->suiv;
}
}

void fin (liste* p_liste)
{
if (p_liste!=NULL)
{
if (p_liste->fin->suiv != NULL)
printf ("vous n etes pas a la fin de la liste\n");

else
printf ("vous etes a la fin de la liste\n");
}
}

element coureur_courant (liste* p_liste)
{
element* courant;
courant = (element*) malloc(sizeof(element));

courant = p_liste->courant;

return *courant;
}

void effacer_courant (liste* p_liste)
{
element *supp_element;

supp_element = p_liste->courant;
supp_element->suiv = p_liste->courant->suiv;

free (supp_element);
p_liste->courant = p_liste->courant->suiv;

}

void affiche_liste (liste* p_liste)
{
p_liste->courant = p_liste->debut;
int heure=0, minute=0, seconde=0;

while (p_liste->courant->suiv != NULL)
{
affiche_coureur ( &(p_liste->courant->donnee) );
p_liste->courant = p_liste->courant->suiv;
}
}

int main (void)
{
liste n_liste;
coureur* p_coureur;

p_coureur = creer_coureur ();
p_coureur->t_cumule = ajouter_temps ( p_coureur );

init_liste (&n_liste);
affiche_liste ( &n_liste );

system ("pause");
return 0;
}

Je vous remercie de votre attention!