Les listes chaînées

 Récupérer l’adresse du dernier élément d’une liste

 Ecrire la fonction Dernier qui renvoie l’adresse du dernier
élément d’une liste donnée par l’adresse de son premier élément
(premier).

 Principe
 Le dernier élément de la liste s’il existe est un maillon qui ne
possède pas de suivant.
 On fait le parcours de liste du premier élément jusqu’à trouver
un maillon dont le suivant vaut Nil.
 L’adresse de ce maillon est renvoyée par la fonction.
Les listes chaînées
 Algorithmique
Fonction Dernier( premier : ^liste) : ^liste
Debut
Tantque(premier <>Nil et premier ^.suivant<>Nil) faire
premier ← premier ^.suivant
FinTantque
Retourner premier
Fin
Les listes chaînées
 Insertion d’une valeur en queue d’une liste
 Ecrire la procédure InsertQueue qui permet d’insérer une valeur
val dans une liste chaînée donnée par l’adresse de son premier
élément (premier).
 Après l’insertion la valeur du premier peut changer (dans le cas
où la liste est vide) donc le passage doit se faire par adresse.
Les listes chaînées
 Principe : Deux cas
Si la liste est vide l’insertion en queue est une insertion en tête.
si(premier =Nil) alors
InsertTete(premier,val)
Sinon
 Créer un maillon d’adresse nouvElt contenant la valeur val et dont l’élément
suivant est Nil
nouvElt ← nouveau(^liste)
nouvElt ^.valeur ← val
nouvElt ^.suivant ← Nil
 Récupérer l’adresse du dernier maillon (Der) et nouvElt devient le suivant de Der
Der ← Dernier(premier)
Der^.suivant ← nouvElt
Finsi
Les listes chaînées
 Algorithmique
PROCEDURE InsertQueue(var premier : ^liste, val : entier)
var
nouvElt,Der: ^liste
Début
si(premier=Nil) alors
InsertTete(premier,val)
Sinon
nouvElt ← nouveau(^liste)
nouvElt ^.valeur ← val
nouvElt ^.suivant ← Nil // il sera le dernier
Der ← Dernier(premier)
Der^.suivant ← nouvElt
Finsi
Fin
Les listes chaînées
 Longueur d’une liste
 Écrire la fonction LongListe qui permet de renvoyer le
nombre d’éléments d’une liste chaînée donnée par l’adresse
de son premier élément (premier).
 La fonction renvoie 0 si la liste est vide.
 Principe
 On fait le parcours de la liste du premier élément jusqu’au
dernier en incrémentant un compteur de 1 à chaque passage d’un
maillon à son suivant.
 La valeur de ce compteur au départ vaut 0
Les listes chaînées
Algorithmique
FONCTION LongListe(premier : ^liste) : entier
var
L : entier
Début
L←0
Tantque(premier <>Nil) faire
L ← L+1;
premier ← premier ^.suivant;
FinTantque
Retourner L;
Fin
Les listes chaînées
 En C
int LongListe(liste*premier){
int L=0;
while(premier!=NULL){
L++;
premier=premier->suivant;
}
return L;
}
Les listes chaînées
 Exercices
 Ecrire une fonction récursive Longueur qui retourne le
nombre d’éléments d’une liste chaînée donnée en
paramètre.
 Ecrire une fonction récursive qui retourne le membre à la
ième position dans une liste chaînée, la liste et la position
sont données en paramètre.
Les listes chaînées
 Insertion d’une valeur à une position k dans une liste
 Écrire la procédure Insertk qui permet d’insérer une valeur val à
une position k dans une liste chaînée donnée par l’adresse de son
premier élément (premier).
 La valeur val aura le rang k+1 dans la liste après l’insertion.
Les listes chaînées
 Principe
Si (k =0) alors //Si k=0 l’insertion se fait en tête de la liste.
InsertTete(premier,val)
Sinon
Si (k>LongListe(premier)) alors
écrire("la position k=" ,k, " n'existe pas car la liste est de taille",LongListe(premier))
Sinon
Pour i de 1 à k-1 faire // Récupérer l’adresse du maillon qui se trouve à la position k
(pk) .
pk ← pk^.suivant;
Finpour
// Créer un maillon d’adresse nouvElt contenant la valeur val et dont l’élément suivant
est le suivant de pk
nouvElt ← nouveau(^liste)
nouvElt ^.valeur ← val
nouvElt^.suivant ← pk^.suivant // Le suivant de nouvElt est le suivant de pk.
pk^.suivant ← nouvElt // Le suivant de pk devient nouvElt.
Finsi
Finsi
Les listes chaînées
PROCEDURE Insertk(var premier : ^liste , k: entier,val: entier)
var
nouvElt,pk : ^liste
i: entier
Début
Si (k =0) alors
InsertTete(premier,val)
Sinon
Si (k>LongListe(premier)) alors
écrire("la position k=" ,k, " n'existe pas car la liste est de taille",LongListe(premier))
Sinon
pk ← premier
Pour i de 1 à k-1 faire
pk ← pk^.suivant
Finpour
nouvElt ← nouveau(^liste)
nouvElt^.valeur ← val
nouvElt^.suivant ← pk^.suivant
pk^.suivant ← nouvElt
Finsi
Finsi
Fin
Les listes chaînées
 En C
liste* InsertK (liste*premier,int k,int val){
liste *nouvElt,*EltK;
int i;
if(k==0)
premier=InsertTete(premier,val);
else{
if (k>LongListe(premier))
printf("Insertion impossible");
else{
EltK=premier;
for(i=1;i<k;i++)
EltK=EltK->suivant;
nouvElt=(liste*)malloc(sizeof(liste));
nouvElt->valeur=val;
nouvElt->suivant=EltK->suivant;
EltK->suivant=nouvElt;
}
}
return premier;
}
Les listes chaînées
 Suppression du premier maillon d’une liste
 Écrire la procédure SuppTete qui permet de supprimer le premier
maillon d’une liste chaînée donnée par l’adresse de son premier
élément (premier).
Les listes chaînées
 Principe
//Si la liste est non vide : on sauvegarde premier dans une variable p.
Si (premier ≠ Nil) alors
p ← premier
// La valeur de premier prend la valeur de son suivant.
premier ← premier^.suivant
// On libère la zone mémoire d’adresse p.
liberer(p)
Finsi
Les listes chaînées
 Algorithmique
PROCEDURE SuppTete(var premier : ^liste)
var
p : ^Liste
Début
Si (premier <> Nil) alors
p ← premier
premier ← premier ^.suivant
liberer(p)
Finsi
Fin
Les listes chaînées
 En C
liste* SuppTete(liste *premier){
liste *p;
if (premier!=NULL){
p=premier;
premier=premier->suivant;
free(p);
}
return premier;
}
Les listes chaînées
 Suppression du dernier maillon d’une liste
 Écrire la procédure SuppQueue qui permet de supprimer le
dernier maillon d’une liste chaînée donnée par l’adresse de son
premier élément (premier).
 Notons qu’après la suppression la valeur du premier peut changer
Les listes chaînées
 Principe
Si (premier ≠ Nil) alors //Si la liste est non vide
//Si la liste contient un seul élément, la suppression se fait en tête de la liste
Si (LongListe(premier)=1) alors
SuppTete(premier)
Sinon // Sinon, On récupère l’adresse de l’avant dernier élément (AvDer)
AvDer ← premier
Tantque(AvDer ^.suivant^.suivant<>Nil) faire
AvDer ← AvDer ^.suivant
FinTantque
// On sauvegarde l’adresse du dernier élément dans une variable p.
p ← AvDer ^.suivant
AvDer^.suivant ← Nil // L’élément d’adresse AvDer devient le dernier élément.
liberer(p) // on libère la zone mémoire d’adresse p.
Finsi
Finsi
Les listes chaînées
 Algorithmique
PROCEDURE SuppFin( var premier : ^liste)
var
AvDer,p : ^liste
Début
Si (premier <> Nil) alors
Si (LongListe(premier)=1)
SuppTete(p)
Sinon
AvDer ← premier
Tantque(AvDer ^.suivant^.suivant<>Nil) faire
AvDer ← AvDer ^.suivant
Fintantque
p ← AvDer ^.suivant
AvDer ^.suivant ← Nil
liberer(p)
Finsi
Finsi
Fin
Les listes chaînées
 En C
liste* SuppFin(liste *premier){
liste *p,*AvDer;
if (premier !=NULL){
if (LongListe(premier)==1){
SuppTete(premier);
}else{
AvDer=premier;
while(AvDer->suivant->suivant!=NULL)
AvDer=AvDer->suivant;
p=AvDer->suivant;
AvDer->suivant=NULL;
free(p);
}
}
Return premier;
}
Les listes chaînées
 Suppression de tous les maillons d’une liste
 Écrire la procédure SuppListe qui permet de supprimer tous les
éléments d’une liste chaînée donnée par l’adresse de son premier
élément (premier).
 Après la suppression la valeur du premier vaudra nil.
 Algorithmique
PROCEDURE SuppListe(var premier: ^liste)
Début En C
Tantque(premier<>Nil)faireliste* SuppListe(liste *premier){
while(premier!=NULL){
SuppTete(premier) premier=SuppTete(premier);
}
fintantque
return premier;
fin }
Les listes chaînées
 Exercice :
Utilisez les fonctions et procédures vues précédemment dans
le cours pour écrire une fonction C qui prend en entrée une
liste chaînée d'entiers et qui ressort deux listes chaînées :
 une pour les nombres pairs
 et une autre pour les nombres impairs.
 la liste initiale est détruite.
 tester dans un programme en affichant la liste des nombres pairs et
celle des nombre impairs ainsi que leur nombres.