langage c: suppression element d'une liste

[invite8b421ec7]

Bonjour,

Je souhaiterais savoir comment éliminer un élement ayant une certaie valeur de ma liste.
Voici ce que j'ai réalisé. Toutefois, mon programme plante.
Le débuggeur ne me renvoie rien en retour. Je ne vois pas d'où l'erreur survient.

typedef struct Point
{      
    int identifiant;
    double abscisse;
    double ordonee;
        struct Client *suivant;
}client;
typedef struct ListeRepere {
		client *debut;
		client *fin;
		int taille;
}llist;

/*=================================================
initialisation liste chainee simple
===================================================*/
void initialisation_llist (llist *liste){
		liste->debut = NULL;
		liste->fin = NULL;
		liste->taille = 0;
}
/*=================================================
ajouter element en tete dans ma liste chainee simple
====================================================*/
int ins_debut_liste (llist * liste, int id, double abs, double ord){
  client *nouveau;
  if ((nouveau= (client *) malloc (sizeof (client))) == NULL)
    return -1;
        nouveau->identifiant = id;
    nouveau->abscisse = abs;
    nouveau->ordonee = ord;
    nouveau->suivant = NULL;
    nouveau->suivant = liste->debut;
    liste->debut = nouveau;
    liste->taille++;
  return 0;
}
/*==========================================================================
fonction supprimer client de ma liste client
===========================================================================*/
void supprimerElement(client *p, int valeur)
{
    client *t = p;
    while( (p = p->suivant) != NULL)
    {
         if(p->identifiant == valeur)
         {
              t->suivant = p->suivant;
              free(p);
              break;
         } 
         t = p;
    }
}


  

/*=================================================
affichage element de ma liste chainee simple
===================================================*/
void affiche (llist * liste){
  client *courant;
  courant = liste->debut;
  while (courant != NULL){
      printf ("%d\n", courant->identifiant);
      courant = courant->suivant;
  }
}
/*=================================================
destruction de ma liste chainee simple
===================================================*/
int supp_debut (llist * liste){
  if (liste->taille == 0)
    return -1;
  client *supp_element;
  supp_element = liste->debut;
  liste->debut = liste->debut->suivant;
  if (liste->taille == 1)
    liste->fin = NULL;
   liste->taille--;
  return 0;
}
void detruire (llist * liste){
  while (liste->taille > 0)
    supp_debut (liste);
}
/*=================================================
programme principal
===================================================*/
int main (void)
{
    llist *ma_liste;
    if ((ma_liste = (llist *) malloc (sizeof (llist))) == NULL)
    return -1;
        
    client *p;

    int id;
    double abs;
    double ord;
    int i,j;
    
    FILE *fp = NULL;
    
    initialisation_llist (ma_liste);

    if (ma_liste!= NULL)
        printf("la liste est non vide \n");

    if ((fp = fopen("D:\\Codes\\TS2004t3\\test.txt", "r"))== NULL)
    {
        printf("Impossible d'ouvrir fichier donnees .txt \n");
        exit (-1);
    }
    else
    {
        for (i=0;i<24;i++)
        {
            fscanf(fp,"%d %lf %lf ",&id,&abs,&ord,);
            ins_debut_liste(ma_liste,id,abs,ord);

        }
    }
       
    supprimerElement(p,15);
   affiche (ma_liste);
   
   detruire (ma_liste);
 
   getchar();
    return 0;
}

Merci par avance de votre aide.
-----

[Jack]

A priori, ton code de suppression ne devrait pas faire planter.

Une remarque cependant:

    while( (p = p->suivant) != NULL)

En faisant cela, tu ne compareras jamais la valeur recherchée au 1er élément de la liste. Et si la liste est vide, alors là ça va planter.

A+

[polo974]

    supprimerElement(p,15);

Et p vaut quoi ? ? ?
c'est un reste de copier/coller sans doute.

La malédiction du copier/coller a encore frappé.

[invite8b421ec7]

    supprimerElement(p,15);

Et p vaut quoi ? ? ?

Bonjour,

Le p est un pointeur qui pointe sur un élement de la liste.

[A voir en vidéo sur Futura]

[Jack]

Bien vu polo. Je ne pensais pas qu'il fallait même vérifier le programme principal.

Bonjour,

Le p est un pointeur qui pointe sur un élement de la liste.

Et a quel moment mets-tu des éléments dans cette liste? Du coup, comme elle est vide, le programme plante comme je l'ai annoncé dans ma 1èrer réponse.

A+

[invite8b421ec7]

Bien vu polo. Je ne pensais pas qu'il fallait même vérifier le programme principal.Et a quel moment mets-tu des éléments dans cette liste? Du coup, comme elle est vide, le programme plante comme je l'ai annoncé dans ma 1èrer réponse.

A+

La fonction

ins_debut_liste(ma_liste,id,ab s,ord);

permet d'ajouter des élements dans la liste(24 éléments).

FILE *fp = NULL;
    
    initialisation_llist (ma_liste);

    if (ma_liste!= NULL)
        printf("la liste est non vide \n");

    if ((fp = fopen("D:\\Codes\\TS2004t3\\test.txt", "r"))== NULL)
    {
        printf("Impossible d'ouvrir fichier donnees .txt \n");
        exit (-1);
    }
    else
    {
        for (i=0;i<24;i++)
        {
            fscanf(fp,"%d %lf %lf ",&id,&abs,&ord,);
            ins_debut_liste(ma_liste,id,abs,ord);

        }
    }

[Jack]

Tu devrais lire avec attention les réponses que l'on te fait.

Ta liste, elle s'appelle ma_liste ou elle s'appelle p? Parce que si tu as bien initialisé ma_liste, tu n'as pas initialisé p. Donc la liste p est vide.

Comme l'a dit polo, tu as du faire un copier/coller sans remettre les noms de variable à jour

[polo974]

C'est pire qu'une liste vide, c'est un pointeur qui pointe vers n'importe quoi...

Heureusement, ce n'est pas le canon d'un flingue qui pointe vers la foule au lieu d'une cible en carton...

[Jack]

C'est pire qu'une liste vide, c'est un pointeur qui pointe vers n'importe quoi...

Heureusement, ce n'est pas le canon d'un flingue qui pointe vers la foule au lieu d'une cible en carton...

Du coup, on se demande comment Celine2 debugge:

Le débuggeur ne me renvoie rien en retour. Je ne vois pas d'où l'erreur survient.

[invite8b421ec7]

J'ai initialisé pointeur sur element p à NULL. Mais ça ne fonctionne toujours pas.

typedef struct Client
{
     
    int identifiant;
    double abscisse;
    double ordonee;
    struct Client *suivant;
}client;
typedef struct ListeRepere {
		client *debut;
		client *fin;
		int taille;
}llist;
void supprimerElement(client *p, int valeur)
{
    client *t = p;
    while( (p = p->suivant) != NULL)
    {
         if(p->identifiant == valeur)
         {
              t->suivant = p->suivant;
              free(p);
              break;
         } 
         t = p;
    }
}
int main (void)
{
    llist *ma_liste;
    ma_liste = (llist *) malloc (sizeof (llist));
    client *p = NULL;
      int id;
    double abs;
    double ord;
    int i,j;
    
    FILE *fp = NULL;
    
    if (ma_liste!= NULL)
        printf("la liste est non vide \n");

    if ((fp = fopen("D:\\Codes\\TS2004t3\\test.txt", "r"))== NULL)
    {
        printf("Impossible d'ouvrir fichier donnees .txt \n");
        exit (-1);
    }
    else
    {
        for (i=0;i<24;i++)
        {
            fscanf(fp,"%d %lf %lf",&id,&abs,&ord);
            ajouterElement(ma_liste,id,abs,ord);

        }
    }
 
   supprimerElement(p, 12);
   
   affiche (ma_liste);
   detruire (ma_liste);
      getchar();
    return 0;
}

[Jack]

J'ai initialisé pointeur sur element p à NULL. Mais ça ne fonctionne toujours pas.

C'est désespérant. Ca sert à quoi de te répondre si tu ne prêtes pas plus d'attention à nos réponses

Relis ATTENTIVEMENT ce qui précède.

[invite8b421ec7]

Tu devrais lire avec attention les réponses que l'on te fait.

Ta liste, elle s'appelle ma_liste ou elle s'appelle p? Parce que si tu as bien initialisé ma_liste, tu n'as pas initialisé p. Donc la liste p est vide.

Comme l'a dit polo, tu as du faire un copier/coller sans remettre les noms de variable à jour

Pour moi, p est un pointeur sur élement de la liste

[ventilopomme]

bon deja un probleme vu que p est pas une variable globale
au niveau du main il vaut toujours null
donc tu as
supprimerElement(p, 12);
c'est comme si tu avais
supprimerElement(null, 12);

donc si tu veux supprimer un element de ta liste
supprimerElement(ma_liste->debut, 12);

alors deja dans ta fonction supprimer
des le debut tu fais un pas de trop
moi je ferais cela deja ta fonction supprimer tu passes l'adresse de ta liste
car si ton element est le premier tu dois faire ce cas particulier
p=liste->premier->suivant;
liste->premier=p;
sinon tu fais un autre cas
car il fau tpas oublier ta fonctionne supprime un element de ta liste donc tu dois passer l'adresse de ta liste

[invite8b421ec7]

SVP est ce que ceci est correcte

typedef struct Client
{
    
    
    int identifiant;
    double abscisse;
    double ordonee;
    struct Client *suivant;
}client;
typedef struct ListeRepere {
		client *debut;
		client *fin;
		int taille;
}llist;
void supprimerElement(llist *p, int valeur)
{
    llist *t = p;
    while( (p = p->debut->suivant) != NULL)
    {
         if(p->debut->identifiant == valeur)
         {
              t->debut->suivant = p->debut->suivant;
              free(p);
              break;
         } 
         t = p;
    }
}
int main()
{
    llist *ma_liste;
    ma_liste = (llist *) malloc (sizeof (llist));
    supprimerElement(ma_liste, 12);
    return 0;
}

[ventilopomme]

non probleme de cast de pointeur
as tu fait a la main deja un croquis avec des cases avant de te lancer dans le code ?

[ventilopomme]

void supprimerElement(llist *p, int valeur)
{
    element *t,*ptr;
    ptr=p->premier
    t=ptr;
    while( (ptr) != NULL)
    {
         if(ptr->identifiant == valeur)
         {
              if  (t==ptr)
              {
                   p->premier = ptr->suivant;
                   free(ptr);
              } 
              else
              {
                    t->suivant=ptr->suivant;
                    free(ptr);
              } 
              break;
         } 
         t=ptr;
         ptr=ptr->suivant;
    }
}

je l'ai fait a la main donc je garantis rien

[invite8b421ec7]

void supprimerElement(llist *p, int valeur)
{
element *t,*ptr;
ptr=p->premier
t=ptr;
while( (ptr) != NULL)
{
if(ptr->identifiant == valeur)
{
if (t==ptr)
{
p->premier = ptr->suivant;
free(ptr);
}
else
{
t->suivant=ptr->suivant;
free(ptr);
}
break;
}
t=ptr;
ptr=ptr->suivant;
}
}

je l'ai fait a la main donc je garantis rien

Excellent ventilopomme
ça marche nickel!
Merci beaucoup!

[ventilopomme]

mais je te conseille de faire toujours un petit schéma a la mano avant
avec l'experience tu le feras de tete de plus il existe des livres d'algorithmique

[polo974]

C'est pire qu'une liste vide, c'est un pointeur qui pointe vers n'importe quoi...

Heureusement, ce n'est pas le canon d'un flingue qui pointe vers la foule au lieu d'une cible en carton...

J'ai initialisé pointeur sur element p à NULL. Mais ça ne fonctionne toujours pas.
...

Bon au moins ton flingue tu le diriges vers le sol maintenant...

Mais en fait, le pointer vers la cible (maliste->debut au hasard à la place de p qui ne sert à rien) , c'est quand même mieux... Non?

[ventilopomme]

vu que j'ai deja donné la solution
je pense que tu viens de te tirer une balle dans le pied
cela fait mal ?

[bzh_nicolas]

Je pense que la solution "toute cuite dans le bec" n'est pas une bonne solution.
Surtout pour une personne qui a des lacunes en algorithmique.
P.S. La phrase au-dessus est un peu brutale mais je pense que celine2 en est consciente.

[polo974]

vu que j'ai deja donné la solution
je pense que tu viens de te tirer une balle dans le pied
cela fait mal ?

Pense ce que tu veux, mais donner la réponse n'aide personne ici.
Et une sortie de ce genre va te faire apprécier, si, si...

celine2 fait des efforts pour apprendre le C, le but est de guider son raisonnement, pas de tout lui donner.
et quelques petites analogies et images pour bien marquer l'esprit, ça permet de décoincer la comprenette d'où l'histoire du flingue.

Maintenant, en revenant à ton post:

bon deja un probleme vu que p est pas une variable globale
...

Et ça aurait changé quoi si p avait été une variable globale?
ça aurait juste permis à tout le monde de tirer dans la foule, sans avoir à faire passer le flingue...
Intéressant, n'est-il pas?

[invite8550c31e]

liste recherche_supr(liste l,int x) // fonction recherche un élément d'une liste chaîné et le supprimé et renvoi la liste
{ int trv=0;
liste p=l;
liste q=l;

if(p->val==x)
{l=p->nxt;
free(p);}
else
{
while(p->nxt!=NULL&&trv==0)
{ if((p->nxt)->val==x)
{trv=1;}
else
{p=p->nxt;} }
if(trv==1)
{q=p->nxt;
p->nxt=q->nxt;
free(q); }
else
{printf("element inixistants\n");}}
return l;
} //fin fonction

int main()
{
liste l_1=NULL;
liste l_2=NULL;
// cree liste l_1

affiche(l_1);
printf("xxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxx\n");
l_2=recherche_supr(l_1,3);
affiche(l_2);
return 0;
}

Rappel de la charte que tu as acceptée en t'inscrivant ici:

La courtoisie est de rigueur sur ce forum : pour une demande de renseignements bonjour et merci devraient être des automatismes.

Merci d"en tenir compte à l'avenir

Pour la modération,

yoda1234.

[Jack]

Quel intérêt de donner ce code?

De plus, je t'encourage à lire les recommandations en tête du forum. Tu y apprendras qu'un code lisible doit être indenté et placé entre des balises code.

A+

[yoda1234]

J'ai fais une petite erreur qui est maintenant réparée, mais cela démontre que balancer du code sans explication et sans balise n'est pas l'idéal et ne facilite pas la compréhension.