liste chainée

[invite69686042]

salut tout le monde j'ai besoin d'une fonction qui supprimer les occurrences dans une listes chainée en langage C j'arrive pas de la faire même j'ai essayer suffisamment
-----

[Jack]

Commence par nous montrer du code (ENCADRE PAR DES BALISES CODE) et on essaiera de voir ce qui ne marche pas.

A+

[invite69686042]

void Supprime_Ocuurences(liste *L , int *pf)
{
    PElement precedent,courant,suivant;
    precedent=NULL;
    courant=L->premier;
    suivant=courant->suivant;
    
    while(suivant!=NULL)
              if(courant->pf != suivant->pf)    courant=courant->suivant ;
              else   Decaler_Gauche( L) ;
}

void Decaler_Gauche ( liste *L )
{

     PElement courant;
     while(courant!=pp->pf)  courant=courant->suivant;

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

#define croissant 1
#define decroissant 2


typedef struct element *PElement;
typedef struct {
        int jr;
        int ms;
        int an;
        }date;
typedef struct element {
PElement suivant;
char marque[20];
char mat[20];
int pf;
date cir;
};

typedef int booleen;



typedef struct {
PElement premier;
PElement dernier;
PElement courant;
} liste;

void initialiser(liste *L) {
L->premier=NULL;
L->dernier=NULL;
L->courant=NULL;
}


void ecrit(PElement ptc) {
     
     printf("La marque de voiture: %s\n",ptc->marque);
     printf("Le matricule: %s\n",ptc->mat);
     printf("la puissance fiscale: %d\n",ptc->pf);
     printf("la date de circulation: %d/%d/%d\n",ptc->cir.jr,ptc->cir.ms,ptc->cir.an);
     
     }

booleen listevide(liste *L) {
return L->premier==NULL;
}

void insererentete(liste *L, PElement Nouveau) {
Nouveau->suivant=L->premier;
L->premier=Nouveau;
if(L->dernier==NULL) L->dernier=Nouveau;
}


void insererapres(liste *L,PElement precedent,PElement Nouveau) {
if(precedent==NULL) {
insererentete(L,Nouveau);
}
else {  
Nouveau->suivant=precedent->suivant;
precedent->suivant=Nouveau;
if(precedent==L->dernier)      L->dernier=Nouveau;
}
}


void insererenfin(liste *L, PElement Nouveau) {
insererapres(L,L->dernier,Nouveau);
}


PElement extraireentete(liste *L) {
PElement extrait;
extrait=L->premier;
if(!listevide(L)) { 
L->premier= L->premier->suivant;
if(L->premier==NULL) L->dernier=NULL;  }
return extrait;
}


PElement extraireapres(liste *L, PElement precedent) {
PElement extrait;
if(precedent == NULL) {
extrait =extraireentete(L);
} else { extrait= precedent->suivant;
if(extrait!=NULL) {
precedent->suivant=extrait->suivant;
if(extrait==L->dernier) L->dernier=precedent;
}
}
return extrait;
}


PElement extraireenfin(liste *L) {
PElement extrait,ptc;       /* pointeur courant */
if(listevide(L)) {
extrait=NULL;
} else if(L->premier==L->dernier) {     /* un seul élément */
extrait=L->premier;
L->premier=NULL;
L->dernier=NULL;
} else {  ptc=L->premier;
while(ptc->suivant !=L->dernier)     ptc=ptc->suivant;  
/* extrait = extraireapres(L,ptc) */
extrait= ptc->suivant; 
ptc->suivant=NULL;
L->dernier=ptc;  }  return extrait; }


void ouvrirliste(liste *L) {
L->courant=L->premier; }

booleen finliste(liste *L) {
return L->courant==NULL;  }


PElement elementcourant(liste *L) {
PElement ptc;
ptc=L->courant;
if(L->courant !=NULL) {
L->courant=L->courant->suivant;  }
return ptc; }


void detruireliste(liste *L) {
PElement ptc;
ouvrirliste(L);
while(!finliste(L)) {
ptc=elementcourant(L);
free(ptc); }
initialiser(L);  }

void recopieliste(liste *L1,liste *L2) {
detruireliste(L1);
*L1=*L2;
initialiser(L2);
}

void listerliste(liste *L) {
     
PElement ptc;
if (listevide(L)) { printf("Liste vide !!");}
else {  
       ouvrirliste(L);
       
while(!finliste(L)) {
                    ptc=(PElement)elementcourant(L);
                    ecrit(ptc);
                    }       
                    }
     }
     


int compterliste(liste *L)
{
    int c=0;
    PElement ptc;
    if (listevide(L))   return 0;
    else{
         ouvrirliste(L);
         
    while(!finliste(L))
    {
              ptc=(PElement)elementcourant(L);
              c++;
    } return c;
    } 
}


void Supprime_Ocuurences(liste *L , int *pf)
{
    PElement precedent,courant,suivant;
    precedent=NULL;
    courant=L->premier;
    suivant=courant->suivant;
    
    while(suivant!=NULL)
              if(courant->pf != suivant->pf)    courant=courant->suivant ;
              else   Decaler_Gauche( L) ;
}

void Decaler_Gauche ( liste *L )
{

     PElement courant;
     while(courant!=pp->pf)  courant=courant->suivant;

}   
}




/********************************************************************************/     
void chercherelement(liste *L,int *num) {
 booleen trouve=0; PElement ptc;
 
  ouvrirliste(L);
  
  while(!finliste(L)) {
                    ptc=(PElement)elementcourant(L);
                    trouve=(ptc->pf)==(*num);
                    if(trouve==1) ecrit(ptc);
                    }       
 
if(trouve==0) printf("La voiture dont la pf est %d n'existe pas !!",*num);
}


/* fournit vrai si n existe ds L *P vaut alors NULL si n est le premier de la liste, fournit faux si nom n'est pas ds L */

booleen chercherprecedent(liste *L,int *num,PElement *p) {
booleen trouve = 0;
PElement prec = NULL;
PElement ptc = NULL;

  ouvrirliste(L);
  
  while(!finliste(L)&& !trouve) {
                       prec = ptc;
                    ptc=(PElement)elementcourant(L);
                    trouve=(ptc->pf)==(*num);
                    }       
                    
  if(trouve) *p=prec;                  
return trouve;  

}

/********************************************************************************/
booleen ordre(PElement Nouveau,PElement ptc,int cd) {
        
        int v1=Nouveau->pf;
        int v2=ptc->pf;

if(cd==croissant) return (v1<v2);
return (v1>v2);
}

/********************************************************************************/

int menu() {
    int cod;
    printf("\n\n --|*|-- GESTION D'UNE LISTE DE VOITURES\n\n");       
    printf("0  - Quitter\n"); 
    printf("1  - Ajout d'une voiture\n");  
    printf("2  - Insertion en fin de liste\n");
    printf("3  - Retrait en tete de liste\n");              
    printf("4  - Retrait en fin de liste\n"); 
    printf("5  - Supprimer voiture\n"); 
    printf("6  - Parcours de la liste\n"); 
    printf("7  - Recherche d'un element\n"); 
    printf("8  - Insertion en ordre a partir d'un fichier\n"); 
    printf("9  - Destruction de la liste\n"); 
    printf("10 - Insertion apres precedent\n");
    printf("11 - Tri a bulles de liste\n");
    printf("12 - Copie de liste dans un fichier\n");
    printf("13 - Nombre de voiture\n");
    printf("\n");
    printf("Votre choix ? : ");scanf("%d",&cod);
    printf("\n");
       return cod;
       }

/********************************************************************************/

void insererenordre(liste *L,PElement nouveau,int cd){
     
     PElement precd;
     PElement ptc;
     int trouve;
     
     if(listevide(L)){
                     
       insererentete(L,nouveau);
       }else{
             ouvrirliste(L);
             ptc=elementcourant(L);  
                          
             if(ordre(nouveau,ptc,cd)) {
                              insererentete(L,nouveau);}
                              else {   /* insertion en milieu de liste ou fin de liste */ 
                                   trouve=0;
                                   while(!finliste(L)&&!trouve){
                                                                precd=ptc;
                                                                ptc=elementcourant(L);          
                                                                trouve=ordre(nouveau,ptc,cd);
     /* insertion en milieu de liste ou fin de liste */                                        }
     
if(trouve){ /* milieu */
           
           insererapres(L,precd,nouveau);
           } else {  /* fin*/
                  insererenfin(L,nouveau);
                  }
                  }
                  }
                  }
                               
/********************************************************************************/  


void tri_bulle_lst(liste *L)
/* le premier ne sera peut-être plus le même donc passage par adresse */
 {
  int ok;
  PElement prec,actu,suiv;
  do
   {
    ok=1; /* vrai */
    
    prec=NULL;
    actu=L->premier;
    suiv=actu->suivant;
    
    while(suiv!=NULL)
     {
      if(actu->pf > suiv->pf)
       {
           ok=0;
        if(prec!=NULL) prec->suivant=suiv; 
        else L->premier=suiv;
        actu->suivant=suiv->suivant;
        suiv->suivant=actu;
       }
      prec=actu;
      actu=suiv;
      suiv=actu->suivant;
     }
   }
  while(!ok);
 }

void copie_fichier(liste *L,FILE *FE){  
     
      PElement ptc;
 
     FE=fopen("voiture.TXT","a+");
     
     if(FE==NULL) { exit(-1);
                  printf("Erreur d'ouverture !!!\n");
                  }
     else { 
     
  ouvrirliste(L);
  
  while(!finliste(L)) {
                    ptc=(PElement)elementcourant(L);
                   fprintf(FE,"%s\n %s\n %d\n %d %d %d\n\n",ptc->marque,ptc->mat,ptc->pf,ptc->cir.jr,ptc->cir.ms,ptc->cir.an);
                    
                    }          
     
     fclose(FE);
     } }
                                                                                  
main() {
       
       liste li1;
       liste *l1=&li1;
       FILE *fe;
       int cd,tmp,permute;
       booleen fini,trouve=0;
       int num;
       int pf;
       PElement Nouveau,extrait,precedent,pp, ptc;
       int c;
       initialiser(l1);
       
       fini=0;
       
       while(!fini){
                    
                    switch(menu()) {
                                   
case 0 : fini=1;exit(0);break;  

case 1 : Nouveau=(PElement)malloc(sizeof(element));
         printf("Marque :");
         scanf("%s",Nouveau->marque);
         printf("Puissance :");
         scanf("%d",&Nouveau->pf);
         printf("Matricule :");
         scanf("%s",Nouveau->mat);
         printf("Date de circulation :");
         scanf("%d %d %d",&Nouveau->cir.jr,&Nouveau->cir.ms,&Nouveau->cir.an);
         insererentete(l1,Nouveau);
         break;

                                 
/*case 10 : Nouveau=(PElement)malloc(sizeof(element));
         printf("Entier a ajouter ? : ");
         scanf("%d",&Nouveau->pf);

        
        precedent=(PElement)malloc(sizeof(element));
        
         printf("Precedent ? : ");
         scanf("%d",&precedent->pf);
         precedent=chercherelement(l1,&precedent->pf);
         insererapres(l1,precedent,Nouveau);   
         break; */
         
case 11 :   tri_bulle_lst(l1);
            printf("Liste triee par ordre croissant : \n\n");
            listerliste(l1); break;       
         
          
         
case 2 : Nouveau=(PElement)malloc(sizeof(element));
         printf("Entier a ajouter ? : ");
         scanf("%d",&Nouveau->pf);insererenfin(l1,Nouveau);break;  
         
case 3 : extrait=(PElement)extraireentete(l1);
            if(extrait!=NULL) {
         printf("Element %d extrait en tete de liste : ",extrait->pf);}
         else{printf("Liste vide !!");}
        break;  
                 

case 4 : extrait=(PElement)extraireenfin(l1);
            if(extrait!=NULL) {
         printf("Element %d extrait en fin de liste : ",extrait->pf);}
         else{printf("Liste vide !!");}
        break;      
       
case 5 :
         printf("Voiture a extraire (Puissance)? : ");scanf("%d",&num);
         trouve=chercherprecedent(l1,&num,&precedent);
         if(!trouve){
                 printf("%d Puissance n'existe pas dans la liste !\n",num);  }  
         else{extrait=(PElement)extraireapres(l1,precedent);
          if(extrait!=NULL) {
         printf("Element %d extrait de la liste",extrait->pf);
         }
         }
        break;  
        
case 6 : listerliste(l1);break; 


case 7 : printf("puissance a rechercher ? : ");scanf("%d",&num);
         chercherelement(l1,&num);
         
                                                            
        break; 
    
    
case 8 : printf("1- Insertion en ordre croissant\n");
         printf("2- Insertion en ordre decroissant\n");
         printf("\nVotre choix ? : ");scanf("%d",&cd);
          
          fe=fopen("ENTIERS.txt","r");
          if(fe==NULL){printf("Erreur d'ouverture de fichier\n");
          }else {
                initialiser(l1);
                while(!feof(fe)){
                                 Nouveau=(PElement)malloc(sizeof(element));
                                 fscanf(fe,"%d\n",&Nouveau->pf);
                                 insererenordre(l1,Nouveau,cd);
                                 }
                                 fclose(fe);
                                 listerliste(l1);
                                 } 
                                   break;     
case 9 : detruireliste(l1);break; 


case 12 :copie_fichier(l1,fe);break;


case 13 :c=compterliste(l1);
         if (c==0)
             printf("\n\t liste vide\n");
         else    { printf("\n La liste est composé de %d voiture.\n",c);}

         break;
 
 
case 14 : printf("entrer la valeur de pf a supprimer de la liste");
          scanf("%d",&pf);
          Supprime_Ocuurences(l1 ,pf, pp);
          break;
 
 
         
}

}

getch();
}

[yoda1234]

Nous avons dit:

(ENCADRE PAR DES BALISES CODE)

Est-ce si difficile a comprendre?
Pour cette fois, j'ai corrigé.

[A voir en vidéo sur Futura]

[invite69686042]

et alors???

[Jack]

et alors???

et alors tu pourrais déjà dire merci à yoda qui a fait le boulot que tu n'as pas voulu faire.

Enfin bon ...

Qu'est-ce qui ne marche pas dans ta fonction? J'ai remarqué que la ligne suivante pouvais poser problème:

    suivant=courant->suivant;

Que vaut suivant si la liste est vide?

A+

[invite895675d5]

Voilà les problèmes que j'ai vu déjà :

void Supprime_Ocuurences(liste *L , int *pf)
{
    PElement precedent,courant,suivant;
    precedent=NULL;
    courant=L->premier;
    suivant=courant->suivant;
    
    while(suivant!=NULL)
     // à voir s'il ne manque pas les accolades ici
              if(courant->pf != suivant->pf)    courant=courant->suivant ;
              else   Decaler_Gauche( L) ;
}

void Decaler_Gauche ( liste *L )
{

     PElement courant;
     while(courant!=pp->pf)  courant=courant->suivant;
	 //courant pas initialisé
	 //c'est quoi pp ? tu ne le déclare pas ni dans la procédure ni en variable globale

}   
} // en trop
//il vaut mieux éviter de mettre quoique ce soit avant les includes
//là, ça ne doit même pas compiler...
#include <stdio.h>

Maintenant, qu'est-ce qu'est censé faire ta procédure Supprime_Ocuurences ? Pourquoi lui fournit tu deux paramètres en entrée, vu que tu n'utilise pas le deuxième dans le corps de la procédure ?

[invite69686042]

pour suppsimer tout les occurences dans une liste chainées la valeur da ces occuences sera demander a l'utilisateur de la donner pour supprimer tout les element qui ont cette valleur de pf (puissance fiscale d'une voiture)