Problème avec les listes chainées

Version imprimable

Bonjour !!

je veut supprimer un element d'une liste chainée en demandant a l'utilisateur de donner la valeur qu'il veut supprimer .
mon probleme est dans la fonction de suppression de l'element .

Merci pour votre aide .

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void supp_elt(element *&debut,int val)
{
     element *c1,*c2;
     c1=debut;
     c2=debut;
     while(c1 != NULL){
              if(c1->info==val){
                               c2=c2->svt;
                               debut=c2->svt;
                               delete c1 ; c1=0;
                               }
                               else{
                                    c1=c1->svt;
                                    c2=c2->svt;
                                    }
   } 
 
}

22/02/2015, 08h50
LittleWhite

Bonjour,

Je vous conseille vivement d'utiliser un débogueur lorsque vous avez ce genre de soucis.

Moi, je ferai le parcours, tant que while(c1->svt != NULL) et non juste c1 != NULL.
Ce truc element *&debut avoir une référence d'un pointeur, c'est ultra étrange, donc certainement faux.

Si on enlève juste le dixième élément, pourquoi début pointerai sur le onzième : debut=c2->svt;N'hésitez pas à prendre une feuille de papier et un crayon pour mieux voir ce que fait l'algorithme et ce qu'il faut faire lors de la suppression d'un élément.

Bonsoir

concernant le debogueur ,je ne l'ai jamais utilisé ..pouvez-vous m'envoyer un tuto S.V.P .

pourquoi la référence d'un pointeur element *&debut est fausse pourtant on a resolu pas mal d'exo dans le TD avec
Pouvez vous m'expliquer ??

et concernant debut=c2->svt oui j'ai fait une trés grande erreur je l'ai pas remarqué .

voici mon nouveau code source mais le probleme persiste !!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void supp_elt(element *&debut,int val) { element * c1,*c2; c1 =debut; c2=debut; while(c1->svt != NULL){ if(c1->info==val){ c2=c2->svt; c1->svt=c2->svt; } else{ c1=c1->svt; c2=c2->svt; } } }

24/02/2015, 19h46
ChouAib0202

salam
je te remarque que vous avez dans votre fonction un seul cas c'est la superssion dans le mileu de la liste
pense si la tete,dernier element ==valeure entree
merci
06/03/2015, 20h09
LittleWhite

Oui, il y a (enfin) un tutoriel sur le débogage : http://alexandre-laurent.developpez....e-application/ :)
06/03/2015, 21h24
pascalCH

Citation:

Envoyé par Naswd_94

pourquoi la référence d'un pointeur element *&debut est fausse pourtant on a resolu pas mal d'exo dans le TD avec

J'avoue que j'aimerai bien voir un exemple (corrigé ... :weird:) qui justifie ce *&debut ....

Citation:

Envoyé par LittleWhite

Oui, il y a (enfin) un tutoriel sur le débogage : http://alexandre-laurent.developpez....e-application/ :)

je vous remercie , je vais l'essayer et concernant la fonction de suppression le probleme persiste !!!! je suis vraiment perdu O.o

Citation:

Envoyé par pascalCH

J'avoue que j'aimerai bien voir un exemple (corrigé ... :weird:) qui justifie ce *&debut ....

voici un exemple :
il s'agit de concatener 2 listes chainées sans sacrifier les listes originales .

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include<iostream>
 
using namespace std;
 
struct element 
{
       int info;
       element *svt;
 
};
void cree_liste(element *&D);
void inser_debut(element*&debut, int x);
void afficher(element *D);
void inser_fin(element*&debut, int x);
void concatener(element *D1,element *D2 ,element *&D3);
 
int main ()
{
    element *D1=0,*D2=0,*D3=0;
    cree_liste(D1);
    cout<<"\n";
    afficher(D1);
    cout<<"\n";
    cree_liste(D2); 
    cout<<"\n";
    afficher(D2);
    concatener(D1,D2,D3);
    afficher(D3);
 
 system("pause");
 return 0;
 
 
} 
 
 
 
 
 
void inser_debut(element*&debut, int x)
{
      element *nouveau ;
      nouveau = new element ;
      nouveau->info=x;
 
      debut=nouveau;
}      
 
 
 void cree_liste(element *&D)
{
     int i,n,x;
 
     cout <<"donner la taille de votre liste :  \n \t";
     cin >> n;
     for(i=0;i<n;i++)
     {
       cout<<"entrer la valeur: \0.5t ";    
       cin >> x;        
       inser_fin(D,x);
 
     }  
 
}
 
void afficher(element *D) 
{
     element *courant;
     courant =D;
     cout<<"votre liste : \t ";
     while(courant!=NULL)
     {
 
               cout<< courant->info <<"\t";
 
               courant=courant->svt;
     }
  cout<<"\n";   
}  
 
void inser_fin(element *&debut ,int x)
{
     element *courant;
     element *nouveau;
     nouveau = new element;
     nouveau->info=x;
     nouveau->svt=0;
     if (debut==0){
                   debut= nouveau;
                   }
     else
     {
      courant = debut ;
            while(courant->svt!=NULL)
            {
                courant=courant->svt;
            }                                            
       courant->svt = nouveau;
     }  
}                                
 
void concatener(element *D1,element *D2 ,element *&D3)
{
     element *courant;
     courant =D1;
 
     cout <<"\napres la concatenation : " << endl;
     while(courant != NULL)
     {
 
                         inser_fin(D3,courant->info);
                         courant = courant->svt;
     }                    
     courant =D2;
     while (courant != NULL)
     {
           inser_fin(D3,courant->info);
           courant=courant->svt;
     }  
}

09/03/2015, 10h31
Bousk

Citation:

Envoyé par pascalCH

J'avoue que j'aimerai bien voir un exemple (corrigé ... :weird:) qui justifie ce *&debut ....

Parce que c'est le seul moyen de modifier la tête de liste si tu la modifies. :weird:
09/03/2015, 10h40
ternel

Parce que si tu avais un type nommé liste, tu voudrais, tu aurais tout à fait envie d'avoir void supp_elt(liste & liste, int index).
Et que ce liste serait ici typedef element* liste;.