TD5- Algorithmique I

Module informatique SMIA-S2

2020-2021

Pr. Er-rajy Latifa

Exercice 1

1. Écrire en langage algorithmique une procédure prenant en paramètres d’entrée,

un tableau Tab d’entier et sa taille N et qui affiche :

a. Le contenu du tableau
b. Le plus grand ainsi que le plus petit élément du tableau
c. Les indices des éléments du plus grand et plus petit élément du tableau

2. Ecrire un programme TEST qui permet de tester cette procédure

Réel par adresse

Procédure Nom_procedure ( n : entier par valeur, tableau Tab : réel par référence)

finProcédure

Pr. Er-rajy Latifa

Exercice 1 Solution :

Procédure Tableau_Min_Max(N: entier par valeur, tableaux Tab: entier par référence)
Var i,Min,Max, Indice_min, Indice_max : entier
Pour i0 à N-1 faire
Ecrire ("Tab[",i, "] =", Tab[i])
FinPour
MinTab[0]
MaxTab[0]
Indice_min0
Indice_max0
Pour i1 à N-1 faire
si Tab[i]<Min
Min Tab[i]
Indice_mini
FinSi
si Tab[i]>Max alors
Max Tab[i]
Indice_maxi
FinSi
FinPour
Ecrire (" le nombre le plus grand est : " , Max, " son indice est :" , Indice_max)
Ecrire (" le nombre le plus petit est : " , Max, " son indice est :" , Indice_min)
FinProcédure
Pr. Er-rajy Latifa
Exercice 1 Solution :

Algorithme Tableau_Min_Max
Var N : entier
Tableau Tab[10] : entier
Début
N10
Pour i0 à N-1 faire
Ecrire("  Veuillez saisir l’élément  ",i+1)
Lire(Tab[i])
FinPour
Tableau(N,Tab)
Fin

Pr. Er-rajy Latifa

Exercice 2

1. Ecrire une procédure qui permet la saisie d’un tableau LireTab et une procédure
AfficherTab qui permet d’afficher le contenu d’un tableau.

2. Ecrire un programme TEST qui permet de tester ces deux procédures.

Pr. Er-rajy Latifa

Exercice 2 Solution :

Procédure LireTab (n: entier par valeur, Tab: réel par référence)
Var i : entier
pour i 0 à n-1
Ecrire(« Veuillez saisir l’élément : », i)
lire(Tab[i])
FinPour
FinProcédure

Procédure AfficheTab(n: entier par valeur, Tab: réel par référence)

variable i: entier
Pour i allant de 0 à n-1
écrire ("T[",i, "] =", T[i])
FinPour
FinProcédure

Pr. Er-rajy Latifa

Exercice 2

Algorithme Tableaux
var p : entier
Tableau A[10] : réel
Début
p10
LireTab(p, A)
AffcheTab(p,A)
Fin

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection)

Il consiste en la recherche du plus grand élément du tableau qui va être placé à sa position
définitive c’est-à-dire en dernière position. L’algorithme continue en recherchant le plus
grand élément du tableau privé de son dernier élément, qui va être placé en avant dernière
position. Et ainsi de suite pour tous les éléments du tableau, qui sera finalement trié.

1- Trier le tableau suivant selon l’algorithme du tri par sélection en donnant toutes les
étapes intermédiaires réalisées.

143520 6 8 7
2- Ecrire l’algorithme qui réalise le tri par sélection

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection)

Les étapes: 1 4 3 5 2 0 6 8 7

On a un Tableau T de N=9 éléments d'indices 0, 1, 2, …, 7, 8 on accède à un

élément du tableau par l'indice de cet élément. T[0] = 1 est en première position
et T[8]= 7 en dernière position.

On va suivre les étapes :

1. Rechercher le plus grand élément du tableau et le placer en dernière

position(ici l'indice N-2 = 8).
2. Recherchant le plus grand élément du tableau restant et le placer en avant
dernière position(ici à l'indice N-1=7).
 
3. Continuer ainsi pour tous les éléments du tableau.

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 1) : Tout élément d'un tableau est déterminé par son indice.
a) Pour commencer : Prenons l'élément en dernière position T[8] comme le plus grand de
tous les autres d'indice. Gardons son indice dans une variable : indice_pge ← 8

  0 1 2 3 4 5 6 7 i=8
Tab[i] 1 4 3 5 2 0 6 8 7
Tab[j] <-----Tab[j=0,1,2,3,4,5,6,7] --------> Tab[i]

b) Comparons ce T[i=8] avec les éléments restants du tableau ( T[j], j= 0,1,2, …, 7).
En comparant, on a le plus grand T[j] =8 pour j= 7. Gardons son indice , indice_pge ← 7

c) On échange alors les éléments T[7] et T[8] (échanger T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] <-----Tab[j=0,1,2,3,4,5,6,7] --------> ok

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 2) : le plus grand parmi les 8 premiers éléments

i 0 1 2 3 4 5 6 i=7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] <-----Tab[j=0,1,2,3,4,5,6] --------> Tab[i] ok

a) On suppose T[7] le plus grand et on garde son indice indice_pge ← i=7

b) On comparant, aucun élément d'indice j <7 , n'est plus grand que T[7]=7
c) Il n ' y a rien à échanger. T[7] reste à sa place

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] <-----Tab[j=0,1,2,3,4,5,6] --------> ok ok

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 3) : le plus grand parmi les 7 premiers éléments

i 0 1 2 3 4 5 i=6 7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] <---Tab[j=0,1,2,3,4,5] --> Tab[i] ok ok

a) On suppose T[6] le plus grand et on garde son indice indice_pge ← i=6

b) On comparant, aucun élément d'indice j <6 , n'est plus grand que T[6]=6
c) Il n ' y a rien à échanger. T[6] reste à sa place.

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] <---Tab[j=0,1,2,3,4,5] --> ok ok ok

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 4) : le plus grand parmi les 6 premiers éléments

i 0 1 2 3 4 i=5 6 7 8
Tab[i] 1 4 3 5 2 0 6 7 8
Tab[j] Tab[j=0,1,2,3,4,5] Tab[i] ok ok ok
a) On suppose T[5] le plus grand et on garde son indice indice_pge ← i=5
b) On comparant, On a le plus grand T[j]=5, pour j= 3 Gardons son indice :indice_pge ← j=3
c) On échange alors les éléments T[3] et T[5] ( On échange T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 4 3 0 2 5 6 7 8
Tab[j] Tab[j=0,1,2,3,4,5] ok ok ok ok

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 5) : le plus grand parmi les 5 premiers éléments

i 0 1 2 3 i=4 5 6 7 8
Tab[i] 1 4 3 0 2 5 6 7 8
Tab[j] Tab[j=0,1,2,3,4] Tab[i] ok ok ok ok

a) On suppose T[4] le plus grand et on garde son indice indice_pge ← i=4

b) En comparant, on a le plus grand T[j]=4 pour j=1 Gardons son indice : indice_pge ← j=1
c) On échange alors les éléments T[1] et T[4] (On échange T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 2 3 0 4 5 6 7 8
Tab[j] Tab[j=0,1,2,3] ok ok ok ok ok

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 6) : le plus grand parmi les 4 premiers éléments

i 0 1 2 i=3 4 5 6 7 8
Tab[i] 1 2 3 0 4 5 6 7 8
Tab[j] Tab[j=0,1,2] Tab[i] ok ok ok Ok ok

a) On suppose T[3] le plus grand et on garde son indice indice_pge ← i=3

b) En comparant, on a le plus grand T[j]=30 pour j=2 Gardons cet indice : indice_pge ← j=2
c) On échange alors les éléments T[2] et T[4] (On échange T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 2 0 3 4 5 6 7 8
Tab[j] Tab[j=0,1,2] ok ok ok ok ok ok

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 7) : le plus grand parmi les 3 premiers éléments

i 0 1 i=2 3 4 5 6 7 8
Tab[i] 1 2 0 3 4 5 6 7 8
Tab[j] Tab[j=0,
1]
Tab[i] ok ok ok ok Ok ok

a) On suppose T[2] le plus grand et on garde son indice indice_pge ← i=2

b) En comparant, on a le plus grand T[j]=2 pour j=1 Gardons son indice: indice_pge ← j=1
c) On échange alors les éléments T[1] et T[2] (On échange T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 0 2 3 4 5 6 7 8
Tab[j] Tab[j=0,
1]
ok ok ok ok ok Ok ok

Pr. Er-rajy Latifa

 Exercice 3. (Tri par sélection) Solution :

Les étapes:

Étape 8) : le plus grand parmi les 2 premiers éléments

i 0 1 2 3 4 5 6 7 8
Tab[i] 1 0 2 3 4 5 6 7 8
Tab[j]Tab[j=0] Tab[i]Ok ok ok ok ok Ok ok
a) On suppose T[1] le plus grand et on garde son indice indice_pge ← i=1
b) En comparant, on a le plus grand T[j]=1 pour j=0 Gardons son indice: indice_pge ← j=0
c) On échange alors les éléments T[0] et T[1] (On échange T[indice_pge] et T[i])

i 0 1 2 3 4 5 6 7 8
Tab[i] 0 1 2 3 4 5 6 7 8
Tab[j] Fin ok ok ok ok ok ok Ok ok

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection)
Solution :

Pr. Er-rajy Latifa

Exercice 3. (Tri par sélection)
Solution :

Algorithme Tri_Selection
Tableau T[10] : réel
Var N, j, indice_pgq, temp : entier
Début
N10
Pour i allant de N-1 à 1 pas -1
indice_pge ← i
Pour j allant de 0 à i-1
Si T[j] >T[indice_pge] alors
indice_pge ← j
Finsi
FinPour
Si indice_pge < i Alors
temp ←T[indice_pge]
T[indice_pge] ←T[i]
T[i] ←temp
FinSI
FinPour
Fin
 
Pr. Er-rajy Latifa
Exercice 4. (Tri rapide-Recherches)

La méthode consiste à placer un élément du tableau (appelé pivot) à sa place

définitive, en permutant tous les éléments de telle sorte que tous ceux qui lui sont
inférieurs soient à sa gauche et que tous ceux qui lui sont supérieurs soient à sa
droite. Cette opération s’appelle le partitionnement. Pour chacun des sous tableaux
situés à droite et à gauche du pivot, on définit un nouveau pivot et on répète
l’opération de partitionnement. Ce processus est répété récursivement, jusqu’à ce
que l’ensemble des éléments soit trié. Généralement, on choisit comme pivot le
premier élément du tableau.

1- Trier le tableau suivant selon l’algorithme du tri rapide en donnant toutes les
étapes intermédiaires réalisées.

2- Ecrire l’algorithme qui réalise le tri rapide

3- Définir une fonction Recherche qui retourne un booléen pour indiquer si une
valeur x appartient à un tableau T de dimension N en utilisant les
recherches séquentielles et dichotomique.

Pr. Er-rajy Latifa

Exercice 4. (Tri rapide-Recherches)

La méthode consiste à placer un élément du tableau (appelé pivot) à sa place

définitive, en permutant tous les éléments de telle sorte que tous ceux qui lui sont
inférieurs soient à sa gauche et que tous ceux qui lui sont supérieurs soient à sa
droite. Cette opération s’appelle le partitionnement. Pour chacun des sous tableaux
situés à droite et à gauche du pivot, on définit un nouveau pivot et on répète
l’opération de partitionnement. Ce processus est répété récursivement, jusqu’à ce
que l’ensemble des éléments soit trié. Généralement, on choisit comme pivot le
premier élément du tableau.

1- Trier le tableau suivant selon l’algorithme du tri rapide en donnant toutes les
étapes intermédiaires réalisées.

Pr. Er-rajy Latifa

Exercice 4. (Tri rapide-Recherches) Solution :

On place un élément du tableau (ou pivot) à sa place définitive, On réalise un

partitionnement, par permutations telles que : Les élément inférieurs au pivot soient
à gauche du pivot et les élément supérieurs pivot soient à droite du pivot.
Pour chaque sous tableaux situés à droite et à gauche du pivot, on définit un
nouveau pivot et on répète l’opération de partitionnement jusqu’à ce que
l’ensemble des éléments soit trié.
Généralement, on démarre avec comme pivot le premier élément du tableau.

Étape 1: Choisir un pivot p

p i j r

143520 6 8 7
pivot

P: l'indice du 1er premier élément du Tableau

r: l'indice du dernier élément du Tableau
Pr. Er-rajy Latifa
Exercice 4. (Tri rapide-Recherches) Solution :

Étape 2:  
Échanger A( i ) et A( j ) pour maintenir A( i ) ≤ p et A ( j ) ≥ p : dans la premier
partition l’indice i avance en avant et il cherche un élément supérieur ou égale le
pivot. Dans la deuxième partition, j avance en arrière et il cherche un élément
inférieur ou égale au pivot

Étape 3:
On incrément i (i=2) jusqu’à ce que rencontre un élément plus grand que le pivot et
on décrémenter j jusqu’à ce que rencontré un élément plus petit que le pivot.
Jusqu’à ce que i et j se croisent. A ce moment il faut s’arrêter car si on contenir de
décrémenter i on va seulement trouver les éléments inférieurs au pivot.
0 1 2 3 4 5 6 7 8

0 1 4 3 5 2 6 8 7
Pr. Er-rajy Latifa
Exercice 4. (Tri rapide-Recherches) Solution :

Étape 4: On répété les mêmes étapes pour le tableau à gauche du pivot et le tableau
à droite de pivot.

q i j r

0 1 2 3 4 5 6 7 8

0 1 4 3 5 2 6 8 7
pivot

0 1 2 3 4 5 6 7 8

0 1 3 2 4 5 6 8 7
0 1 2 3 4 5 6 7 8

0 1 3 2 4 5 6 8 7
0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 8 7
0 1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 8 7

Pr. Er-rajy Latifa

Exercice 4. (Tri rapide-Recherches)

2- Ecrire l’algorithme qui réalise le tri rapide

• l a procédure partition, divise les éléments qui lui sont fournis en 2

parties, séparées par un élément d'indice q:
partie1 (T[p] … T[q-1]) + T[q] + Partie2 (T[q+1]...T[r])
• Tout élément de partie1 est inférieur à chaque élément partie2
• L'indice q est fourni par adresse

Pr. Er-rajy Latifa

 Exercice 4. (Tri rapide-Recherches) Solution :
Procédure Partition(tableau T : réel par adresse, p,r: entier par valeur, q: entier par adresse )
Variables i, j: entier
pivot: réel
pivot ←T[p], i←p+1, j ←r
TantQue (i<=j)
TantQue (i<=r et T[i] <=pivot)
i ←i+1
FinTantQue
TantQue (j>=p et T[j] >pivot )
j← j-1
FinTantQue
Si i < j alors
Echanger(T[i], T[j]), i← i+1, j ←j-1
FinSi
FinTantQue
Echanger(T[j], T[p])
q ←j
FinProcédure
Procédure TriRapide(tableau T : réel par adresse, p,r: entier par valeur)
variable q: entier
Si p <r alors
Partition(T,p,r,q)
TriRapide(T,p,q-1)
TriRapide(T,q+1,r)
FinSi
Fin Procédure Pr. Er-rajy Latifa
Exercice 4. (Tri rapide-Recherches) Solution :

Algorithme TRiSari3
Tableau T[10] :réel
variables i, n , p, r: entier
DEBUT
n10
Pour i allant de 0 à n-1
Ecrire("Donner la ", i+1, "e valeur")
Lire(T[i])
FinPour
p ←0
r←n-1
TriRapide(T, p,r)
fin

Pr. Er-rajy Latifa

Exercice 4. (Tri rapide-Recherches)

3- Définir une fonction Recherche qui retourne un booléen pour indiquer si une
valeur x appartient à un tableau T de dimension N en utilisant les
recherches séquentielles et dichotomique.

• La recherche séquentielle consiste à prendre les éléments de la liste les uns après
les autres, jusqu'à avoir trouvé la cible : Vérifier si T[i]=x.

• La recherche dichotomique : Inf , Sup, milieu ((Inf+Sup)div 2)

On compare x avec l'élément du milieu du Tableau T[iMilieu] :
- Si x < T[iMilieu], on cherche x dans la 1ère moitié du tableau
- Si x > T[iMilieu], on cherche x dans la 2ème moitié du tableau

Pr. Er-rajy Latifa

 Solution :

Fonction Recherche(x : réel, N: entier, tableau T : réel par adresse ) : booléen

Variable i: entier
Pour i allant de 0 à N-1
Si (T[i]=x) alors
retourne (Vrai)
FinSi
FinPour
retourne (Faux)
FinFonction

Pr. Er-rajy Latifa

 Solution :

Fonction Recherche(x : réel, N: entier, tableau T : réel par adresse) : booléen

variables inf, sup , milieu : entier
Trouvé : booléen
inf←0
sup←N-1
Trouvé ←Faux
TantQue (inf <=sup) ET (Trouvé=Faux)
milieu← (inf+sup) div 2
Si (x=T[milieu]) alors
Trouvé ←Vrai
SinonSi (x>T[milieu]) alors
inf←milieu+1
Sinon
sup←milieu-1
FinSi

FinTantQue
Retourne(Trouvé)
FinFonction
Pr. Er-rajy Latifa
Exercice 5. (Retour aux Matrices)

Soient deux matrices carrées A et B (NxN). Ecrire un algorithme qui permet de

calculer:

1- La matrice S somme des deux matrices A et B

Pr. Er-rajy Latifa

 Solution :

ALGORITHME SOM2MATRICES
Tableau A[10][10], B[10][10], S[10][10]: réel // somme de A et B
variables i, j, n : entier Pour i allant de 0 à n-1
DEBUT Pour j allant de 0 à n-1
n10 S[i][j] ←A[i][j]+B[i][j]
Pour i allant de 0 à n-1 FinPour
Ecrire("Donner la ligne:",i+1, “ de A”) FinPour
Pour j allant de 0 à n-1 //affichage de la matrice S
Lire(A[i][j]) Pour i allant de 0 à n-1
FinPour Pour j allant de 0 à n-1
FinPour Ecrire(S[i][j]," ")
Pour i allant de 0 à n-1 FinPour
Ecrire("donner la ligne ",i+1"de B") FinPour
Pour j allant de 0 à n-1 FIN
Lire(B[i][j])
FinPour
FinPour

Pr. Er-rajy Latifa

Exercice 5. (Retour aux Matrices)

Soient deux matrices carrées A et B (NxN). Ecrire un algorithme qui permet de

calculer:

2- La matrice P produit des deux matrices A et B.

Pr. Er-rajy Latifa

 Solution :

ALGORITHME Produit2MATRICES
Tableau A[10][10], B[10][10],P[10][10]: réel // Produit P = A*B tel que pij= somme des
VAR i, j, k, n, S : entier aik*bkj
DEBUT Pour i allant de 0 à n-1
n10 Pour j allant de 0 à n -1
Pour i allant de 0 à n-1 S ←0
Ecrire("Donner la ligne:",i+1, “ de A”) Pour k allant de 0 à n-1
Pour j allant de 0 à n-1 S ←S + A[i][k]*B[k][j]
Lire(A[i][j]) FinPour
FinPour P[i][j] ←S
FinPour FinPour
Pour i allant de 0 à n-1 FinPour
Ecrire("donner la ligne ",i+1"de B") //affichage de la matrice P
Pour j allant de 0 à n-1 Pour i allant de 0 à n-1
Lire(B[i][j]) Pour j allant de 0 à n-1
FinPour Ecrire(P[i][j]," ")
FinPour FinPour
FinPour
Fin

Pr. Er-rajy Latifa

Exercice 5. (Retour aux Matrices)

Soient deux matrices carrées A et B (NxN). Ecrire un algorithme qui permet de

calculer:

3- Écrire un algorithme qui donne la transposé d'une matrice carré NxN.

Pr. Er-rajy Latifa

 Solution :

ALGORITHME TRANSPOSE
Tableau A[10][10], T[10][10]: réel //affichage de la matrice T
VAR i, j : entier Pour i allant de 0 à n-1
DEBUT Pour j allant de 0 à n-1
n10 Ecrire(T[i][j]," ")
Pour i allant de 0 à n-1 FinPour
Ecrire("Donner la ligne:",i+1, “ de A”) FinPour
Pour j allant de 0 à n-1 Fin
Lire(A[i][j])
FinPour
FinPour
Pour i allant de 0 à n-1
Pour j allant de 0 à n-1
T[i][j]A[j][i]
FinPour
FinPour

Pr. Er-rajy Latifa