Module: ALGORITHMIQUE 1

Chapitre 4: Les Vecteurs et les Matrices

Niveaux: 1A
Equipe ALGO

Année universitaire:
2021/2022

1
Objectifs
A la fin de ce chapitre, l’étudiant sera capable de:

• Connaître les tableaux uni et bidimensionnels.

• Manipuler les tableaux: Accès, Remplisage, Affichage et Recherche d’une

valeur.

• Manipuler les algorithmes de tri (tri par sélection, tri à bulles, tri par insertion)
& la recherche Dichotomique

2
 Problématique
Calculer la moyenne d’un nombre fini d’étudiants d’une classe, puis afficher les étudiants
par ordre de mérite : de la plus forte moyenne jusqu’à la plus faible.
Quelle solution allez-vous proposer ?
Structure répétitive: Permettra de traiter la moyenne de chaque étudiant (calcul et affichage)
L’affichage des étudiants par ordre de mérite nécessite la disponibilité de toutes les moyennes
déjà calculées.
Déclarer autant de variables moyennes que d’étudiants:
On écrira autant de blocs d’instructions que de nombre d’étudiants.
Algorithme de mauvaise qualité.
Un nom pour chaque variable.

Aucun lien entre les différentes variables.

 Solution
▪Utiliser une structure de données capable de mémoriser les moyennes dans un seul
endroit, pour les retrouver ultérieurement et effectuer d’autres traitements (Tri, Mise à
jour, etc.).
▪Une telle structure est appelée Tableau.

Tableau pour stocker ces moyennes + Accès à l’aide d’un indice.

15 12 10 9 13 20
Moyennes

Indices 1 2 3 4 5 6

Moyenne de l’élève
 Utilité
✔ Un tableau est une structure de données constituée d'un nombre fini d'éléments
de même type.
✔ Facilite la gestion des données de même type, destinées au même traitement et qui
doivent être accessibles le long d'un programme.

On distingue deux catégories de tableaux :

- Les tableaux à une dimension (unidimensionnels) appelés également Vecteurs.
- Les tableaux à deux dimensions (bidimensionnels) appelés également Matrices.
Les tableaux Unidimensionnels
Vecteurs

6
 Définition
● Un vecteur est une variable structurée formée d’un nombre fini de variables de
même type, qui sont appelées les éléments (ou composantes) du tableau.
● La représentation d’un tableau se fait toujours de manière contigüe (bloc d’éléments
non-séparés).

● Un tableau est caractérisé par:

✔ Son nom
✔ Sa taille
✔le types des éléments

● L’accès à un élément du tableau est direct et se fait à l’aide d’un indice.

 Déclaration d’un tableau
Syntaxe
TYPE
Nom_Tab = Tableau [borne_Inf..borne_Sup] de Type_Element
VARIABLE
Nomvar : Nomtableau
Indice : entier
▪ Nom_Tab : l'identificateur du tableau
▪ Type_Element : les éléments du tableau sont caractérisés par leur type (e.g. entier, réel)
Exemples :
TYPE
Tab : Tableau [1..50] de caractère
VARIABLE
T1: Tab
i: entier
 Déclaration d’un tableau

L’utilisation des constantes est recommandée pour définir la capacité du tableau.

Constante Syntaxe
NMAX = 20
Type
TabEnt = Tableau [1..NMAX] d’entier
Variable
T : TabEnt
i:entier
 Représentation

On va avoir une variable T comportant 20 cases et dans chacune on placera un entier.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

T 10 3 7 13 20 18 19 9 8 5 3 0 14 13 11 16 16 15 20 17

•Le premier élément de T contient la valeur 10 ; on note T[1] 10

•Le deuxième élément de T contient la valeur 3 ; on note T[2] 3
D’une manière générale, T[I] désigne le contenu de la Ième case du tableau T.
On le note également par T(I).
Opérations de base
Accès / Initialisation/ Remplissage
Affichage/ Recherche
Accès
T ‘A’ ‘B’ ‘C’ ‘D’ ‘E’ ‘F’
Indices 1 2 3 4 5 6

Contenu T[1] T[2] T[3] T[4] T[5] T[6]

● Considérons un tableau T de dimension N :

○ L’accès au premier élément du tableau se fait par T[1]

○ L’accès au dernier élément du tableau se fait par T[N]
○ L’accès à l’élément i du tableau se fait par T[i]
Initialisation d’un tableau
Placer une même valeur dans les différentes cases du vecteur (exemple initialisation par 0)

Algorithme Ini_Tab
Constante N = 20
Type TabEnt = Tableau [1..N] de Entier
Variable T : TabEnt
I : entier
Début
Pour I allant de 1 à N faire
T(I) 0
Fin Pour
Fin
13
 Remplissage d’un tableau
Algorithme Remp_Tab
Constante N = Val
Type TabEnt = Tableau [1..N] de Entier
Variable T : TabEnt
I : entier
Début
Pour I allant de 1 à N faire
Lire(T(I))
Fin Pour
Fin
Remarque :
14
Lire(T(I)) consiste à entrer une valeur et la mémoriser dans la Ième case du tableau T : Lire (T(I)) ⬄ { Lire(X), T(I) X}
Affichage d’un tableau
Algorithme Aff_Tab
Constante N = Val
Type TabEnt = Tableau [1..N] de Entier
Variable T : TabEnt
I : entier
Début
Pour I allant de 1 à N faire
Écrire(T(I))
Fin Pour
Fin
15
Recherche Séquentielle
Chercher un élément X saisi par l’utilisateur, dans un tableau T.

Algorithme Rech_Seq
Constante N = 20
Type TabEnt = Tableau [1..N] de Entier
Variable T : TabEnt
I : entier
X : entier (* X est l’élément à chercher dans le tableau *)
Trouve : Booléen (* cette variable va nous permettre de sortir dès qu’on trouve X *)
Début
Lire(X)
I 1
Trouve Faux
Tant que ((I<=N) et (Trouve = Faux)) Faire
Si (T(I) <> X) Alors I I+1
Sinon Trouve Vrai
Fin Si
Fin Tant que
Si (Trouve = Vrai) Alors Écrire(X, ‘appartient à T’)
Sinon Écrire (X,’ne se trouve pas dans T’)
Fin Si
Fin
Recherche Séquentielle
Chercher un élément val saisi, dans un tableau T et affichage de son indice.

Algorithme Recherche
Constante N = 20
Type TabEnt = Tableau [1..N] de Entier
Variable
i, val : Entier
T: TabEnt
Début
Lire(val)
i 0
Répéter
i i+1
Jusqu’à ((T[i] = val) ou (i > n))
Si (T[i] = val) Alors
Ecrire(‘Indice = ’, i)
Sinon
Ecrire(‘Elément introuvable…’)
FinSi
Fin
Exercice d’application 1:
On dispose de deux tableaux T1 et T2 de même taille et leurs éléments de même type.
Ecrire un algorithme permettant de faire le produit de tableaux et de stocker dans un tableau T3.

1 2 3 4 5

T1 10 3 7 13 20

1 2 3 4 5

T2 2 3 5 1 2

1 2 3 4 5

T3 20 9 35 13 40
Exercice d’application 2:
Soit T un tableau contenant n éléments de type entier. Ecrire un algorithme MinTab qui retourne le plus
petit élément de ce tableau.
Algorithme MinTab
Type TabEnt = Tableau [1..20] de Entier
Variable
min, i : Entier
T: TabEnt
Début
Lire(N)
Pour i allant de 1 à N faire
Lire(T[I])
Fin Pour
min T[1]
Pour i de 2 à N Faire
Si (T[i] < min) Alors
min T[i]
FinSi
FinPour
Ecrire(‘Le plus petit élément du tableau est’, min)
Fin 19
Les tableaux Bidimensionnels
Matrices

20
 Définition

Une matrice est une structure de données permettant de

regrouper sous un même nom de variable un nombre fini d’
éléments de même type, organisés en lignes et en colonnes.

● L : nombre de lignes du tableau

● C : nombre de colonnes du tableau

● Un tableau à deux dimensions contient L*C éléments

 Représentation
Indice du Indice du
ligne colonne Colonnes

Mat[1,1] 1 2 3 4 Mat[1,4]

2
Lignes
Mat[3,3]
3

4 Mat[4,4] 22
Mat[4,1]
 Déclaration d’une matrice
Syntaxe
TYPE
Nom_Tab = Tableau [1..NbLigne, 1..NbColonne] de Type_Element
VARIABLE
M: Nom_Tab
i,j: entier (* i étant l’indice des lignes et j celui des colonnes *)

Type_Element : les éléments du tableau sont caractérisés par leur type (entier, réel)

Exemples :
TYPE
Mat = Tableau [1..30, 1..30] d’entier
VARIABLE
M: Mat
 Déclaration d’une matrice

L’utilisation des constantes est recommandée pour définir la capacité

(dimension) de la matrice
Syntaxe
Constante
LMAX = 30
CMAX = 20
Type
Mat = Tableau [1..LMAX, 1..CMAX] d’entier
Variable
M : Mat
Opérations de base
Accès / Initialisation/ Remplissage
Affichage/ Recherche
Accès
● Considérons un tableau M de L lignes et C colonnes :
○ Les indices du tableau M varient de 1 à L en ligne et de 1 à C en colonne
○ L’accès à un élément de la matrice ne peut se faire qu’avec deux indices
○ La composante de la ième ligne et jème colonne est notée M[i, j] ou M(i,j)

Exemple
M : tableau de 3 lignes et 4 colonnes
Initialisation d’une matrice

Exemple : Remise à zéro des éléments d’une matrice M.

Pour I allant de 1 à Nbr_Lig Faire

Pour J allant de 1 à Nbr_Col Faire
M(I,J) 0
Fin Pour
Fin Pour

27
Remplissage d’un tableau bidimensionnel

Algorithme Remplissage
Constante
L=3
C= 4
Type Mat : Tableau [1..L, 1..C] d’entier
Variable
M : Mat
i, j : entier
Début
Pour i allant de 1 à L Faire
Pour j allant de 1 à C Faire
écrire(‘ Saisir M[‘, i, ‘, ‘, j, ‘] : ‘)
lire(M[i, j])
Fin pour
Fin pour
Fin 3
2
Affichage d’un tableau bidimensionnel

Algorithme Affichage
Constante
L=3
C= 4
Type Mat : Tableau [1..L, 1..C] d’entier
Variable
M : Mat
i, j : entier
Début
Pour i allant de 1 à L Faire
Pour j allant de 1 à C Faire
écrire(M[i, j])
Fin pour
Fin pour
Fin

3
3
Recherche d’un élément
Algorithme Rech_Matrice
Constante Nbr_Lig = Val1 (* Nombre de Lignes *)
Nbr_Col = Val2 (* Nombre de Colonnes *)
Type Matrice = Tableau [1..Nbr_Lig, 1..Nbr_Col] de Type_Élément_Matrice
Variable M : Matrice
I, J : Entier (* I étant l’indice des lignes et J celui des colonnes *)
X : Entier
Trouve : Booléen
Début
Lire(X)
I 1
Trouve Faux
Tant que (I<=Nbr_Lig) et (Trouve =Faux) Faire
J 1
Tant que (J<= Nbr_Col) et (Trouve=Faux) Faire
Si (M(I,J) = X) Alors Trouve Vrai
Sinon J J+1
Fin Si
Fin Tant que
I I+1
Fin Tant que
Si (Trouve = Vrai) Alors Écrire (X, ‘se trouve dans la matrice’)
Sinon Écrire (X,’est inexistant dans la matrice’)
Fin Si
Fin
Exercice d’application 3

Ecrire un algorithme permettant d’afficher tous les éléments d’une

matrice dont la valeur est supérieure à une valeur V introduite.

1 12 20 15

13 9 3 17
8 10 11 5

V=10
Output: 12, 20, 15, 13, 17, 11
Exercice d’application 4
Soient M1 et M2 deux matrices à 3 lignes et 4 colonnes.
On veut écrire un algorithme qui calcule la somme des éléments de la matrice
M3=M1+M2
Hypothèse : les deux matrices doivent être de même type et de même taille.
Algorithme Somme_Mat
TYPE
Mat = Tableau [1..3, 1..4] de entier
Variable
i, j : Entier
M1,M2,M3: Mat
Début
Pour i allant de 1 à 3 Faire
Pour j allant de 1 à 4 Faire
M3[i,j] M1[i,j]+ M2[i,j]
FinPour
FinPour
Fin