INF 1425

Algorithmique et structures de données

TRAVAIL PRATIQUE
25 points

■
Remplissez soigneusement cette feuille d’identité.
■
Rédigez votre travail à la page suivante, à la suite de cette feuille.
■
Respectez les espaces réservés pour la personne tutrice.
■
Sauvegardez votre travail de cette façon : INF1425_TP_VOTRENOM.doc
■
Utilisez le Dépôt des travaux pour acheminer votre travail à votre personne tutrice.

Feuille d’identité
Nom: Romero Francia

Prénom: Gonzalo Alfredo

Trimestre: Automne 2022

Date d’envoi: A déterminer prochainement

Réservé à l’usage de la personne tutrice

Note

Commentaires :

_________________

_________________

_________________

_________________
Exercice 1. Les tableaux (8 points)

(1)
Pseudo-code :

Fonction Calcul_Nombre_Eleves_Classe_Iterative(Liste_Eleve : Tableau; nmax : Entier; Prenom : chaine; nom : chaine) : Entier
Variable :
i, nombre_eleves : Entier
Début :
nombre_eleves  0
Pour(i=1 à nmax) Faire
Si (Taille de Prenom≤20 et Taille de Nom≤20) Alors
Lire(Prenom, Nom)
Écrire(Prenom, Nom)
nombre_eleves  nombre_eleves+1
Fin Si
Fin Pour
Retourner nombre_eleves
Fin.

Note : l’auteur du présent document AIME afficher la liste complète de tous les étudiants d’une classe X (et de toute structure de données
quelconque), pour ensuite réaliser le calcul du nombre d’élèves de cette classe X (et tout type de calcul et opération quelconque)!

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]
INF 1425 – Travail pratique

(2)
Pseudo-code1 :

Fonction Calcul_Nombre_Eleves_Classe_Recursive(Liste_Eleve : Tableau; nmax : Entier; Prenom : chaine; nom : chaine) : Entier
Variable :
nombre_eleves : Entier
Début :
Si (nombre_eleves=-1) Alors
nombre_eleves0
Sinon Si (nombre_eleves=nmax) Alors
Retourner nombre_eleves
Sinon Si(Taille de Prenom≤20 et Taille de Nom≤20 et nombre_eleves˂nmax) Alors
Lire(Prenom, Nom)
Écrire(Prenom, Nom)
Retourner nombre_eleves  Calcule_Nombre_Eleves_Classe_Recursive(nombre_eleves+1)
Fin Si
Fin.

Note : l’auteur du présent document AIME afficher la liste complète de tous les étudiants d’une classe X (et de toute structure de données
quelconque), pour ensuite réaliser le calcul du nombre d’élèves de cette classe X (et tout type de calcul et opération quelconque)!

1 : Voir l’annexe du présent document, car il contient la compilation de chacune des lignes de code du pseudo-code ci-dessus, qui démontre la
validité de ce pseudo-code.

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(3)
La forme itérative de la fonction créé à la question 1, de l’exercice #1, a une complexité algorithmique de l’ordre (n), c-à-d, que cet algorithme
parcourt toute la table fournie dans l’énoncé de cet exercice, afin de lire tous les prénoms et tous les noms des étudiants d’une classe
quelconque, tandis que la forme récursive résout, de manière simple et plus rapide, la détermination du nombre d’étudiants de cette classe.

La forme récursive détermine ce nombre d’étudiant de cette classe, tout en décomposant le problème principal, en des sous-problèmes de
complexité algorithmique moindre et identique, pour chacun de ces sous-problèmes. Ceci ayant été dit, le complexité algorithmique de ces sous-
problèmes, fournis par la forme récursive, de la fonction de la question 2, de l’exercice 1, est de l’ordre (1).

3
INF 1425 – Travail pratique

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

Résultat pour l’exercice 1 et commentaire général (sur 8 points)

[Ici, le texte de la personne tutrice]

Exercice 2. Les piles et les files (8 points)

(1)
Les voici les avantages de la structure de données de type pile, par rapport à la structure de données de type tableau :

1. Le principe d’empilage et de dépilage est de type LIFO : dernier entré, premier sorti.
2. La complexité algorithmique des opérations Pile Vide(P), Empiler(P) et Dépiler(P) est de l’ordre (1), c-à-d, que la complexité algorithmique
de ces trois types D’opérations dans une pile P est constante, et que le temps d’exécution n’augmente pas lorsque la taille de la pile
augmente.
3. Dans une pile P, pour chercher et trouver un élément x appartenant à cette pile P, il faut seulement dépiler, jusqu’à ce que l’on trouve
l’élément recherché, le dépilage prenne un temps d’exécution constant et de valeur moindre.

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(2)
Algorithme Ajouter_Un_Element_Dans_Une_Pile_P(P : Pile; x : élément)
Début :
P.sommetP.sommet+1
P[P.sommet]x
Fin.

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

4
INF 1425 – Travail pratique

(3)
Fonction Algorithme_Calculer_Nombre_Elements_Dans_Une_Pile(P : Pile; x : élément)à
Début :
Retourner P.sommet
Fin.

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(4)
Actions sur une pile vide P:

Empiler(10)→10
↑
P.sommet

Empiler(3)→10 3
↑
P.sommet

Dépiler()→10
↑
P.sommet

Empiler(12)→10 12
↑
P.sommet

Empiler(84)→10 12 84
↑
P.sommet

Dépiler()→10 12
↑
P.sommet

5
INF 1425 – Travail pratique

Dépiler()→10
↑
P.sommet

Empiler(19)→10 19
↑
P.sommet

Empiler(20)→10 19 20
↑
P.sommet

Dépiler()→10 19
↑
P.sommet

Empiler(17)→10 19 17
↑
P.sommet

Empiler(16)→10 19 17 16
↑
P.sommet

Dépiler()→10 19 17
↑
P.sommet

Dépiler()→10 19
↑
P.sommet

6
INF 1425 – Travail pratique

Empiler(4)→10 19 4
↑
P.sommet

Dépiler()→10 19
↑
P.sommet

Dépiler()→10
↑
P.sommet

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(5)
Algorithme Ajouter_Un_Element_Dans_Une_File_F(F : File; x : élément)
Début :
F[F.queue]x
Si (F.queue==F.longueur) Alors
F.queue=1
Sinon
F.queueF.queue+1
Fin Si
Fin.

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

7
INF 1425 – Travail pratique

(6)
Actions sur une file vide :

Enfiler(51)→ 51
↑
F.tête

Enfiler(61)→ 51 61
↑ ↑
F.tête F.queue

Défiler()→ 61
↑
F.tête

Enfiler(21)→ 61 21
↑ ↑
F.tête F.queue
Enfiler(81)→ 61 21 81
↑ ↑
F.tête F.queue

Défiler()→ 21 81
↑ ↑
F.tête F.queue

Défiler()→ 81
↑
F.tête

Enfiler(9)→ 81 9
↑ ↑
F.tête F.queue

8
INF 1425 – Travail pratique

Enfiler(10)→ 81 9 10
↑ ↑
F.tête F.queue

Défiler()→ 9 10
↑ ↑
F.tête F.queue

Enfiler(17)→ 9 10 17
↑ ↑
F.tête F.queue

Enfiler(16)→ 9 10 17 16
↑ ↑
F.tête F.queue

Défiler()→ 10 17 16
↑ ↑
F.tête F.queue

Défiler()→ 17 16
↑ ↑
F.tête F.queue

Enfiler(4)→ 17 16 4
↑ ↑
F.tête F.queue

Défiler()→ 16 4
↑ ↑
F.tête F.queue

Défiler()→ 4
↑
F.tête
9
INF 1425 – Travail pratique

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

Résultat pour l’exercice 2 et commentaire général (sur 8 points)

[Ici, le texte de la personne tutrice]

Exercice 3. Les algorithmes de tri (9 points)

(1)
Triage de la suite d’éléments 21,64,33,16,17,99,14,12,18,55, en utilisant l’algorithme de tri par sélection montrée par la figure suivante :

i=1 21(1),64(2),33(3),16(4),17(5),99(6),14(7),12(8),18(9),55(10)
indmin=1

(i,j)=(1,2)→Fais rien!
(i,j)=(1,3)→Fais rien!
(i,j)=(1,4)→indmin=4, et l’élément est 16.
(i,j)=(1,5)→Fais rien!

10
INF 1425 – Travail pratique

(i,j)=(1,6)→Fais rien!
(i,j)=(1,7)→indmin=7, et l’élément est 14.
(i,j)=(1,8)→indmin=8, et l’élément est 12.
(i,j)=(1,9)→Fais rien!
(i,j)=(1,10)→Fais rien!

(1)
Indmin=8˃i=1? Oui→Permute(1,8)→ 12 ,64(2),33(3),16(4),17(5),99(6),14(7),21(8),18(9),55(10)

i=2 12(1),64(2),33(3),16(4),17(5),99(6),14(7),21(8),18(9),55(10)
indmin=2

(i,j)=(2,3)→ indmin=3, et l’élément est 33.

(i,j)=(2,4)→ indmin=4, et l’élément est 16.
(i,j)=(2,5)→ indmin=5, et l’élément est 17.
(i,j)=(2,6)→Fais rien!
(i,j)=(2,7)→ indmin=7, et l’élément est 14.
(i,j)=(2,8)→Fais rien!
(i,j)=(2,9)→Fais rien!
(i,j)=(2,10)→Fais rien!

(1)
Indmin=7˃i=2? Oui→Permute(2,7)→ 12 ,14(2),33(3),16(4),17(5),99(6),64(7),21(8),18(9),55(10)

i=3 12(1),14(2),33(3),16(4),17(5),99(6),64(7),21(8),18(9),55(10)
indmin=3

(i,j)=(3,4)→ indmin=4, et l’élément est 16.

(i,j)=(3,5)→ indmin=5, et l’élément est 17.
(i,j)=(3,6)→Fais rien!
(i,j)=(3,7)→Fais rien!
(i,j)=(3,8)→ indmin=8, et l’élément est 21.
(i,j)=(3,9)→ indmin=9, et l’élément est 18.
(i,j)=(3,10)→Fais rien!

11
INF 1425 – Travail pratique

(1)
Indmin=4˃i=3? Oui→Permute(3,4)→ 12 ,14(2),16(3),33(4),17(5),99(6),64(7),21(8),18(9),55(10)
i=4 12(1),14(2),16(3),33(4),17(5),99(6),64(7),21(8),18(9),55(10)
indmin=4

(i,j)=(4,5)→ indmin=5, et l’élément est 17.

(i,j)=(4,6)→Fais rien!
(i,j)=(4,7)→Fais rien!
(i,j)=(4,8)→ indmin=8, et l’élément est 21.
(i,j)=(4,9)→ indmin=9, et l’élément est 18.
(i,j)=(4,10)→Fais rien!

(1)
Indmin=5˃i=4? Oui→Permute(4,5)→ 12 ,14(2),16(3),17(4),33(5),99(6),64(7),21(8),18(9),55(10)

i=5 12(1),14(2),16(3),17(4),33(5),99(6),64(7),21(8),18(9),55(10)
indmin=5

(i,j)=(5,6)→Fais rien!
(i,j)=(5,7)→Fais rien!
(i,j)=(5,8)→ indmin=8, et l’élément est 21.
(i,j)=(5,9)→ indmin=9, et l’élément est 18.
(i,j)=(5,10)→Fais rien!

(1)
Indmin=9˃i=5? Oui→Permute(5,9)→ 12 ,14(2),16(3),17(4),18(5),99(6),64(7),21(8),33(9),55(10)

i=6 12(1),14(2),16(3),17(4),18(5),99(6),64(7),21(8),33(9),55(10)
indmin=6

(i,j)=(6,7)→ indmin=7, et l’élément est 64.

(i,j)=(6,8)→ indmin=8, et l’élément est 21.
(i,j)=(6,9)→ indmin=9, et l’élément est 33.
(i,j)=(6,10)→ indmin=10, et l’élément est 55.

(1)
Indmin=8˃i=6? Oui→Permute(6,8)→ 12 ,14(2),16(3),17(4),18(5),21(6),64(7),99(8),33(9),55(10)

12
INF 1425 – Travail pratique

i=7 12(1),14(2),16(3),17(4),18(5),21(6),64(7),99(8),33(9),55(10)
indmin=7

(i,j)=(7,8)→Fais rien!
(i,j)=(7,9)→ indmin=9, et l’élément est 33.
(i,j)=(7,10)→ indmin=10, et l’élément est 55.

(1)
Indmin=9˃i=7? Oui→Permute(7,9)→ 12 ,14(2),16(3),17(4),18(5),21(6),33(7),99(8),64(9),55(10)

i=8 12(1),14(2),16(3),17(4),18(5),21(6),33(7),99(8),64(9),55(10)
indmin=8

(i,j)=(8,9)→ indmin=9, et l’élément est 64.

(i,j)=(8,10)→ indmin=10, et l’élément est 55.

(1)
Indmin=10˃i=8? Oui→Permute(8,10)→ 12 ,14(2),16(3),17(4),18(5),21(6),33(7),55(8),64(9),99(10)
Le voici la suite d’éléments de l’exercice #3, triée avec l’algorithme de tri par sélection :

12,14,16,17,18,21,33,55,64,99

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

13
INF 1425 – Travail pratique

(2)
Triage de la suite d’éléments 21,64,33,16,17,99,14,12,18,55, en utilisant l’algorithme de tri par insertion montrée par la figure suivante :

21(1),64(2),33(3),16(4),17(5),99(6),14(7),12(8),18(9),55(10)
(i,j)=(1,2)→ 21˃64? Non!
33˃64? Non!
16˃64? Non!
17˃64? Non!
99˃64? Oui! → Alors il ne se passe rien, car l’élément 99 est placé après l’élément 64!
14˃64? Non!
12˃64? Non!
18˃64? Non!
55˃64? Non! !→ Alors l’élément 99 placé après l’élément 55!→ 21,64,33,16,17,14,12,18,55,99

Alors, le seul changement de place montrés ci-dessus donnent la suite suivante → 21,64,33,16,17,14,12,18,55,99

14
INF 1425 – Travail pratique

(i,j)=(2,3)→ 21˃33? Non!

64˃33? Oui! → Alors l’élément 64 est placé après l’élément 33→ 21,33,64,16,17,14,12,18,55,99
16˃33? Non!
17˃33? Non!
14˃33? Non!
12˃33? Non!
18˃33? Non!
55˃33? Oui! → Alors l’élément 64 est placé après l’élément 55!→ 21,33,16,17,14,12,18,55,64,99
99˃33? Oui! → Alors l’élément 99 garde sa place!

Alors, les deux changements de place montrés ci-dessus donnent la suite suivante → 21,33,16,17,14,12,18,55,64,99

(i,j)=(3,4)→ 21˃17? Oui! → Alors l’élément 21 est placé après l’élément 17!→ 33,16,17,21,14,12,18,55,64,99
33˃17? Oui! → Alors l’élément 33 est placé après l’élément 21!→ 16,17,21,33,14,12,18,55,64,99
16˃17? Non!
14˃17? Non!
12˃17? Non!
18˃17? Oui! → Alors il ne se passe rien, car l’élément 18 est placé après l’élément 17!
55˃17? Oui! → Alors l’élément 55 garde sa place!
64˃17? Oui! → Alors l’élément 64 garde sa place!
99˃17? Oui! → Alors l’élément 99 garde sa place!

Alors, les deux changements de place montrés ci-dessus donnent la suite suivante → 16,17,21,33,14,12,18,55,64,99

(i,j)=(4,5)→ 16˃14? Oui! → Alors l’élément 16 est placé après l’élément 14!→ 17,21,33,14,16,12,18,55,64,99
17˃14? Oui! → Alors l’élément 17 est placé après l’élément 16!→ 21,33,14,16,17,12,18,55,64,99
21˃14? Oui! → Alors l’élément 21 est placé après l’élément 17!→ 33,14,16,17,21,12,18,55,64,99
33˃14? Oui! → Alors l’élément 33 est placé après l’élément 21!→ 14,16,17,21,33,12,18,55,64,99
12˃14? Non!
18˃14? Non!
55˃14? Oui!→Alors l’élément 55 garde sa place!
64˃14? Oui!→Alors l’élément 64 garde sa place!
99˃14? Oui!→Alors l’élément 99 garde sa place!

Alors, les quatre changements de place montrés ci-dessus donnent la suite suivante → 14,16,17,21,33,12,18,55,64,99

15
INF 1425 – Travail pratique

(i,j)=(5,6)→ 14˃12? Oui! → Alors l’élément 14 est placé après l’élément 12! → 16,17,21,33,12,14,18,55,64,99
16˃12? Oui! → Alors l’élément 16 est placé après l’élément 14! → 17,21,33,12,14,16,18,55,64,99
17˃12? Oui! → Alors l’élément 17 est placé après l’élément 16! → 21,33,12,14,16,17,18,55,64,99
21˃12? Oui! → Alors l’élément 21 est placé après l’élément 17! → 33,12,14,16,17,21,18,55,64,99
33˃12? Oui! → Alors l’élément 33 est placé après l’élément 21! → 12,14,16,17,21,33,18,55,64,99
18˃12? Oui! → Alors il ne se passe rien, car l’élément 18 est placé après l’élément 12!
55˃12? Oui!→Alors l’élément 55 garde sa place!
64˃12? Oui!→Alors l’élément 64 garde sa place!
99˃12? Oui!→Alors l’élément 99 garde sa place!

Alors, les cinq changements de place montrés ci-dessus donnent la suite suivante → 12,14,16,17,21,33,18,55,64,99

(i,j)=(6,7)→ 12˃18? Non!

14˃18? Non!
16˃18? Non!
17˃18? Non!
21˃18? Oui! → Alors l’élément 21 est placé après l’élément 18! → 12,14,16,17,33,18,21,55,64,99
33˃18? Oui! → Alors l’élément 33 est placé après l’élément 21! → 12,14,16,17,18,21,33,55,64,99
55˃18? Oui! → Alors l’élément 55 garde sa place!
64˃18? Oui!→ Alors l’élément 64 garde sa place!
99˃18? Oui!→Alors l’élément 99 garde sa place!

Alors, les deux changements de place montrés ci-dessus donnent la suite suivante → 12,14,16,17,18,21,33,55,64,99

(i,j)=(7,8)→ 12˃55? Non!

14˃55? Non!
16˃55? Non!
17˃55? Non!
18˃55? Non!
21˃55? Non!
33˃55? Non!
64˃55? Oui!→ Alors l’élément 64 garde sa place!
99˃55? Oui!→Alors l’élément 99 garde sa place!
16
INF 1425 – Travail pratique

(i,j)=(8,9) → Idem que pour le cas de l’itération (i,j)=(7,8), sauf que la clé dans cette itération est l’élément 64¡

Le voici la suite d’éléments de l’exercice #3, triée avec l’algorithme de tri par sélection :

12,14,16,17,18,21,33,55,64,99

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(3)
Triage de la suite d’éléments 21,64,33,16,17,99,14,12,18,55, en utilisant l’algorithme de tri à bulle montrée par la figure suivante :

21(1),64(2),33(3),16(4),17(5),99(6),14(7),12(8),18(9),55(10)
Traitement de N-1 à (10) :

55<99 → Permute(55,99)→ 21(1),64(2),33(3),16(4),17(5),99(6),14(7),12(8),18(9),55(10)

Cela donne : 21(1),64(2),33(3),16(4),17(5),55(6),14(7),12(8),18(9),99(10)

55<64 → Permute(55,64)→ 21(1),64(2),33(3),16(4),17(5),55(6),14(7),12(8),18(9),99(10)

17
INF 1425 – Travail pratique

Cela donne : 21(1),55(2),33(3),16(4),17(5),64(6),14(7),12(8),18(9),99(10)

Traitement de N-1 à (9) :

18<64 → Permute(18,64)→ 21(1),55(2),33(3),16(4),17(5),64(6),14(7),12(8),18(9),99(10)

Cela donne : 21(1),55(2),33(3),16(4),17(5),18(6),14(7),12(8),64(9),99(10)

18<33 → Permute(18,33)→ 21(1),55(2),33(3),16(4),17(5),18(6),14(7),12(8),64(9),99(10)

Cela donne : 21(1),55(2),18(3),16(4),17(5),33(6),14(7),12(8),64(9),99(10)

18<55 et 18<21 → Permute(18,55) et Permute(18,21) → 21(1),55(2),18(3),16(4),17(5),33(6),14(7),12(8),64(9),99(10)

Cela donne : 18(1),21(2),55(3),16(4),17(5),33(6),14(7),12(8),64(9),99(10)

Traitement de N-1 à (8) :

12<14→Permute(12,14) → 18(1),21(2),55(3),16(4),17(5),33(6),14(7),12(8),64(9),99(10)

Cela donne : 18(1),21(2),55(3),16(4),17(5),33(6),12(7),14(8),64(9),99(10)

12<33→Permute(12,33)→ 18(1),21(2),55(3),16(4),17(5),33(6),12(7),14(8),64(9),99(10)

Cela donne : 18(1),21(2),55(3),16(4),17(5),12(6),33(7),14(8),64(9),99(10)

18
INF 1425 – Travail pratique

12<17 et 12<16→Permute(12,17) et Permute(12,16)→ 18(1),21(2),55(3),16(4),17(5),12(6),33(7),14(8),64(9),99(10)

Cela donne : 18(1),21(2),55(3),12(4),16(5),17(6),33(7),14(8),64(9),99(10)

12<55, 12<21 et 12<18 → Permute(12,55), Permute(12,21) et Permute(12,18) → 18(1),21(2),55(3),12(4),16(5),17(6),33(7),14(8),64(9),99(10)

Cela donne : 12(1),18(2),21(3),55(4),16(5),17(6),33(7),14(8),64(9),99(10)

Traitement de N-1 à (7) :

14<17 → Permute(14,17) → 12(1),18(2),21(3),55(4),16(5),17(6),33(7),14(8),64(9),99(10)

Cela donne : 12(1),18(2),21(3),55(4),16(5),14(6),33(7),17(8),64(9),99(10)

14<16 et 14<55 → Permute(14,16) et Permute(14,55) → 12(1),18(2),21(3),55(4),16(5),14(6),33(7),17(8),64(9),99(10)

Cela donne : 12(1),18(2),21(3),14(4),55(5),16(6),33(7),17(8),64(9),99(10)

14<21 et 14<18 → Permute(14,21) et Permute(14,18) → 12(1),18(2),21(3),14(4),55(5),16(6),33(7),17(8),64(9),99(10)

Cela donne : 12(1),14(2),18(3),21(4),55(5),16(6),33(7),17(8),64(9),99(10)

19
INF 1425 – Travail pratique

Traitement de N-1 à (6) : On ne fait rien, car 99 est la valeur max!

Traitement de N-1 à (5) :

17<55 → Permute(17,55) → 12(1),14(2),18(3),21(4),55(5),16(6),33(7),17(8),64(9),99(10)

Cela donne : 12(1),14(2),18(3),21(4),17(5),16(6),33(7),55(8),64(9),99(10)

17<21 et 17<18 → Permute(17,21) et Permute(17,18) → 12(1),14(2),18(3),21(4),17(5),16(6),33(7),55(8),64(9),99(10)

Cela donne : 12(1),14(2),17(3),18(4),21(5),16(6),33(7),55(8),64(9),99(10)

Traitement de N-1 à (4) :

16˂21 → Permute(16,21) → 12(1),14(2),17(3),18(4),21(5),16(6),33(7),55(8),64(9),99(10)

Cela donne : 12(1),14(2),17(3),18(4),16(5),21(6),33(7),55(8),64(9),99(10)

16˂18 et 16˂17 → Permute(16,18) et Permute(16,17) → 12(1),14(2),17(3),18(4),16(5),21(6),33(7),55(8),64(9),99(10)

Cela donne : 12(1),14(2),16(3),17(4),18(5),21(6),33(7),55(8),64(9),99(10)

Le voici la suite d’éléments de l’exercice #3, triée avec l’algorithme de tri par sélection :

12,14,16,17,18,21,33,55,64,99

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

(4)
20
INF 1425 – Travail pratique

Triage de la suite d’éléments 21,64,33,16,17,99,14,12,18,55, en utilisant l’algorithme de tri rapide montrée par les figures suivantes :

21(1),64(2),33(3),16(4),17(5),99(6),14(7),12(8),18(9),55(10)
↑
r (pivot)

21
INF 1425 – Travail pratique

Itération #1 :

21(1) 64(2) 33(3) 16(4) 17(5) 99(6) 14(7) 12(8) 18(9) 55(10)
↑
Pivot (pour l’itération #1!)

(i,j)=(0,1) → (1,1)
(i,j)=(1,2) → Fais rien!
(i,j)=(1,3)→ (2,3) → Permute(64,33) → 21(1) 33(2) 64(3) 16(4) 17(5) 99(6) 14(7) 12(8) 18(9) │ 55(10)
*
(i,j)=(2,4)→ (3,4) → Permute(64,16) → 21(1) 33(2) 16(3) 64(4) 17(5) 99(6) 14(7) 12(8) 18(9) │ 55(10)
*
(i,j)=(3,5)→ (4,5) → Permute(64,17) → 21(1) 33(2) 16(3) 17(4) 64(5) 99(6) 14(7) 12(8) 18(9) │ 55(10)
*
(i,j)=(4,6) → Fais rien!

(i,j)=(4,7)→ (5,7) → Permute(64,14) → 21(1) 33(2) 16(3) 17(4) 14(5) 99(6) 64(7) 12(8) 18(9) │ 55(10)
*
(i,j)=(5,8)→ (6,8) → Permute(99,12) → 21(1) 33(2) 16(3) 17(4) 14(5) 12(6) 64(7) 99(8) 18(9) │ 55(10)
*
(i,j)=(6,9)→ (7,9) → Permute(64,18) → 21(1) 33(2) 16(3) 17(4) 14(5) 12(6) 18(7) 99(8) 64(9) │ 55(10)
*
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
Permute(8,10) → Permute(99,55) → 21 33 16 17 14 12 18 55 64 │ 99
*
↑
Pivot (pour l’itération #2!)

Retourner i+1 → réaliser un décalage à droite à la toute fin de la compilation de l’algorithme de tri rapide!

22
INF 1425 – Travail pratique

Itération #2 :

21(1) 33(2) 16(3) 17(4) 14(5) 12(6) 18(7) 55(8) 64(9) │ 99(10)
↑
Pivot (pour l’itération #3!)
*
(i,j)=(0,1) → (1,1)
(i,j)=(1,2) → (2,2)
(i,j)=(2,3) → (3,3)
(i,j)=(3,4) → (4,4)
(i,j)=(4,5) → (5,5)
(i,j)=(5,6) → (6,6)
(i,j)=(6,7) → (7,7)
(i,j)=(7,8) → (8,8)
(i,j)=(8,9) → (9,9)

Permute(9,10) → Il n’est pas possible de réaliser cette permutation, car les chiffres de position 8, 9 et 10, qui sont les élément 55,64 et 99, SONT
A LEUR PLACE ET NE DOIVENT PLUS ÊTRE TOUCHÉS. Alors, le prochain élément qui doit devenir le pivot, c’est le premier élément qui se trouve
juste à gauche de l’élément 55, qui est à sa place. Cet élément est le nombre 18, alors c’est cet élément le prochain pivot!

Ceci ayant été clarifié, le voici le prochain changement de place à faire, pour compiler l’algorithme de tri rapide :

Mettre l’élément 18 après l’élément 99 → 21(1) 33(2) 16(3) 17(4) 14(5) 12(6) 55(7) 64(8) 99(9) │ 18(10)
*
Note : Il est à comprendre que, à cause de l’impossibilité de réaliser la permutation Permute(9,10), et que le prochain pivot est l’élément 18, en
plus du fait que les éléments 55,64 et 99 SONT A LEUR PLACE, il ne faut SURTOUT PAS réaliser une permutation, il faut plutôt réaliser un
changement de place, pour ce nouveau pivot, qui est l’élément 18, car sinon on sera DANS UNE BOUCLE INFINIE, où i y aura des permutations
bidon QUI NE RÉALISENT AUCUN TRI RAPIDE!

Retourner i+1 → réaliser un décalage à droite à la toute fin de la compilation de l’algorithme de tri rapide!

23
INF 1425 – Travail pratique

Itération #3 :

21(1) 33(2) 16(3) 17(4) 14(5) 12(6) 55(7) 64(8) 99(9) │ 18(10)
↑ *
Pivot (pour l’itération #4!)

(i,j)=(0,1) → Fais rien!

(i,j)=(0,2) → Fais rien!
(i,j)=(0,3) → (1,3) → Permute(21,16) → 16(1) 33(2) 21(3) 17(4) 14(5) 12(6) 55(7) 64(8) 99(9) │ 18(10)
*
(i,j)=(1,4) → (2,4) → Permute(33,17) → 16(1) 17(2) 21(3) 33(4) 14(5) 12(6) 55(7) 64(8) 99(9) │ 18(10)
*
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
(i,j)=(2,5) → (3,5) → Permute(21,14) → 16 17 14 33 21 12 55 64 99 │ 18
*
(i,j)=(3,6) → (4,6) → Permute(33,12) → 16(1) 17(2) 14(3) 12(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 18(10)
*
(i,j)=(4,7) → Fais rien!
(i,j)=(0,8) → Fais rien!
(i,j)=(0,9) → Fais rien!

Permute(5,10) → Permute(21,18) →

Permute(5,10) → Il n’est pas possible de réaliser cette permutation, car les chiffres de position 5,6,7,8 et 9, qui sont les élément 21,33,55,64 et
99, SONT A LEUR PLACE ET NE DOIVENT PLUS ÊTRE TOUCHÉS. Alors, le prochain élément qui doit devenir le pivot, c’est le premier élément qui se
trouve juste à gauche de l’élément 21, qui est à sa place. Cet élément est le nombre 12, alors c’est cet élément le prochain pivot!

Ceci ayant été clarifié, le voici la prochaine permutation à faire, pour compiler l’algorithme de tri rapide :

Permute(4,10) → Permute(12,18) → 16(1) 17(2) 14(3) 18(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 12(10)

24
INF 1425 – Travail pratique

Note : Il est à comprendre que, à cause de l’impossibilité de réaliser la permutation Permute(5,10), et que le prochain pivot est l’élément 12, en
plus du fait que les éléments 21,33,55,64 et 99 SONT A LEUR PLACE, il faut réaliser la permutation Permute(4,10), au lieu de la permutation
Permute(5,10).

Retourner i+1 → réaliser un décalage à droite à la toute fin de la compilation de l’algorithme de tri rapide!

Itération #4 :

16(1) 17(2) 14(3) 18(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 12(10)
↑ *
Pivot (pour l’itération #5!)

(i,j)=(0,1) → Fais rien!

(i,j)=(0,2) → Fais rien!
(i,j)=(0,3)→ Fais rien!
(i,j)=(0,4) → Fais rien!
(i,j)=(0,5) → Fais rien!
(i,j)=(0,6) → Fais rien!
(i,j)=(0,7) → Fais rien!
(i,j)=(0,8) → Fais rien!
(i,j)=(0,9) → Fais rien!

Permute(1,10)1 → Permute(16,12) → 12(1) 17(2) 14(3) 18(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 16(10)
*
1 
: La permutation Permute(1,10) est possible à cause du fait que, dans la compilation de la boucle TANT QUE, à l’itération #5, n’a donné aucun
triage. Alors, la variable i de l’algorithme de tri rapide, montrée à la page 21, n’a jamais changé tout au cours de cette itération #5. Par
conséquent, i vaut 0, et i+1 vaut 1, et donc la permutation qui est placé APRÈS LA BOUCLE TANT QUE, se réalise avec la variable i assignée à la
valeur 0, et la variable r assignée à la valeur 10.

Retourner i+1 → réaliser un décalage à droite à la toute fin de la compilation de l’algorithme de tri rapide!

25
INF 1425 – Travail pratique

Itération #5 :

12(1) 17(2) 14(3) 18(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 16(10)
*
(i,j)=(0,1) → (1,1)
(i,j)=(1,2) → Fais rien!
(i,j)=(1,3)→ (2,3) Permute(17,14) → 12(1) 14(2) 17(3) 18(4) 21(5) 33(6) 55(7) 64(8) 99(9) │ 16(10)
*
(i,j)=(2,4) → Fais rien!
(i,j)=(0,5) → Fais rien!
(i,j)=(0,6) → Fais rien!
(i,j)=(0,7) → Fais rien!
(i,j)=(0,8) → Fais rien!
(i,j)=(0,9) → Fais rien!

Permute(4,10)2 → Il n’est pas possible de réaliser cette permutation, car les chiffres de position 1,2,3,4,5,6,7,8 et 9, qui sont les élément
12,14,17,18,21,33,55,64 et 99, SONT A LEUR PLACE ET NE DOIVENT PLUS ÊTRE TOUCHÉS. Alors, l’algorithme de triage rapide s’est terminé, et
alors on doit placer l’élément 16 à l’emplacement j=3, car c’est le dernier emplacement compilé par l’algorithme de tri, et qui a donné comme
résultat de compilation, une permutation d’éléments.

Ceci ayant été clarifié, l’algorithme de tri se termine par l’emplacement de l’élément 16 à la quatrième position de la suite d’éléments de
l’exercice 3, ainsi qu’il faut réaliser 7 décalages à droite, afin de réaliser une mise à jour des numéros d’emplacements des éléments suivant cet
élément 16. Le voici l’emplacement de cet élément 16, dans la suite d’élément déjà trié de manière ascendante :

12(1),14(2),16(3),17(4),18(5),21(6),33(7),55(8),64(9),99(10)

2 
: A l’itération #5, il n’y a plus de permutations à faire, car TOUS LES NUMÉROS, SAUF 16 sont DÉJÀ TRIÉS, DE FORME ASCENDANTE, alors on ne
les touche plus! Il faut déterminer l’emplacement du dernier numéro pivot créé par l’algorithme de tri rapide, qui est le numéro 16. La façon la
plus logique de déterminer l’emplacement de ce nombre 17, de manière ascendante, est de prendre la dernière valeur compilée de la variable j ,
et qui a permis de réaliser une permutation, à l’aide de l’algorithme de tri rapide. Dans le cas de l’itération #5, cette variable j a pris, comme
dernière valeur compilée, la valeur 3, alors on met l’élément 16 à l’emplacement 3! C’est de cette manière que finit la compilation de
l’algorithme de tri rapide!

26
INF 1425 – Travail pratique

Le voici la suite d’éléments de l’exercice #3, triée avec l’algorithme de tri par sélection :

12,14,16,17,18,21,33,55,64,99

Note : le triage réalisé par l’algorithme de tri rapide a été très rapide hein!!!

Commentaires de la personne tutrice

[Ici, le texte de la personne tutrice]

Résultat pour l’exercice 3 et commentaire général (sur 9 points)

[Ici, le texte de la personne tutrice]

27
INF 1425 – Travail pratique

Annexe
Travail Pratique – Révision et vérification du pseudo-code de l’exercice (2), de la question 1 du
Travail pratique
1

i=1 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=1

i=2 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=2

i=3 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=3

i=4 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=4

28
INF 1425 – Travail pratique

i=5 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=5

40

i=40 → nombre_eleves=0 → nombre_eleves Retourner Calcul_Nombre_Eleves_Classe_Recursive(nombre_eleves+1) → nombre_eleves=40

39

Fin

Les lignes ci-dessus, qui montrent la compilation des lignes du pseudo-code de l’exercice 2, de la question 1, du présent travail pratique, en
considérant une classe quelconque X, ayant un maximum de 40 élèves, c-à-d, que cette classe d’école X est associée à 40 élèves d’école
quelconque Y!

29