Faculté des Sciences de Tunis Département des Sciences de l’Informatique

TD ASD2
Corrigé - Révision liste chainée
Module : ASD II Section : LCE1 / LCS1
Enseignante : FAYECH Ines & SALHI Hajer AU : 2021-2022

Exercice 1

Soit L une liste chainée double d´entiers initialement vide.

1. Écrire une procédure qui accepte une suite d´entiers différents de -1 et les chargent dans la
liste chaînée L dans l´ordre inverse de leur introduction.
LISTE_INT = ^ Noeud
Nœud = Enregistrement
Val : entier
suiv : LISTE_INT
prec : LISTE_INT
Fin Enregistrement

Inversion de l’ordre des entiers ➔ Insertion au début

Procédure Charger_1 (var L : LISTE_INT) Ou bien

Variables p : LISTE_INT
x : entier Procédure Charger_1 (var L : LISTE_INT)
Début Variables p : LISTE_INT
L NIL x : entier
Ecrire (‘‘Donner la liste d’entiers’’) Début
Lire (x) L  NIL
Si x <> -1 alors Ecrire (‘‘Donner la liste d’entiers’’)
Créer (p) Lire (x)
p^.Val  x Tant que ( x ≠ −1) ) faire
p^.suiv  NIL Créer (p)
p^.prec  NIL p^.Val  x
Lp p^.suiv  L
Lire (x) p^.prec  NIL
Tant que ( x ≠ −1) ) faire si L ≠ NIL alors
Créer (p) L^.prec  p
p^.Val  x Finsi
p^.suiv  L L p
p^.prec  NIL Lire (x)
L^.prec  p Fin tantque
L p FIN
Lire (x)
Fin tantque
Finsi
FIN

-1-
2. Écrire une procédure qui accepte une suite d´entiers différents de -1 et les chargent dans la
liste chaînée L dans le même ordre de leur introduction.

Procédure Charger_2 (var L : LISTE_INT)

Variables p, q : LISTE_INT
Début
Ecrire (‘‘Donner la liste d’entiers se terminant par -1’’)
Lire (x)
Si (x ≠-1) alors // insertion du premier élément de la liste chainée
Créer (p)
p^.Val  x
p^.suiv NIL
p^.prec  NIL
Lp
qL
Lire (x)
Tant que ( x ≠ −1) ) faire
Créer (p)
p^.Val  x
p^.suiv NIL
p^.prec  q
q^.suiv  p
q q^.suiv
Lire (x)
Fin tantque
Fin Si
FIN
3. Ecrire une procédure qui permet de supprimer un entier x dans une liste chainée double
d’entiers.

Procédure Supprimer (var L : LISTE_INT, x : entier)

Variables p, q : LISTE_INT
Début
pL
Tantque p <> NIL et p^.Val <> x faire
pp^.suiv
Fin tantque
Si p <> NIL alors // au début
Si p = L alors
LL^.suiv
Si L <> NIL alors
L^.prec  NIL
Finsi
Sinon Si p^.suiv <> NIL alors // au milieu
(P^.suiv)^.prec  p^.prec
(P^.prec)^.suiv  p^.suiv
Sinon // à la fin
(P^.prec)^.suiv  NIL
Finsi
Finsi
Liberer (p)
Finsi
FIN
-2-
4. Ecrire une procédure Afficher(L) qui affiche les éléments d´une liste d´entiers L.

Procédure Afficher (L : LISTE_INT)

Variables p, q : LISTE_INT
Début
pL
Tantque p <> NIL faire
Ecrire (p^.Val)
pp^.suiv
Fin tantque
FIN
5. Ecrire un algorithme qui accepte une suite d´entiers différents de -1 et les charge dans une
liste d´entiers L dans l´ordre inverse de leur introduction et affiche les valeurs de la liste.

Algorithme (L : LISTE_INT)
Variables L : LISTE_INT
Début
Charger_1 (L)
Afficher (L)
FIN
Exercice 2
LISTE_INT = ^ Noeud
Nœud = Enregistrement
Val : entier
suiv : LISTE_INT
prec : LISTE_INT
Fin Enreg

Ecrire les procédures suivantes :

1. Ajout d´un élément au début d´une liste doublement chainée circulaire.
Ajout_D (var L : LISTE_INT, x :entier)
VAR p : LISTE_INT
Début
Créer (p)
p^.Val  x
Si L<> NIL alors
P^.suiv  L
P^.prec  L^.prec
L^.prec  p
(p^.prec)^.suiv p
Lp
Sinon
P^.suiv  p
P^.prec p
Lp
Finsi
FIN

-3-
2. Ajout d´un élément á la fin d´une liste doublement chainée circulaire.
Ajout_F(var L : LISTE_INT, x :entier)
Var p : LISTE_INT
Début
Créer(p)
P^.val  x
Si L = NIL alors
P^.suiv  p
P^.prec p
Lp
Sinon
P^.suiv  L
P^.prec  L^.prec
(P^.prec)^.suiv  p
L^.prec p
Finsi
FIN
3. Suppression du premier élément dans une liste doublement chainée circulaire.
Supprimer_D (var L : LISTE_INT)
Var
Début
Si L^.suiv = L alors
Liberer (L)
LNIL
Sinon
(L^.suiv)^.prec  L^.prec
(L^.prec)^.suiv  L^.suiv
PL
LL^.suiv
Liberer (p)
Finsi
FIN
4. Suppression du dernier élément dans une liste doublement chainée circulaire.
Supprimer_D (var L : LISTE_INT)
Var
Début
Si L^.prec = L alors
Liberer (L)
LNIL
Sinon
P L^.prec
L^.prec  p^.prec
(P^.prec)^.suiv L
Liberer (p)
Finsi
FIN

-4-
Exercice 3
Soit une liste chainée double circulaire initialement vide.
Ecrire les procédures suivantes :

1. Charger des éléments saisis terminant par -1 dans la liste tel sorte que la liste soit triée.
Ajout_triée(var L : LISTE_INT, x :entier)
Var p,q : LISTE_INT
Début
Créer(p)
P^.val  x

Si L = NIL alors
P^.suiv  p
P^.prec p
Lp
Sinon
qL
Tantque q^.suiv <>L et q^.val <x faire
q q^.suiv
Fin tantque
P^.suiv q
P^.prec q^.prec
(q^.prec)^.suiv  p
q^.prec  p
Si q = L
Lp
Finsi
Finsi
FIN

2. Charger des éléments saisis terminant par -1 dans la liste tel sorte que la liste soit triée.

Charger_Liste(var L : LISTE-INT)
VAR
Début
Lire (x)
Tantque (x<> -1) faire
Ajout_triée (L, x)
Lire(x)
Fintantque
FIN

-5-
3. Recherche d’un élément x dans une liste doublement chainée circulaire.
Fonction Recherche (L : LISTE-INT, x :entier) : LISTE-INT
VAR
Début
PL
Si ( L<> NIL et (L^.val <= x et (L^.prec)^.val >= x) ) alors
Tantque (p^.suiv <> L et p^.val <> x) faire
P p^.suiv
Fintantque
Si p^.val = x alors
Recherche p
Sinon
Recherche NIL
Finsi
Sinon
Recherche NIL
Finsi
FIN
4. Suppression de l’élément x dans une liste doublement chainée circulaire triée.
Supprimer_X (L : LISTE-INT, x :entier)
VAR
Début
p  Recherche (L, x)
Si p <> NIL alors
Si p = L alors // p est le premier élément
Si p^.suiv = L alors // L contient un seul élément
Liberer (L)
LNIL
Sinon
(L^.suiv)^.prec  L^.prec
(L^.prec)^.suiv  L^.suiv
pL
LL^.suiv
Liberer (p)
Finsi
Sinon Si p^.suiv = L alors // p est le dernier élément
p L^.prec
L^.prec  p^.prec
(p^.prec)^.suiv L
Liberer (p)
Sinon // p est au milieu (entre 2 éléments)
(p^.suiv)^.prec  p^.prec
(p^.prec)^.suiv  p^.suiv
Liberer (p)
Finsi
Finsi
FinSi
FIN

-6-
Exercice 4

On souhaite faire une étude sur des villes, les informations qu’on dispose sur chacune des
villes sont :
- le nom d’une ville (chaine de caractères)
- la région correspondante (chaine de caractères)
- le pays correspondant (chaine de caractères)
- le nombre d’habitants (entier)

On souhaite charger les informations dans une liste chaînée et appliquer quelques traitements.
1. Définir le type VILLE (pour les données d’une ville) et le type LISTE_VILLE de la liste
des villes.
VILLE = enregistrement
Nom : cc
Région : cc
Pays : cc
Nb : entier
Suiv : ^VILLE
Fin enreg
LISTE_VILLE = ^VILLE

2. Ecrire la procédure/fonction insere_ville(…..) qui insère une ville dans la liste chaînée
Insere_ville_F ( var L :LISTE_VILLE, v : VILLE)
Var
Début
Créer(p)
P^v
P^.suiv NIL
Si L= NIL alors
Lp
Sinon
Q L
Tantque q^.suiv <> NIL faire
Q q^.suiv
Fintq
Q^.suiv p
Fin si
FIN
Insere_ville_D (var L : LISTE_VILLE, v : VILLE)
Var
Début
Créer(p)
P^v
P^.suiv  L
Lp
FIN

-7-
3. Ecrire la procédure/fonction supprime_ville(…..) qui supprime une ville de la liste chaînée
Supprime_ville (var L : LISTE_INT, Nom : cc)
Var
Début
P L ; pred NIL
Tantque p <> NIL et p^.Nom <> Nom faire
Pred p
p p^.suiv
Fintq
Si p<>NIL
SI p=L alors
L L^.suiv
Liberer (p)
Sinon
Pred^.suiv  p^.suiv
Liberer (p)
Finsi
Fin si
FIN

4. Ecrire la procédure/fonction charger_ville(…..) qui charge les informations dans une liste
chaînée.
Remarque : La valeur de retour de la fonction est un pointeur sur le premier élément de
la liste.
Fontion Charger_ville () : LISTE_VILLE
Var L : LISTE_VILLE
V : VILLE
Début
L NIL
Lire (Nom)
Tantque ( Nom <> ‘ ‘)
v.Nom  Nom
Lire ( v.Région, v.pays, v.Nb)
Insere_ville_F (L , v)
Lire (Nom)
Fintq
Charger_ville  L
Fin

5. Ecrire une procédure/fonction itérative puis récursive affiche_villes_pays(…..) qui affiche

toutes les villes d’un pays donné.
Afficher-Iter (L : LISTE_VILLE, pays : cc)
-8-
VAR
Début
PL
Tantque p <> NIL
Si p^.pays = pays alors
Ecrire (p^.Nom)
FinSI
Pp^.suiv
Fintantque
FIN

Afficher-Rec (L : LISTE_VILLE, pays : cc)

VAR
Début
Si L<> NIL
Si L^.pays = pays alors
Ecrire (L^.Nom)
FinSI
Afficher-Rec (L^.suiv , pays)
Finsi
FIN

6. Ecrire une fonction itérative puis récursive nombre_habitant(…..) qui retourne le nombre
d’habitants pour une région d’un pays donné.
Fonction Nombre_habitant-Iter (L : LISTE_VILLE, pays : cc, region : cc) : entier
VAR
Début
PL
S0
Tantque p<> NIL
Si p^.pays = pays et p^.region = region alors
S  S+ p^.Nb
FinSI
Pp^.suiv
Fintantque
Nombre_habitant-Iter  S
FIN
Fonction Nombre_habitant-rec (L : LISTE_VILLE, pays : cc, region : cc) : entier
VAR
Début
Si L <> NIL
Si L^.pays = pays et L^.region = region alors
Nombre_habitant-rec  L^.Nb + Nombre_habitant-rec (L^.suiv, pays , region)
Sinon
Nombre_habitant-rec  Nombre_habitant-rec (L^.suiv, pays , region)
FinSi
Sinon
Nombre_habitant-rec  0
FinSI
FIN

-9-