Discussion :

[Fahmi06]

Salut tout le monde,
J'ai introduit des fonctions classiques de manipulation des listes chainées dans mon application mais j'ai trouvé des résultats étranges.

Lorsque j'ai essayé les fonctions des listes chainées dans un petit programme à part j'ai remarqué que la suppression d'élement (qui sont des entiers) consiste à remplacer l'élément supprimé par un autre élément de valeur 0.

voici le code vous pouvez tester, j'ai utilisé le compilateur gcc sous ubuntu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdio.h>
#include <math.h>
 
typedef struct ID_REQUEST {
int val;
 
struct ID_REQUEST * suivant;
 
}ID_REQUEST;
 
void afficherListe(ID_REQUEST* liste);
void ajouter(ID_REQUEST*liste, int valeur);
void supprimerElement(ID_REQUEST* liste, int valeur);
/********************************** *********************/
void ajouter(ID_REQUEST*liste, int valeur){
 
      struct ID_REQUEST* new = malloc(sizeof *new);
      if(new != NULL ) {
	new->val=valeur;
	new->suivant = NULL;
     }
 
     if (liste == NULL){
	  liste = new;
 
      }
      else {
	struct ID_REQUEST* temp=liste;
	while(temp->suivant != NULL){
	    temp = temp->suivant;
        }
	temp->suivant = new;
	return;
      }
}
/********************************** *********************/
void supprimerElement(ID_REQUEST* liste, int valeur)
{
    /* Liste vide, il n'y a plus rien à supprimer */
    if(liste == NULL)
        return;
 
	  /* Si l'élément en cours de traitement doit être supprimé */
	  if(liste->val == valeur)
	  {
	      /* On le supprime en prenant soin de mémoriser 
	      l'adresse de l'élément suivant */
	      ID_REQUEST* tmp = liste->suivant;
	      free(liste);
	      /* L'élément ayant été supprimé, la liste commencera à l'élément suivant
	      pointant sur une liste qui ne contient plus aucun élément ayant la valeur recherchée */
	      supprimerElement(tmp, valeur);
 
	      return;
	  }
	  else
	  {
	      /* Si l'élement en cours de traitement ne doit pas être supprimé,
	      alors la liste finale commencera par cet élément et suivra une liste ne contenant
	      plus d'élément ayant la valeur recherchée */
	      supprimerElement(liste->suivant, valeur);
	      return;
	  }
 
}
/********************************** *********************/
void afficherListe(ID_REQUEST* liste)
{
    ID_REQUEST *tmp = liste;
    /* Tant que l'on n'est pas au bout de la liste */
    printf("\n ********************************** \n");
    while(tmp != NULL)
    {
        /* On affiche */
        printf("%d ", tmp->val);
        /* On avance d'une case */
        tmp = tmp->suivant;
    }
}
/********************************** *********************/
int main(){
    struct ID_REQUEST* liste = malloc(sizeof *liste);
    afficherListe(liste);
    ajouter(liste, 1);
    ajouter(liste, 3);
    afficherListe(liste);
    supprimerElement(liste,3);
    afficherListe(liste);
 
}

Merci pour votre aide.

[Climoo]

Je crois qu'il y a des gros soucis dans ton code, aussi bien dans l'ajout que dans la suppression... Je vais commenter ton code là ou je pense qu'il y a des trucs incorrects...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void ajouter(ID_REQUEST*liste, int valeur){
 
      struct ID_REQUEST* new = malloc(sizeof *new);
      if(new != NULL ) {
	new->val=valeur;
	new->suivant = NULL;
 
     }
     /*Et sinon, si erreur d'allocation, il ne faudrait pas inserer l'element !*/
 
     if (liste == NULL){ /*Si la liste est vide*/
	  liste = new; 
              /*tu changes le pointeur, mais a la sortie, il n'a pas change ! Il  s'agit d'un passage par valeur. De plus, vu ton main, tu ne passes jamais par ici.*/
 
      }
      else {/*Ajout en fin de liste apparemment, ok*/
	struct ID_REQUEST* temp=liste;
	while(temp->suivant != NULL){
	    temp = temp->suivant;
        }
	temp->suivant = new; /*ok*/
	return;
      }

Pour gerer l'insertion, tu pourrais faire en sorte que ta fonction retourne un pointeur sur la tete de ta liste. Comme ca tu pourrais gerer l'insertion du premier element sans te casser la tete...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void supprimerElement(ID_REQUEST* liste, int valeur)
{
    /* Liste vide, il n'y a plus rien à supprimer */
    if(liste == NULL)
        return;
 
	  /* Si l'élément en cours de traitement doit être supprimé */
	  if(liste->val == valeur)
	  {
	      /* On le supprime en prenant soin de mémoriser 
	      l'adresse de l'élément suivant */
	      ID_REQUEST* tmp = liste->suivant;
	      free(liste); /*Et le raccord ??? L'element precedent pointe sur une zone memoire qui a ete libérée !!*/
	      /* L'élément ayant été supprimé, la liste commencera à l'élément suivant
	      pointant sur une liste qui ne contient plus aucun élément ayant la valeur recherchée */
	      supprimerElement(tmp, valeur);
 
	      return;
	  }
	  else
	  {
	      /* Si l'élement en cours de traitement ne doit pas être supprimé,
	      alors la liste finale commencera par cet élément et suivra une liste ne contenant
	      plus d'élément ayant la valeur recherchée */
	      supprimerElement(liste->suivant, valeur);
	      return;
	  }
 
}

Ta fonction est incorrecte car tu ne raccordes pas les maillons. Il faut que l'élément précédent celui que tu supprimes ait pour nouveau successeur le successeur de l'élément à supprimer (à lire lentement^^).
Ecrire cette fonction en itératif est surement plus simple qu'en récursif...