***Université de Tunis El Manar***

***Faculté des Sciences de Tunis***

Correction TD4 ASD2 Niveau : LCS1

Les Listes chaînées Enseignante : N. Amdouni

Exercice 1 :

1. Définir une liste simplement chainée composée d’une valeur entière et d’un pointeur vers
l’élément suivant.
Type
Liste : ^Cellue
Cellule= Enregistrement
val :entier
suivant :Liste
Fin enregistrement

2. Déclarer une variable de ce type défini dans la question 1.

Var
Tête : Liste

3. Ecrire une procédure permettant de créer une liste simplement chainée de n entiers.
Procédure CréerListe ( VAR Tête :Liste, n : entier)
Var
NC,P :Liste
i :entier
Début
//Créer la tête
Allouer(NC)
Ecrire(« donner la valeur de la tête »)
Lire(NC^.val)
NC^.suivant Nil
Tête NC
//Créer le reste de la liste : ajouter élément par élément à la fin de la liste
P Tête
Pour i de 2 à n Faire
Allouer(NC)
Ecrire(« donner la valeur de l’élément,» i)

1/9
 Lire(NC^.val)
NC^.suivant Nil
P^.suivant NC
P P^.suivant //ou P NC
FinPour
Fin

4. Ecrire une fonction récursive booléenne qui permet de rechercher un élément x dans une liste
simplement chaînée.
Fonction Recherche_rec(x : entier , Tête : Liste) : booléen
Début
Si (Tête=Nil) Alors
Recherche_rec Faux
SinonSi (Tête^.val=x) Alors
Recherche_rec Vrai
Sinon
Recherche_rec Recherche_rec(x, Tête^.suivant)
FinSi
Fin

5. Ecrire une procédure Inverser qui permet d’inverser une liste simplement chaînée sur elle-même.
Procédure Inverser (VAR Tête : Liste)
VAR
P,Q : Liste
Début
Q Nil
P Tête
Tantque (P^.suivant < > NIL) Faire
Q P^.suivant / / Q pointe sur l’élément à déplacer
P^.suivant Q^.suivant //isoler l’élément à déplacer
Q^.suivant Tête //l’élément pointée par Q a été déplacé en tête
Tête Q //Mettre à jour la tête de liste
FinTantque
Fin

2/9
6. Ecrire une procédure Envers qui permet d’inverser une liste simplement chaînée L1 dans une
nouvelle liste simplement chaînée L2.
Procédure Envers ( L1, VAR L2 : Liste)
Var
NC :Liste
Début
L2 NIL
Tantque (L1< > NIL) Faire
Allouer(NC)
NC^.val L1^.val
NC^.suivant L2
L2 NC
L1 L1^.suivant
FinTantque
Fin

7. Ecrire une Procédure Affich_Envers qui permet d’afficher à l’envers une liste simplement
chaînée.

Procédure Affich_Envers(Tête :Liste)

Var
Tête2 : Liste
Début
Envers(Tête,Tête2)
Tantque (Tête2< > NIL) Faire
Ecrire(Tête2^ .val, « » )
Tête2 Tête2^.suivant
FinTantque
Fin

3/9
 8. Ecrire une procédure « Destruction » qui permet de vider une liste simplement chaînée.
Procédure Destruction (VAR Tête : Liste)
Var
AS : Liste
Début
Tantque (Tête < > NIL) Faire
AS Tête
Tête Tête^.suivant
Libérer (AS)
AS Nil
FinTantque
Fin

Exercice 2 :

1. Soit un produit commercial représenté de la façon suivante :

• CodePdt : entier
• NomPdt : chaîne de caractères
• Prix_unitaire : réel
• Quantité : entier
Définir une liste simplement chaînée ListePdt représentant un produit.
Type
ListePdt=^Produit
Produit=enregistrement
CodePdt : entier
NomPdt : chaîne [30]
PU: réel
Q : entier
Suivant : ListePdt
Fin enregistrement

2. Une commande est représentée par :

• un code (entier),
• le nom du client (chaîne de caractères),
• un ensemble de produits,
• un montant total à payer.

4/9
 Définir une liste simplement chaînée ListeCd représentant une commande.
Type
ListeCd=^Commande
Commande=enregistrement
Code : entier
NomCl : chaîne[30]
Pdts : ListePdt
Montant : réel
Suivant : ListeCd
Fin enregistrement

3. Définir les sous-programmes suivants :

• AjouterPdt permettant d’ajouter un produit à une liste simplement chaînée.
Procédure AjouterPdt (VAR TêtePdt : ListePdt)
Var
NP,P : ListePdt
Début
Allouer(NP)
Ecrire(« Saisir Code Pdt »)
Lire(NP^.CodePdt)
Ecrire(« Saisir Désignation du produit»)
Lire(NP^.NomPdt)
Répéter
Ecrire(« Saisir Prix unitaire»)
Lire(NP^.PU)
Jusqu’à (NP^.PU>0.0)
Répéter
Ecrire(« Saisir la quantité »)
Lire(NP^.Q)
Jusqu’à (NP^.Q>0)
NP^.Suivant Nil
Si TêtePdt= NIL Alors //Liste initialement vide
TêtePdt NP
Sinon //Liste non vide (on ajoute à la fin de la liste)
P TêtePdt
Tantque (P^.suivant < > NIL) Faire
P P^.suivant
FinTantque
P^.suivant NP

5/9
 FinSi
Fin

• ValeurCd permettant de retourner le montant total d’une commande.

Fonction ValeurCd(TêtePdt :ListePdt) :réel
Var
P :ListePdt
Début
P TêtePdt
ValeurCd 0.0
Tantque (P< > Nil) Faire
ValaurCd ValeurCd+(P^.PU*P^.Q)
P P^.suivant
FinTantque
Fin

• AjouterCd permettant d’ajouter une commande à une liste simplement chaînée.

Procédure AjouterCd (VAR TêteCd : ListeCd)

Var
P,NC :ListeCd
rep :caractère
Début
Allouer(NC)
Ecrire(« Saisir Code Commande »)
Lire(NC^.Code)
Ecrire(« Saisir Nom Client »)
Lire(NC^.NomCl)
NC^.Pdts NIL
Répéter
Ecrire(« Ajouter un pdt à votre commande »)
AjouterPdt( NC^.Pdts)
Répéter
Ecrire(« Voulez-vous ajouter un autre produit ? ‘o’ : oui, ‘n’ : non »)
Lire(rep)
Jusqu’à (rep==’o’ OU rep=’n’)
Jusqu’à (rep=’n’)

6/9
 NC^.Montant ValeurCd(NC^.Pdts)
NC^.suivant NIL
Si (TêteCd= NIL) Alors //Liste des commandes initialement vide
TêteCd NC
Sinon //Liste non vide : on ajoute la NC à la fin de la liste
P TêteCd
Tantque (P^.suivant < > NIL) Faire
P P^.suivant
FinTantque
P^.suivant NC
FinSi
Fin
• CréerListeCd permettant de créer N commandes
Procédure CréerListeCd (VAR TêteCd : ListeCd)
Var
i :entier
Début
TêteCd NIL
Répéter
Ecrire (« Saisir le nbre des commandes »)
Lire(N)
Jusqu’à (N>0)
Pour i de 1 à N faire
AjouterCd(TêteCd)
FinPour
Fin
• AfficherCd permettant d’afficher le code et le nom du client des commandes ayant un montant
> 500 Dt.
Procédure AfficheCd(TêteCd :ListeCd)
Var
i :entier
P : ListeCd
Début
P TêteCd
Tantque (P < > NIL) faire
Si (P^.Montant>500.0) Alors
Ecrire(P^.Code, P^.NomCl)

7/9
 FinSi
FinTantque
Fin

Exercice 3 :

Ecrire une procédure « Concat » qui permet de concaténer deux listes doublement chainées d’entiers
dans une troisième liste doublement chaînée.

Procédure Concat (T1,Q1,T2,Q2,VAR T3, VAR Q3 : ListeDC)

Var
Début
Si T1= NIL et T2=NIL Alors //Les 2 listes sont vides
T3 NIL
Q3 NIL
Sinon Si T1=NIL et T2 < > NIL Alors // Liste 1 vide et Liste 2 non vide
T3 T2
Q3 Q2
Sinon Si T1 < > NIL et T2=NIL Alors // Liste 1 non vide et Liste 2 vide
T3 T1
Q3 Q1

Sinon

T3 T1

Q3 Q1

Q3^.suivant T2

T2^.précédent Q3

Q3 Q2

FinSi

Fin

Exercice 4 :

Ecrire une procédure « TriBulles » qui permet de trier une liste doublement chaînée dans l’ordre
croissant en utilisant le tri à bulles.

8/9
Procédure Tri_Bulles (VAR Tête: ListeDC) Procédure Tri_Bulles_Tab (VAR T : Tab , N : entier)
Var Var
aux : entier i, aux : entier
P,Q :ListeDC permute: booléen
permute: booléen Début
Début Répéter
Répéter permute Faux
permute Faux Pour i de 1 à (N-1) Faire
P T Si(T[i] > T[i+1]) Alors /*on les permute*/
Q P^.suivant aux T[i]
T[i] T[i+1]
Tantque (Q < > NIL) Faire T[i+1] aux
Si(P^.val > Q^.val) Alors /*on les permute Vrai
permute*/ Fin Si
aux P^.val Fin Pour
P^.val Q^.val Jusqu'à (permute = Faux)
Q^.val aux Fin
permute Vrai
Fin Si
Fin Tantque
Jusqu'à (permute = Faux)
Fin

Exercice 5 :

Ecrire une fonction « Occurrence » qui calcule le nombre d’occurrence d’un entier x dans une liste
simplement chaînée circulaire.

Fnction Occurence (x :entier, Courant : Liste) :entier

Var
P : Liste
Début
Occurrence 0
Si (Courant < > NIL) Alors
P Courant
Répéter
Si (P^.val=x) Alors
Occurrence Occurrence+1
FinSi
P P^.suivant
Jusqu’à (P = Courant)
FinSi
Fin

9/9