Révision sur les listes

1. M. ZAIR
Exercices de
révision sur les
listes

2. 1) (3,5pts)
Etant donnée une liste non vide L.
Ecrire une fonction qui calcule le plus grand écart entre deux
valeurs dans L.
Fonction PGE (L : Liste) : entier ; 0,5pt
Variable p : Liste; min, max : entier ;
Début
pL ; maxVal(L); minVal(L); 0,75pt
tant que (p<>Nil) faire
si(Val(p)> max) alors max Val(p); finsi ;
si(Val(p)< min) alors min Val(p);finsi ; 2pts
pSuiv(p);
Fait;
Retourner(max-min); 0,25pt
Fin 2
Révision sur les listes

3. 2) (3pts)
Etant donnée une liste non vide L, et un nombre entier v.
Ecrire une fonction qui calcule le nombre d’occurrence de
v dans la liste L.
Fonction OCC (L : Liste, v : entier) : entier ; 0,75pt
Variable p : Liste; min, max : entier ;
Début
pL ; cpt0 ; 0,5pt
tant que (p<>Nil) faire
si(Val(p)= v) alors cptcpt+1; finsi ;
p Suiv(p) ; 1,5pt
Fait;
Retourner(cpt) ; 0,25pt
Fin 3
Révision sur les listes

4. 3) (0,5+1,5+1,5=3,5pts)
Soit une liste L, écrire un traitement qui permet de
soustraire 1 à tous les éléments de rang impair,
puis d’ajouter 1 à tous les éléments pairs.
i1; pL;
tantque (p<>Nil) faire
si(i mod 2<>0) alors Aff_Val(p, Val(p)-1); finsi ;
si(Val(p) mod 2=0) alors Aff_Val(p, Val(p)+1); finsi;
ii+1; p Suiv(p);
fait ;
4
Révision sur les listes

5. 5
Rangs des éléments d’une liste
Afficher les éléments de rang pair d’une liste L.
p  Suiv(L) ;
Tant que(p<>NIL) faire
Ecrire(Val(p));
p  Suiv(p);
Si (p <>NIL) alors pSuiv(p); finsi;
fait ;
p  Suiv(L) ;
Tant que(p<>NIL) faire
Ecrire(Val(p));
p  Suiv(p); p  Suiv(p);
{ou alors : p  Suiv(Suiv(p));}
fait ;
p  L ;
Tant que(p<>NIL) faire
Si(p mod 2 = 0) alors Ecrire(Val(p)); finsi;
p  Suiv(p);
fait ;
p  L ; i  1 ;
Tant que(p<>NIL) faire
Si(i mod 2 = 0) alors Ecrire(Val(p)); finsi;
p  Suiv(p); i  i+1 ;
fait ;
Fausse
Fausse Correcte
Correcte

6. 6
Exercice X
4) Afficher les valeurs de tous les éléments sauf
le premier et le dernier :
PSuiv(L);
Tant que(Suiv(P)<>Nil) faire
Ecrire(Val(P)); PSuiv(P);
fait;
5 0 3
L P P
Arrêt :
Suiv(P)=Nil
-1
P

7. 5) (0,5+1+1=2,5pts)
Soit une liste non vide L. Ecrire un
traitement qui permet de la rendre une
liste circulaire en reliant le dernier élément
avec le premier élément.
pL;
tant que(Suiv(p)<>Nil) faire
pSuiv(p);
Fait;
Aff_Suiv(p, L); 7
Révision sur les listes

8. 6) (0,75+1,5+0,75=3pts)
Ecrire un traitement qui permet de calculer la moyenne des
éléments d’une liste circulaire.
8
Révision sur les listes
sVal(L); cpt1; pSuiv(L); {0,75pt}
tantque (p<>L) faire
cptcpt+1; ss + Val(p); p Suiv(p); {1,5pt}
fait ;
moys/cpt; {0,75pt}
s0; cpt0; pL; {0,75pt}
Répéter
ss + Val(p); cptcpt+1; p Suiv(p); {1,5pt}
Jusqu’à (p=L);
moys/cpt; {0,75pt}
s0; cpt0; pL; {0,75pt}
tantque (Suiv(p)<>L) faire
cptcpt+1; ss + Val(p); p Suiv(p); {1,5pt}
fait ;
moy  (s+Val(p)) / (cpt+1); {0,75pt}

9. 7) (3pts)
Effectuer une rotation à gauche dans une liste non vide L.
Exemple : 𝟓 → 𝟕 → 𝟎 → 𝟏 devient 𝟕 → 𝟎 → 𝟏 → 𝟓
{Méthode 1 : avec modification des valeurs. Principe : on met la
valeur du 1er maillon dans x, puis on décale à gauche les valeurs de
tous les éléments (du 2ème au dernier), puis on met x dans le dernier}
x Val(L);
qL; p Suiv(L);
tant que (p<>Nil) faire
Aff_Val(q, Val(p)); qp; pSuiv(p);
fait;
Aff_Val(q, x); 9
Révision sur les listes
5 0 1
L
7
x=5
5 0 1
L q p
7
q p
q p
7 0 1 5
q p=Nil

10. {Méthode 2 : avec modification des chainages. Principe : Mettre le
premier élément à la fin de la liste, ainsi le 2ème maillon devient le
premier maillon dans la liste}
{placer q sur le deuxième maillon} qSuiv(L);
{placer p sur le dernier maillon}
pL; tant que (Suiv(p)<>Nil) faire pSuiv(p); fait;
{Relier le dernier(p) avec le premier(L)} Aff_Suiv(p, L);
{Casser le chainage entre le premier (L) avec le deuxième (q)}
Aff_Suiv(L, Nil);
{Placer L avec q}
Lq; 10
Révision sur les listes
5 0 1
L
7
5 0 1
L p
7
q p p
p
L

11. 8) (4pts)
Effectuer une rotation à droite dans une liste non vide L.
Exemple : 𝟓 → 𝟕 → 𝟎 → 𝟏 devient 𝟏 → 𝟓 → 𝟕 → 𝟎
{Méthode 1 : Avec modification des valeurs. Principe : on
permute entre le 1er et le 2ème, ensuite entre le 1er et le 3ème,
ensuite entre le 1er et le 4ème, …}
p Suiv(L);
Tant que(p<>Nil) faire
x Val(L); Aff_Val(L, Val(p)); Aff_Val(p, x);
p Suiv(p);
Fait; 11
Révision sur les listes
5 0 1
L p
7
p p
7 5 7 0
5 0 1
L
7
x=5 x=7 x=0 p=Nil
0
1

12. {Méthode 2 : avec modification des chainages. Principe : Mettre le
dernier élément au début de la liste, ainsi l’avant dernier maillon
devient le dernier maillon dans la liste}
{placer p sur le dernier maillon et q sur l’avant dernier}
pL; tant que (Suiv(p)<>Nil) faire qp; pSuiv(p); fait;
{Relier le dernier(p) avec le premier(L)} Aff_Suiv(p, L);
{Casser le chainage entre l’avant dernier (q) avec le dernier (p)}
Aff_Suiv(q, Nil);
{Placer L avec p}
Lp; 12
Révision sur les listes
5 0 1
L p
7
p p
5 0 1
L
7
q p q q L

13. 9) (5,5pts)
Etant donnée une liste non vide L1
contenant que des 0 et des 1.
Ecrire une procédure qui construit
une liste L2 qui représente le
complément de 1 de la liste L1 (le 0
devient 1 et le 1 devient 0).
13
Révision sur les listes

14. 9) Procédure Complément_à_1 (L1 : Liste, var L2 : Liste); {1pt}
Variable p1, p2, q2 : Liste;
Début
p1  L1; L2 Nil; {0,5pt}
tant que (p1<>Nil) faire
p2Allouer();
Si (Val(p1)=0) alors Aff_Val(p2, 1);
Sinon Aff_Val(p2, 0);
Finsi; {ou alors : } Aff_Val(p2, 1- Val(p1));
si(L2=Nil) alors L2  p2; q2  p2; {3,5pt}
sinon Aff_Suiv(q2, p2); q2  p2;
finsi;
p1  Suiv(p1);
fait;
Si(L2˂˃Nil) alors Aff_Suiv(p2, Nil); finsi; {0,5pt}
Fin 14
Révision sur les listes

15. 10) (1+5=6pts)
Etant donnée une liste non vide L.
Ecrire une procédure ‘Inverse’ qui inverse la liste L.
Procédure Inverse (var L : Liste);
Variable Q, P : Liste;
Début
Fin 15
Révision sur les listes
Q Suiv(L);
Aff_Suiv(L, Nil);
Tantque(Q < > Nil) faire
P Suiv(Q);
Aff_Suiv(Q, L);
LQ;
QP;
Fait;
QNil; P Suiv(L);
Tantque(P < > Nil) faire
Aff_Suiv(L, Q);
QL;
L P;
P Suiv(P);
Fait ;
Aff_Suiv(L, Q);

16. 16
Révision sur les listes
qNil; p Suiv(L); {𝒒 → 𝑳 → 𝒑}
Tant que (p < > Nil) faire
Aff_Suiv(L, q);
qL; L p p Suiv(p);
Fait ;
Aff_Suiv(L, q);
5 0 1
L q p
7
q p
q p p=Nil
5 0
7
P A F
q=Nil
L L L
1
P A F

17. Exercice Interrogation Mai 2019 : (12,5 pts)
1) (1,5pt)
Définir les structures de données d’une liste d’entiers tel
que vous l’avez vue en cours.
Algorithme exo1;
Type Maillon= structure
Val : entier; {1pt}
Suiv : pointeur Maillon;
Fin ;
Liste = pointeur Maillon; {0,5pt}
Variable p, q, L : Liste; n, i : entier;
17
Révision sur les listes

18. 2) (4,5pts)
Ecrire une fonction qui vérifie si un
nombre entier donné x>1 est premier
ou non. (Un nombre x est premier s’il
accepte exactement 2 diviseurs.
~~Prévoir une solution optimale si
possible~~
18
Révision sur les listes

19. Fonction Premier (x : entier) : booléen; {1pt}
Variable i, cpt : entier; pr : booléen;
Début
{solution non optimale}
cpt  0; {0,5pt}
pour i  1 à x pas 1 faire
si(x mod i =0) alors
cpt  cpt+1; {1,5pt}
Finsi ;
fait ;
si (cpt=2) alors retourner(vrai);
sinon retourner(faux); {0,5pt}
finsi ; 19
Révision sur les listes

20. {solution optimale}
pr  vrai; {0,5pt} i  2;
tant que (i<=x div 2) et (pr=vrai) faire
si(x mod i =0) alors
pr  faux;
sinon i  i+1; {2,5pts}
Finsi;
Fait;
retourner(pr); {0,5pt}
Fin
20
Révision sur les listes

21. 3) Ecrire un algorithme qui :
a. (0,5pt)
Lit un nombre entier n >1.
b. (5pts)
Utilise la fonction précédente pour créer une liste
L contenant tous les nombres premiers positifs
qui sont inférieurs ou égal n.
Exemple : si n=10 alors la liste va être :
21
Révision sur les listes

22. DEBUT
Répéter
Ecrire(“Donner n>1“); lire(n); {0,5pt}
jusqu’à(n>1);
LNil; {0,5pt}
pour i  2 à n pas 1 faire
si(Premier(i)) alors
pAllouer(); Aff_Val(p, i);
Si(L=Nil) alors L  p; q  p; {4pts}
Sinon Aff_Suiv(q, p); q  p;
Finsi;
Finsi;
Fait;
Aff_Suiv(p, Nil); {0,5pt}
22
Révision sur les listes

23. c. (1pt)
Affiche la liste L.
p  L;
tant que (p<>Nil) faire
Ecrire(Val(p)); {1pt}
p  Suiv(p);
fait;
FIN
23
Révision sur les listes

24. 24
Le Beurre de cette séance : (‫)فوائد‬
1) Refaite l’exercice 1, la maitrise du modèle
doit être à 100%
2) Il ne faut surtout pas oublier d’avancer le
pointeur lors des opérations qui
nécessitent un parcours sur les éléments
de la liste (PSuiv(P);).
3)
Liste vide : L=Nil
Liste avec un seul élément : Suiv(L) = Nil
Liste avec plus d’un élément : Suiv(L) <> Nil

25. 25
4)
5) Le premier maillon constitue un cas spécial, alors si on
pose une question dans laquelle on veut faire la
création d’une liste, une insertion/suppression d’un
maillon alors il faut voir si le cas du premier élément se
pose ou pas.
Tant que (P<>Nil)…. Tant que (Suiv(P)<>Nil)….
Les actions de la boucles
sont exécutées sur tous
les éléments de la liste
Les actions de la boucles
sont exécutées sur tous
les éléments de la liste
sanf le dernier
A la sortie de la boucle
on trouve P = Nil
A la sortie de la boucle
on trouve Suiv(P) = Nil
mais P<>Nil
Le Beurre de cette séance : (‫)فوائد‬

26. 26
6) Lorsqu’on veut modifier une liste (modification
de la valeur/chainage d’un maillon, l’insertion,
ou la suppression d’un maillon), il faut :
a)Dessiner une liste comportant au moins 4
maillons
b)Détecter les maillons qui sont infectés par
ces modifications, et placer un pointeur sur
chaque maillon infecté (sur le schéma)
c)Effectuer les modifications nécessaires sur
chaque maillon infecté et faire attention à
l‘ordre (sur le schéma)
d)Ecrire la solution algorithmique
Le Beurre de cette séance : (‫)فوائد‬