Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri

ère
Dr. Mohamed BADECHE Tronc Commun – MI,, Faculté NTIC – 1 Année (2021-2022)

Université Abdelhamid Mehri – Constantine 2

2021-2022. Semestre 1

Initiation à l’algorithmique

Chapitre 4 : Tableaux et Matrices

atrices

Chargé de cours
Nom Grade Faculté/Institut Adresse e-mail
e
BADECHE Mohamed MCB Nouvelles Technologies [email protected]
algo.assistance

Etudiants concernés
Faculté/Institut Département Année Spécialité
Nouvelles Technologies MI Licence 1 Tronc commun

Objectifs :
Introduire la notion de tableaux.
Apprendre à déclarer et manipuler un tableau.
tableau
Apprendre à déclarer et manipuler une matrice.
matrice
Introduire la notion de constantes et de nouveaux types.
Présenter la notion de structure ‘statique’ d’un tableau.
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

Sommaire
Chapitre 4 : Tableaux et Matrices ........................................................................................................................................... 1
4.1. Tableaux ....................................................................................................................................................................... 1
4.1.1. Introduction à la notion de tableaux .................................................................................................................... 1
4.1.2. Déclaration d’un tableau ...................................................................................................................................... 3
4.1.3. Lecture, écriture et parcours d’un tableau ........................................................................................................... 4
4.1.4. Notion de structure ‘statique’ d’un tableau ......................................................................................................... 5
4.1.5. Tableaux en langage C .......................................................................................................................................... 5
4.1.6. Exercices ............................................................................................................................................................... 6
4.2. Matrices ....................................................................................................................................................................... 7
4.2.1. Introduction à la notion de matrices .................................................................................................................... 7
4.2.2. Déclaration d’une matrice .................................................................................................................................... 8
4.2.3. Lecture, écriture et parcours d’une matrice ......................................................................................................... 9
4.2.4. Matrices en langage C ......................................................................................................................................... 10
4.2.5. Exercices ............................................................................................................................................................. 10
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

Chapitre 4 : Tableaux et Matrices

4.1. Tableaux

4.1.1. Introduction à la notion de tableaux

Supposons qu’on veut écrire un algorithme qui demande cinq (5) notes, et affiche les notes qui sont supérieures
à la moyenne. Dans ce cas, on doit commencer par calculer la moyenne, puis d’afficher dans un deuxième
temps, les valeurs supérieures à cette moyenne, comme suit :

Algo Moy
Variables
a, b, c, d, e, Moy : Réel
Début
Lire(a,b,c,d,e)

Moy (a+b+c+d+e)/5

Si a ≥ Moy :
Ecrire(a)
FSi
Si b ≥ Moy :
Ecrire(b)
FSi
Si c ≥ Moy :
Ecrire(c)
FSi
Si d ≥ Moy :
Ecrire(d)
FSi
Si e ≥ Moy :
Ecrire(e)
FSi
Fin

Imaginons qu’on veut faire le même traitement, mais sur 100 notes au lieu de 5. Dans ce cas, il sera
pratiquement impossible de travailler avec 100 variables. La solution est d’utiliser une nouvelle structure de
donnée, à savoir le Tableau1, qui permet la sauvegarde de 100 notes dans une même variable composée T :

1
Aussi appelé ‘Vecteur’ dans certaines références bibliographiques.
1
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

Algo Moy_Tab
Variables
T : Tableau de 100 Réel
i : Entier
Moy : Réel
Début
Pour i 1 à 100 :
Lire(T(i))
FPour

Moy 0
Pour i 1 à 100 :
Moy Moy + T(i)
FPour
Moy Moy / 100
Ecrire(Moy)
Pour i 1 à 100 :
Si T(i) ≥ Moy :
Ecrire(T(i))
FSi
FPour
Fin

Un tableau à une dimension est donc, une variable composée de plusieurs éléments repérés par des indices :

T indices 1 2 3 4 5 6 7 8 9 10
Éléments 11.5 13.25 10 8.75 15 9 7.5 12 14 10.25
Le tableau précédent appelé T, se compose de dix (10) éléments (cases) repérés par des indices (de 1 à 10)2,
chaque élément contient une valeur réelle. T(1) par exemple, est le premier élément du tableau, il contient la
valeur 11.5, T(2) est le deuxième, il contient la valeur 13.25 et T(10) quant à lui, est le dixième élément, il
contient 10.25. Le nombre d’éléments, ici 10, représente la taille du tableau.
Il faut donc différencier entre l’indice d’un élément (son numéro) et l’élément lui-même qui contient la valeur
proprement dite.

Nom du tableau T(i) L’indice

L’élément

2
De 0 à 9 dans certains langages de programmation comme le langage C
2
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.1.2. Déclaration d’un tableau

On déclare le tableau de l’exemple précédent comme suit :

Taille du tableau
Nom de la variable tableau
T : Tableau de 100 Réel Type des éléments du tableau

Un tableau donné peut contenir des éléments de n’importe quel type, mais d’un seul type à la fois ; on ne peut
pas avoir des éléments de différents types dans le même tableau.

a. Notion de ‘Constante’

L’un des avantages de cette structure de données (les tableaux) est que les algorithmes écrits pour un tableau de
100 éléments par exemple, peuvent facilement être modifiés pour fonctionner avec un tableau d’une autre taille,
il suffit de remplacer toute occurrence de la taille 100 par sa nouvelle valeur.
Afin de rendre cette tâche de modification plus simple, on fait recours à la notion de déclaration de constantes.
A la différence d’une variable, une constante est déclarée pour ne pas être modifiée par la suite dans le corps de
l’algorithme. On la déclare dans un bloc à part comme suit :
Algo Moy_Tab_Cons
Constantes
D = 100
Variables
T : Tableau de D Réel
i : Entier
Moy : Réel
Début
Pour i 1 à D :
Lire(T(i))
FPour

Moy 0
Pour i 1àD:
Moy Moy + T(i)
FPour
Moy Moy / D
Ecrire(Moy)
Pour i 1àD:
Si T(i) ≥ Moy :
Ecrire(T(i))
FSi
FPour
Fin

Par la suite, si on veut modifier l’algorithme pour fonctionner sur un tableau de 1000 éléments, il suffit de
remplacer la valeur de D dans le bloc Constantes par 1000.

3
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

b. Déclaration de nouveau type

L’algorithmique offre d’autre part, un outil permettant de définir de nouveaux types, comme suit :
Déclaration sans définition de nouveaux types Déclaration avec définition d’un nouveau type TAB
Constantes Constantes
D = 100 D = 100
Variables Types
T : Tableau de D Réel TAB = Tableau de D Réel
Moy : Réel Variables
T : TAB
Moy : Réel
4.1.3. Lecture, écriture et parcours d’un tableau
Dans l’exemple précédent, la première boucle permet de lire le tableau, élément par élément :
Pour i 1àD:
Lire(T(i))
FPour
Il n’est pas possible de lire un tableau d’un coup comme un seul bloc. L’instruction Lire(T) n’est pas correcte.
Il faut procéder élément par élément, généralement à travers une boucle.
De même pour écrire un tableau, on ne peut pas agir directement en une seule instruction : Ecrire(T), mais il
faut procéder élément par élément, généralement à travers une boucle :
Pour i 1àD:
Ecrire(T(i))
FPour
Lecture d’un tableau Exemple de traitement d’un tableau Affichage d’un tableau
Pour i 1àD: Moy 0 Pour i 1àD:
Lire(T(i)) Pour i 1 à D : Ecrire(T(i))
FPour Moy Moy + T(i) /100 FPour
FPour
Dans l’exemple précédent, on peut fusionner les deux premières boucles pour permettre la lecture et le calcul de
la moyenne en même temps, mais on ne pourra pas fusionner la dernière boucle d’affichage dans ce cas,
puisqu’il faut calculer la moyenne en premier, et faire une deuxième passe pour afficher les notes qui sont
supérieures à la moyenne :
Algo Moy_Tab_Cons
Constantes
D = 10
Variables
T : Tableau de D Réel
i : Entier
Moy : Réel
Début
Moy 0
Pour i 1 à D :
Lire(T(i))
Moy Moy + T(i) /D
FPour
Ecrire(Moy)
Pour i 1 à D :
Si T(i) ≥ Moy :
Ecrire(T(i))
FSi
FPour
Fin
4
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.1.4. Notion de structure ‘statique’ d’un tableau

On qualifie la structure d’un tableau de ‘statique’, dans le sens où la taille du tableau doit être définie une fois
pour toute dans le bloc déclaration, et ne peut être modifiée par la suite dans le corps de l’algorithme.

Dans le cas, où on prévoit un tableau pour contenir un nombre de données inconnu préalablement, comme pour
le nom de l’utilisateur par exemple, on peut déclarer un tableau avec une taille maximale possible pour contenir
un nom, et ne pas utiliser par la suite, toutes les cases du tableau dans le cas de noms plus courts.

4.1.5. Tableaux en langage C

Voici ci dessous, l’équivalent en langage C du pseudo code de l’exemple de ce cours :

Pseudo code Equivalent en langage C

Algo Moy_Tab_Cons #include<stdio.h>
Constantes const int D = 5;
D=5
main()
Variables {
T : Tableau de D Réel float T[D];
i : Entier int i;
Moy : Réel
float Moy;
Début
Pour i 1àD: for(i=0;i<D;i++)
Lire(T(i)) {
FPour scanf("%f",&T[i]);
}

Moy 0 Moy = 0;
for(i=0;i<D;i++)
Pour i 1àD:
{
Moy Moy + T(i)
FPour Moy = Moy + T[i];
Moy Moy / D }
Ecrire(Moy) Moy = Moy / D;
printf("%f\n",Moy);

Pour i 1àD: for(i=0;i<D;i++)

Si T(i) ≥ Moy : {
Ecrire(T(i)) printf("%f",T[i]);
FSi }
FPour }
Fin

5
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.1.6. Exercices
Exercice 01:
a- Écrire un algorithme qui permet à l’utilisateur de remplir un tableau de 30 caractères (dans une boucle à
part), et affiche le nombre de voyelles de ce tableau. Note : les voyelles sont : a, e, i, o, u, y.
b- Écrire un algorithme qui permet à l’utilisateur de remplir un tableau de 25 entiers (dans une boucle à part), et
affiche le nombre, la somme et le pourcentage d’éléments impairs du tableau.

Exercice 02:
Écrire un algorithme qui permet à l’utilisateur de remplir un tableau de 50 réels (dans une boucle à part), et
d’afficher :
a- la plus grande valeur.
b- la plus grande valeur et son indice. S’il y a plusieurs éléments qui donnent la même plus grande valeur,
l’algorithme devra afficher le plus petit indice.
c- la plus grande valeur et son indice. S’il y a plusieurs éléments qui donnent la même plus grande valeur,
l’algorithme devra afficher tous les indices correspondants.

Exercice 03:
Écrire un algorithme qui demande de remplir deux tableaux A et B, de 45 réels chacun (dans deux boucles à
part), et de les additionner dans un troisième tableau C, élément par élément, d’afficher le contenu de C, puis de
calculer et d’afficher leur produit scalaire.

Exercice 04:
Écrire un algorithme qui demande de remplir un tableau de 30 caractères (dans une boucle à part), et faire un
décalage circulaire du tableau :
a- vers la gauche d’une position.
b- vers la droite d’une position.
c- vers la droite de K positions.
d- vers la gauche d’une position à partir du nème élément.
On doit à la fin, afficher pour chaque cas le contenu du tableau après décalage.

Exercice 05:
Écrire un algorithme qui demande de remplir un tableau de 20 chaines de caractères (dans une boucle à part), et
d’inverser les valeurs de ce tableau (la valeur du 1ère élément sera rangée dans le dernier, celle du 2ème élément
sera rangée dans l’avant dernier et ainsi de suite):
a- dans un autre tableau.
b- dans le même tableau initial, sans utiliser aucun autre tableau intermédiaire.
L’algorithme doit à la fin, afficher le tableau résultant.

6
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.2. Matrices

4.2.1. Introduction à la notion de matrices

Une matrice est un tableau à plusieurs dimensions. Nous allons nous limiter à deux (2) dimensions dans ce
semestre.
Supposons qu’on veut écrire un algorithme qui demande les notes de 100 étudiants dans quatre (4) matières
différentes et calcule la moyenne de chacune des quatre matières.
On peut penser à utiliser quatre tableaux de 100 éléments chacun, ou d’utiliser plus simplement une matrice à
deux dimension comme suit :
Algo Moy_Mat
Variables
M : Tableau de 4 * 100 Réel
i, j : Entier
Moy : Réel
Début
Pour i 1 à 4 :
Pour j 1 à 100 :
Lire(M(i,j))
FPour
FPour

Pour i 1à4:
Moy 0
Pour j 1 à 100 :
Moy Moy + M(i,j) /100
FPour
Ecrire(Moy)
FPour
Fin

Une matrice à deux dimensions est donc, une variable composée de plusieurs éléments repérés chacun par deux
indices.
M Colonnes
lignes 1 2 3 4 5 6 7 8 9 10
1 11.5 13.25 10 8.75 15 9 7.5 12 14 10.25
2 10.75 10.5 7.25 6.25 11.25 15.75 2 11.25 17.75 4
3 9 17.25 5 7 16.5 2.75 9.5 17.25 14.5 8.5
4 8.25 6.75 3.75 11 13.75 9 10.25 9.5 12.75 13.75
La matrice précédente appelée M, se compose de quatre (4) lignes et dix (10) colonnes, soit en tout 40 éléments
(cases) repérés chacun par deux indices à la fois, le premier représente le numéro de ligne et le deuxième
représente le numéro de colonne. M(1,1) par exemple, est le premier élément de la matrice, il contient la valeur
11.5, M(1,10) est le dernier élément de la première ligne, il contient la valeur 10.25, M(2,9) est l’élément situé
sur la deuxième ligne et la neuvième colonne, il contient la valeur 17.75, et M(5,10) quant à lui, est le dernier
élément de la matrice, il contient 13.75.

Nom de la matrice M(i,j) Indices : i représente le numéro de ligne

j représente le numéro de colonne
Elément

7
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.2.2. Déclaration d’une matrice

On déclare une matrice à deux dimensions comme suit :

Dimensions d’une matrice

Nom de la variable matrice
M : Tableau de 5 * 100 Réel Type des éléments de la matrice

Remarquez que dans la déclaration d’une matrice, on écrit le mot clé ‘tableau’ et non pas ‘matrice’, puisque
cette dernière n’est autre qu’un tableau à deux dimensions3.
Dans ce cours, quand on parle de ‘tableau’, on veut dire tableau à une dimension (l’équivalent de ‘vecteur’ dans
certaines références), et on désigne par ‘matrices’, les tableaux à plusieurs dimensions.

De la même manière qu’un tableau, une matrice donnée peut contenir des éléments de n’importe quel type,
mais d’un seul type à la fois, et on peut utiliser des constantes qui représentent les dimensions de la matrice.
Algo Moy_Mat_Cons
Constantes
D1 = 5
D2 = 100
Variables
M : Tableau de D1 * D2 Réel
i, j : Entier
Moy : Réel
Début
Pour i 1 à D1 :
Pour j 1 à D2 :
Lire(M(i,j))
FPour
FPour

Pour i 1 à D1 :
Moy 0
Pour j 1 à D2 :
Moy Moy + M(i,j) /D2
FPour
Ecrire(Moy)
FPour
Fin

La définition d’un nouveau type ‘Matrice’ se fait comme suit :

Déclaration sans définition de nouveaux types Déclaration avec définition d’un nouveau type MAT
Constantes Constantes
D1 = 5 D1 = 5
D2 = 100 D2 = 100
Variables Types
M : Tableau de D1 * D2 Réel MAT = Tableau de D1 * D2 Réel
Moy : Réel Variables
M : MAT
Moy : Réel

3
Ou plusieurs dimensions de façon générale.

8
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.2.3. Lecture, écriture et parcours d’une matrice

La lecture et l’écriture d’une matrice ne peut pas se faire d’un coup comme un seul bloc. Les instructions
Lire(M) et Ecrire(M) ne sont pas correctes. Il faut procéder élément par élément, généralement à travers deux
boucles, l’une pour parcourir les lignes de la matrice et l’autre pour parcourir ses colonnes (ou l’inverse) :
Pour i 1 à D1 :
Pour j 1 à D2 :
Lire(M(i,j))
FPour
FPour

Pour i 1 à D1 :
Pour j 1 à D2 :
Ecrire(M(i,j))
FPour
FPour

Lecture d’une matrice Exemple de traitement d’une matrice Affichage d’une matrice
Pour i 1 à D1 : Pour i 1 à D1 : Pour i 1 à D1 :
Pour j 1 à D2 : Moy 0 Pour j 1 à D2 :
Lire(M(i,j)) Pour j 1 à D2 : Ecrire(M(i,j))
FPour Moy Moy + M(i,j) /D2 FPour
FPour FPour FPour
Ecrire(Moy)
FPour

Le parcours d’une matrice se fait ligne par ligne si on commence par la boucle qui parcourt les lignes (comme
dans l’exemple précédent), ou colonne par colonne, si on commence par la boucle qui parcourt les colonnes.

9
Cours : Initiation à l’algorithmique Université Constantine 2 – Abdelhamid Mehri
ère
Dr. Mohamed BADECHE Tronc Commun – MI, Faculté NTIC – 1 Année (2021-2022)

4.2.4. Matrices en langage C

Voici ci dessous, l’équivalent en langage C du pseudo code de l’exemple de ce cours utilisant une matrice :

Pseudo code Equivalent en langage C

Algo Moy_Mat_Cons #include<stdio.h>
Constantes const int D1 = 2;
D1 = 2 const int D2 = 3;
D2 = 3
main()
Variables {
M : Tableau de D1 * D2 Réel float M[D1][D2];
i, j : Entier int i, j;
Moy : Réel float Moy;

Début for(i=0;i<D1;i++)
Pour i 1 à D1 : {
Pour j 1 à D2 : for(j=0;j<D2;j++)
Lire(M(i,j)) {
FPour scanf("%f",&M[i][j]);
FPour
}
}

Pour i 1 à D1 : for(i=0;i<D1;i++)
Moy 0 {
Moy = 0;
Pour j 1 à D2 : for(j=0;j<D2;j++)
Moy Moy + M(i,j) /D2 {
FPour Moy = Moy + M[i][j]/D2;
}
Ecrire(Moy) printf("%f\n",Moy);
FPour }
Fin }

4.2.5. Exercices
Exercice 01:
Écrire un algorithme qui demande de remplir une matrice de 5×3 réels, et met Zéro dans tous les éléments de la
ligne 4 et la colonne 2, puis affiche la matrice résultante.

Exercice 02:
a- Écrire un algorithme qui demande de remplir un tableau de 25 réels et vérifie s’il est trié dans l’ordre
croissant ou pas.
b- Écrire un algorithme qui demande de remplir une matrice de 25×5 réels et vérifie si elle est triée dans l’ordre
décroissant ou pas. Note : pour qu’une matrice soit triée, il faut que les lignes soient triées et que le dernier
élément d’une ligne soit trié par rapport au premier élément de la ligne suivante.

Exercice 03:
Écrire un algorithme qui demande de remplir deux matrices A de 4×2 réels, et B de 2×3 réels, et calcule le
produit matriciel dans une troisième matrice C, dont il affiche le contenu à la fin.

10