Bonsoir

Voici un algo d'insertion ds une liste chaîné double :
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
 
/* Définition du type "liste doublement chaînée d'entiers"
 */
typedef struct liste *ptr_liste;
 
typedef struct liste {
  int info;
  ptr_liste suiv, prec;
} Liste;
 
 
void insere(ptr_liste *l, int aAjouter)
{
  // Itérateur sur la liste
  ptr_liste courant;
  // Pointeur sur le nouveau chaînon
  ptr_liste nouveau ;
 
  // De toute manière, il faudra bien l'allouer ce chaînon!
  nouveau = malloc(sizeof(Liste));
  nouveau->info = aAjouter;
 
  // Le cas où *l est vide est équivalent au cas où il faut ajouter
  // le nouveau maillon en début de liste
  if (*l == NULL || (*l)->info > aAjouter) {
    // Le nouveau est le premier de la liste
    nouveau->prec = NULL;
    nouveau->suiv = *l;
 
    // Seule différence: le chaînage de l'ancien premier doit être modifié
    // s'il existe!
    if (*l != NULL)
      (*l)->prec = nouveau;
 
    // Le début de la liste (paramètre E/S) est modifié
    *l = nouveau;
  }
  else {
    // Dans les autres cas, il faut trouver où insérer le chaînon
    // On s'arrête sur celui qui doit être juste à droite du nouveau
    // chaînon (éventuellement le dernier de la liste)
    courant = *l;
    while (courant->suiv != NULL && courant->suiv->info < aAjouter) {
      courant = courant->suiv;
    }
 
    // Le chaînage du nouveau maillon est mis-à-jour
    nouveau->suiv = courant->suiv;
    nouveau->prec = courant;
    // est-on à la fin? si non, le nouveau est le précédent d'un maillon
    if (courant->suiv != NULL) {
      courant->suiv->prec = nouveau;
    }
 
    // Dans tous les cas, c'est le suivant du chaînon courant
    courant->suiv = nouveau;
  }
}
Une chose me turlupine... Pourquoi est-ce de partout *l qui est écrit ? Par exemple :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
  if (*l == NULL || (*l)->info > aAjouter)
Personnellement, et je sais que c'est faux, j'aurais écrit l tout court... Le pointeur pointe sur NULL.

En fait là, l est un pointeur sur une liste ? *l correspond à quoi ?

J'aurais fait ainsi moi :
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
 
/* Définition du type "liste doublement chaînée d'entiers"
 */
typedef struct liste {
  int info;
  liste *suiv, *prec;
} Liste;
 
 
void insere(liste *l, int aAjouter)
{
 
  liste *courant;
 
  liste *nouveau ;
 
 nouveau = malloc(sizeof(Liste));
 
 nouveau->info = aAjouter;
 
 if (l == NULL || l->info > aAjouter) { /*si || est un "ou alors" */
 
    nouveau->prec = NULL;
    nouveau->suiv = l;
 
    if (l != NULL)
      l->prec = nouveau;
 
    l = nouveau;
  }
  else {
    courant = l;
    while (courant->suiv != NULL && courant->suiv->info < aAjouter) {
      courant = courant->suiv;
    }
 
    nouveau->suiv = courant->suiv;
    nouveau->prec = courant;
 
    if (courant->suiv != NULL) {
      courant->suiv->prec = nouveau;
    }
 
 
    courant->suiv = nouveau;
  }
}
Ce n'est pas juste j'imagine^^