Chapitre05 : Les tableaux

Introduction au langage C++
Chapitre 5
Les tableaux
Youssouf EL ALLIOUI, youssouf.elallioui@uhp.ac.ma
Université Hassan Premier de Settat
Ce cours est disponible en format électronique sur http://fr.slideshare.net/yelallioui/
Objectif de ce chapitre
Les variables, telles que nous les avons vues dans les chapitres précédents, ne
permettent de stocker qu'une seule donnée à la fois. Or, pour de très nombreux
programmes, on a besoin d'avoir plusieurs données du même type et qui jouent quasiment
le même rôle. Pensez par exemple à la liste des utilisateurs d'un site web, cela représente
plusieurs variables de type string.
L’utilisation des variables distinctes, dans ce cas, seraient beaucoup trop lourdes à
gérer. Heureusement, le C++ propose un moyen simple de regrouper ces données dans
un seul support. Il s’agit des tableaux.
Les tableaux sont des structures de données constituées d'un certain nombre
d'éléments de même type. Ils correspondent aux vecteurs et matrices en mathématiques.
Un tableau est caractérisé par sa taille et par le type de ses éléments.
Dans ce chapitre, je vais vous apprendre à manipuler deux sortes de tableaux :
 Les tableaux statiques : ceux dont la taille est connue à l'avance, elle est
donc figée une fois pour toute et ne peut pas être modifiée en cours
d'exécution du programme.
2016

1 | 16
1 Introduction au langage C++ | Chapitre 5 : Les tableaux
 Les tableaux dynamiques : ceux dont la taille peut varier au cours de
l'exécution du programme.
Les chaînes de caractères sont déclarées en C++ comme tableaux de caractères et
permettent l'utilisation d'un certain nombre de notations et de fonctions spéciales. Les
particularités des tableaux de caractères seront traitées séparément à la fin de ce
chapitre.
Entraînez-vous via
 Exercices applicatifs
 QCM fourni à la fin de la séance
 Les TPs
Sommaire
I. Les tableaux unidimensionnels ________________________________________2
I. 1. Les tableaux unidimensionnels statiques _____________________________2
I. 2. Les tableaux unidimensionnels dynamiques (vector)__________________5
II. Les tableaux multidimensionnels_______________________________________9
II. 1. Les tableaux multidimensionnels statiques __________________________10
II. 2. Les tableaux multidimensionnels dynamiques ________________________11
III. Les strings sont des tableaux de caractères (lettres)_____________________11
III. 1. Déclaration ___________________________________________________11
III. 2. Accès aux lettres_______________________________________________12
III. 3. Les fonctions de manipulation de chaînes de caractères ________________12
III. 4. Exemples_____________________________________________________13
IV. Tri des tableaux en C++ ___________________________________________14
IV. 1. Tri à bulles__________________________________________________14
IV. 2. Tri par sélection _____________________________________________14
IV. 3. Tri par insertion _____________________________________________15
IV. 4. Autres algorithmes de tri ______________________________________16
V. Ce que vous devez retenir ! __________________________________________16
Références
Cours de C/C++ [Ouvrage] / aut. Casteyde Christian. - 2001. - Vol. Version 1.40.1 : p. 501.
Programmer en langage C : Cours et exercices corrigés [Ouvrage] / aut. Delannoy
Claude. - [s.l.] : EYROLLES, 2008.
Programmez avec le langage C++ [Ouvrage] / aut. Mathieu Nebra et Matthieu Schaller. -
[s.l.] : le Livre du Zéro, 2015.

2 | 16
I. Les tableaux unidimensionnels
Un tableau unidimensionnel est un tableau qui contient des éléments simples (des éléments
qui ne sont pas des tableaux) de même type.
Dans cette partie, je vais vous apprendre à manipuler deux sortes de tableaux
unidimensionnels :
- Les tableaux statiques : Ceux dont la taille est connue à l'avance, et
- Les tableaux dynamiques : ceux dont la taille peut varier en permanence.
I. 1. Les tableaux unidimensionnels statiques
I. 1. 1. Déclaration
Comme toujours en C++, une variable est composée d'un nom et d'un type. Comme les
tableaux sont des variables, cette règle reste valable. Il faut juste ajouter une propriété
supplémentaire, la taille du tableau.
La syntaxe de la définition d'un tableau unidimensionnel est la suivante :
1 type nomDuTableau [taille];
- type : définit le type des éléments que contient le tableau
- nomDuTableau : est le nom que l'on décide de donner au tableau,
- taille : est un nombre entier qui détermine le nombre de cases que le tableau
doit comporter
NB :
 Rappelez-vous qu’un tableau en langage C++ est composé uniquement d'éléments de
même type.
 Le nom du tableau suit les mêmes règles qu'un nom de variable.
Voici quelques exemples de déclaration des tableaux :
1 int meilleurScore [5];
2 char voyelles [6];
3 string etudiants [20];
4 double notes [20];
il est possible aussi d'initialiser le tableau à la déclaration en plaçant entre accolades les
valeurs, séparées par des virgules.
Voici un exemple :
1 int meilleurScore [5] = {100432, 87347, 64523, 31415, 118218};
NB :
 Le nombre de valeurs entre accolades ne doit pas être supérieur au nombre
d'éléments du tableau

3 | 16
 Les valeurs entre accolades doivent être des constantes, l'utilisation de variables
provoquera une erreur du compilateur.
 Si le nombre de valeurs entre accolades est inférieur au nombre d'éléments du
tableau, les derniers éléments sont initialisés à 0
 Il doit y avoir au moins une valeur entre accolades.
 L’instruction suivante permet d'initialiser tous les éléments du tableau à zéro :
1 int meilleurScore [5] = {0};
I. 1. 2. Accès aux éléments
Chaque élément d'un tableau peut être utilisé comme n'importe quelle autre variable, il
n'y a aucune différence, sauf que pour y accéder, le nom de celui-ci ne suffit pas car il
comporte plusieurs éléments. Pour cela, on définit un nombre appelé indice qui, combiné
avec le nom du tableau, permet de décrire exactement chaque élément.
Pour accéder à un élément du tableau, on utilise la syntaxe nomDuTableau[indice].
NB :
 Le premier élément d’un tableau possède le numéro 0 et pas 1, tandis que le dernier
élément possède le numéro taille – 1.
 Un indice est toujours positif.
Pour accéder à la troisième case d’un tableau, il faudra donc écrire : nomDuTableau[2].
I. 1. 3. Manipulation des éléments
Un élément du tableau (repéré par le nom du tableau et son indice) peut être manipulé
exactement comme une variable, on peut donc effectuer des opérations avec (ou sur) des
éléments de tableau.
Voici un exemple :
1 // Définissons un tableau de 10 entiers :
2 int Toto[10];
3
4 // Pour affecter la valeur 6 au huitième élément on écrira :
5 Toto[7] = 6;
6
7 // Pour affecter au 10Ã¨me élément le résultat de l'addition des éléments 1
et 2, on écrira :
8 Toto[9] = Toto[0] + Toto[1];
I. 1. 4. Parcourir un tableau
Le gros point fort des tableaux, c'est qu'on peut les parcourir en utilisant une boucle. On
peut ainsi effectuer une action sur chacune des cases d'un tableau, l'une après l'autre :
par exemple afficher le contenu des cases.
Voici un exemple :
1 #include <iostream>

4 | 16
2 #include "calcul.h"
3
4 using namespace std;
5
6 int main()
7 {
8 //La taille du tableau
9 int const nombreMeilleursScores(5);
10 //Déclaration du tableau
11 int meilleursScores[nombreMeilleursScores];
12
13 //Remplissage de la première case
14 meilleursScores[0] = 100432;
15 //Remplissage de la deuxième case
17 //Remplissage de la troisième case
19 //Remplissage de la quatrième case
21 //Remplissage de la cinquième case
23
24 for(int i(0); i<nombreMeilleursScores; ++i)
25 {
26 cout << "Meilleur score de joueur " << i+1 << " est : " <<
meilleursScores[i] << endl;
27 }
28
29 return 0;
30 }
Le résultat de l’exécution de ce programme est le suivant :
I. 1. 5. Tableaux et fonctions
Au même titre que les autres types de variables, vous pouvez passer un tableau comme
argument d'une fonction. Voici donc une fonction qui reçoit un tableau en argument :
1 void afficheTableau(int tableau[], int n)
2 {
3 for(int i = 0; i < n; i++)
4 {
5 cout << tableau[i] << endl;
6 }
7
9 }

5 | 16
NB :
 À l'intérieur de la fonction afficheTableau(), il n'y a aucun moyen de connaître
la taille du tableau ! C’est pour cela nous avons ajouté un deuxième argument n
contenant la taille du tableau.
Voyons maintenant, l’implémentation du programme précédent, en utilisant cette fois-ci
la fonction afficheTableau().
3
5
6 void afficheTableau(int tableau[], int n);
7
8 int main()
9 {
13 int meilleursScores[nombreMeilleursScores] =
14 {100432, 87347, 64523, 31415, 118218};
15
16 // appel de la fonction afficheTableau () :
17 afficheTableau(meilleursScores, nombreMeilleursScores);
18
19 return 0;
20 }
21
22 void afficheTableau(int tableau[], int n)
23 {
24 for(int i = 0; i < n; i++)
25 {
26 cout << tableau[i] << endl;
27 }
28 }
Ce petit programme affiche les valeurs du tableau meilleursScores grâce à la
fonction afficheTableau(), qui prend comme paramètre un tableau d'entiers et la
taille du tableau.
I. 2. Les tableaux unidimensionnels dynamiques (vector)
Les tableaux que nous avons vus jusqu'ici sont des tableaux statiques :
1 int t[5] ;
Cette forme de tableaux vient du langage C, et est encore très utilisée. Cependant, elle
n'est pas très pratique. En particulier :
- un tableau de cette forme ne connaît pas sa taille.
- on ne peut pas faire d'affectation globale, par exemple on ne peut pas faire :
1 int T1[3] = {1, 9, 2};
2 int T2[3];
3 T2 = T1 ;

6 | 16
- une fonction ne peut pas retourner de tableaux.
Pour remédier ces trois problèmes, Le C++ a introduit la notion des tableaux dynamiques
qui n'ont pas ces inconvénients. Un tableau dynamique est un tableau dont le nombre de
cases peut varier au cours de l'exécution du programme. Il permet d'ajuster la taille du
tableau au besoin du programmeur.
Entre les tableaux statiques et tableaux dynamique il y a certaines choses qui sont
identiques, ce qui va nous éviter de tout répéter.
I. 2. 1. Déclaration
La première différence se situe au tout début de votre programme. Il faut ajouter la
ligne #include <vector> pour utiliser ces tableaux. Et la deuxième grosse différence
se situe dans la manière de déclarer un tableau.
Voici la syntaxe :
vector<type> nomDuTableau(taille);
Par exemple, pour un tableau de 3 entiers, on écrit :
1 vector<int> tab(3);
On peut aussi faire :
1 vector<int> tab(3, 0);
pour initialiser tous les éléments du tableau à 1 au moment de la déclaration.
et:
1 vector<int> tab2(tab1);
pour initialiser les éléments de tab2 aux mêmes valeurs que tab1.
On peut même déclarer un tableau sans cases en ne mettant pas de parenthèses du tout
:
1 vector<int> tab;
Rappelez-vous que ce sont des tableaux dont la taille peut varier. On peut donc ajouter
des cases par la suite. Nous allons voir comment faire ça !
I. 2. 2. Accès aux éléments
On peut accéder aux éléments de tab de la même façon qu'on accéderait aux éléments
d'un tableau statique :
1 tab[0] = 7;
Essayons de réécrire l'exemple de la section précédente avec un vector :
3 #include <vector>

7 | 16
5
6 int main()
7 {
11 vector<int> meilleursScores(nombreMeilleursScores);
12
13 //Remplissage de la première case
15 //Remplissage de la deuxième case
17 //Remplissage de la troisième case
19 //Remplissage de la quatrième case
21 //Remplissage de la cinquième case
23
24 for(int i(0); i<nombreMeilleursScores; ++i)
25 {
26 cout << "Meilleur score de joueur " << i+1 << " est : " <<
meilleursScores[i] << endl;
27 }
28
29 return 0;
30 }
I. 2. 3. Modification de la taille
Entrons maintenant dans le vif du sujet : faire varier la taille d'un tableau. Nous allons
voir comment :
1) ajouter des cases à la fin d'un tableau.
2) supprimer la dernière case d'un tableau
Commençons par ajouter des cases à la fin d'un tableau.
1) la fonction push_back()
Il faut utiliser la fonction push_back(). On écrit le nom du tableau, suivi d'un point et
du mot push_back avec, entre parenthèses, la valeur qui va remplir la nouvelle case.
18 //Un tableau de 3 entiers valant tous 2
19 vector<int> tableau(3,2);
20
21 //On ajoute une 4Ã¨me case au tableau qui contient la valeur 8
22 tableau.push_back(8);
2) la fonction pop_back()
On peut supprimer la dernière case d'un tableau en utilisant la fonction pop_back() de
la même manière que push_back(), sauf qu'il n'y a rien à mettre entre les parenthèses.
18 //Un tableau de 3 entiers valant tous 2
19 vector<int> tableau(3,2);
20
21 //il y a plus que deux entier
22 tableau.pop_back();

8 | 16
I. 2. 4. Savoir la taille du tableau
Comme la taille peut changer, on ne sait pas de manière certaine combien d'éléments
contient un tableau. Heureusement, il y a une fonction pour cela : size(). Cette fonction
nous permet à chaque moment de connaître le nombre d'éléments du tableau. Voici
comment :
1 int taille = tab.size();
I. 2. 5. Exemple récapitulatif
Voici un programme qui calcule la moyenne des notes stockées dans un tableau dynamique :
2 #include <vector> //A ne pas oublier !
3
5
6 int main()
7 {
8 //Déclaration d'un tableau vide
9 vector<double> notes;
10
11 //On ajoute des cases (6) avec les notes
12 notes.push_back(12.5);
14 notes.push_back(6);
18
19 double moyenne(0);
20 for(int i(0); i<notes.size(); ++i)
21 //On utilise notes.size() pour la limite de notre boucle
22 {
23 //On additionne toutes les notes
24 moyenne += notes[i];
25 }
26
27 moyenne /= notes.size();
28 //On utilise à nouveau notes.size() pour obtenir le nombre de notes
29
30 cout << "Votre moyenne est : " << moyenne << endl;
31
32 return 0;
33 }
I. 2. 6. Les vector et les fonctions
Passer un tableau dynamique en argument à une fonction est beaucoup plus simple que pour
les tableaux statiques. Comme pour n'importe quel autre type, il suffit de
mettre vector<type> en argument. Et c'est tout. Grâce à la fonction size(), il n'y a
même pas besoin d'ajouter un deuxième argument pour la taille du tableau :
1 void afficheTableau(vector<int> tab)
2 {
3 for(int i = 0; i < tab.size(); i++)

9 | 16
4 {
5 cout << tab[i] << endl;
6 }
7 }
Astuce : si le tableau contient beaucoup d'éléments, le copier prendra du temps. Il vaut
donc mieux utiliser un passage par référence constante const& pour optimiser la copie.
Ce qui donne :
1 void afficheTableau(vector<int> const& tab)
2 {
// ...
7 }
Dans ce cas, le tableau dynamique ne peut pas être modifié. Pour changer le contenu du
tableau, il faut utiliser un passage par référence tout simple (sans le mot const donc).
Ce qui donne :
1 void afficheTableau(vector<int>& tab)
2 {
// ...
7 }
Pour appeler une fonction recevant un vector en argument, il suffit de mettre le nom du
tableau dynamique comme paramètre entre les parenthèses lors de l'appel. Ce qui donne :
1 vector<int> tab(3,2); //On crée un tableau de 3 entiers valant 2
3
2 afficheTableau(tab); //On passe le tableau à la fonction afficherTableau()
Il est évidemment possible d'écrire une fonction renvoyant un vector.
1 vector<int> premierCarres(int n)
2 {
3 vector<int> tab(n);
4 for(int i = 0; i < tab.size(); i++)
5 {
6 tab[i] = i * i;
7 }
8 return tab;
9 }
NB : Il faut, cependant, noter que ceci va implicitement générer une copie du tableau
quand la fonction se termine. Pour éviter cela, on préfère utiliser un passage du tableau
par référence, comme nous l'avons vu dans le chapitre précédent. Les copies inutiles de
tableaux sont des sources courantes de ralentissement des programmes. Si vous avez
besoin d'un programme très performant, faites attention à vos tableaux.
II. Les tableaux multidimensionnels
Dans une certaine mesure, tableau peut-être considéré comme un type en lui-même.
Pourquoi alors ne pas faire un tableau de tableaux ? Nous parlons des tableaux
multidimensionnels.
Un tableau multidimensionnel est un tableau dont ses éléments sont aussi des tableaux.

10 | 16
Par exemple un tableau bidimensionnel (3 lignes, 4 colonnes), est en fait un tableau
comportant 3 éléments, chacun d'entre eux étant un tableau de 4 éléments.
Comme c’est le cas pour les tableaux unidimensionnels, les tableaux multidimensionnels
sont de deux sorts : les tableaux multidimensionnels statiques et les tableaux
multidimensionnels dynamiques.
II. 1. Les tableaux multidimensionnels statiques
II. 1. 1. Déclaration
Un tableau multidimensionnel statique se définit de la manière suivante :
1 type nomDuTableau [a1][a2][a3] ... [aN] ;
- Chaque élément entre crochets désigne le nombre d'éléments dans chaque
dimension
- Le nombre de dimensions n'est pas limité
Un tableau d'entiers positifs à deux dimensions (3 lignes, 4 colonnes) se définira avec la
syntaxe suivante :
1 int tab [3][4] ;
On peut représenter ce tableau de la manière suivante :
tab [0][0] tab [0][1] tab [0][2] tab [0][3]
tab [1][0] tab [1][1] tab [1][2] tab [1][3]
tab [2][0] tab [2][1] tab [2][2] tab [2][3]
il est possible aussi d'initialiser le tableau à la déclaration en plaçant entre accolades les
valeurs, séparées par des virgules.
Voici un exemple :
1 type Nom_du_tableau [Taille1][Taille2]...[TailleN] = {a1, a2, ... aN};
Les valeurs sont attribuées aux éléments successifs en incrémentant d'abord les indices
de droite, c'est-à-dire pour un tableau à 2 dimensions : [0][0], [0][1], [0][2] ... puis [1][0],
[1][1], etc.
Une autre manière pour initialiser tous les éléments d’un tableau est l’utilisation des
boucles imbriquées. Par exemple les éléments de tab[3][4] pourront être initialisés à 0
par les instructions suivantes :
1 int i,j;
2
3 for (i=0; i<2; i++){
4 for (j=0; j<3; j++){
5 tab[i][j] = 0;
6
7 }

11 | 16
8 }
II. 1. 2. Accès aux éléments
Pour accéder à une case de notre grille, il faut, tout simplement, indiquer la position en
ligne et en colonne de la case voulue.
Par exemple tab[0][0] accède à la case en-bas à gauche de la
grille. tab[0][1] correspond à celle qui se trouve juste au-dessus, alors
que tab[1][0] se situe directement à sa droite.
II. 2. Les tableaux multidimensionnels dynamiques
Notez qu’il est aussi possible de créer des tableaux multi-dimensionnels de taille variable
en utilisant les vectors.
Pour une grille 2D d'entiers, on devra écrire :
1 vector<vector<int> > grille;
Le problème est que ce n'est pas réellement un tableau 2D, mais plutôt un tableau de
lignes. Il faudra donc commencer par ajouter des lignes à notre tableau.
3 grille.push_back(vector<int>(5)); //On ajoute une ligne de 5 cases à notre
grille
4 grille.push_back(vector<int>(3,4)); //On ajoute une ligne de 3 cases
contenant chacune 4 à notre grille
Chaque ligne peut donc avoir une longueur différente. On peut accéder à une ligne en
utilisant les crochets :
6 grille[0].push_back(8); //Ajoute une case contenant 8 à la première ligne
de la grille
Finalement, on peut accéder aux valeurs dans les cases de la grille en utilisant deux paires
de crochets, comme pour les tableaux statiques. Il faut par contre s'assurer que cette
ligne et cette colonne existent réellement.
8 grille[2][3] = 9; //Change la valeur de la cellule (2,3) de la grille
III. Les strings sont des tableaux de caractères (lettres)
En C++, une chaîne de caractères n’est rien d’autre qu’un tableau de caractères, avec un
caractère nul ’0’ marquant la fin de la chaîne.
On peut par exemple représenter la chaîne « Bonjour » de la manière suivante :
B o n j o u r 0
Les chaînes de caractère peuvent être saisies au clavier et affichées à l’écran grâce aux
objets habituels cin et cout.
III. 1. Déclaration

12 | 16
Pour définir une chaîne de caractères en langage C, il suffit de définir un tableau de
caractères. Le nombre maximum de caractères que comportera la chaîne sera égal au
nombre d'éléments du tableau moins un (réservé au caractère de fin de chaîne).
Voici quelques exemples :
1 char nom[20], prenom[20]; // 19 caractères utiles
1 char adresse[3][40]; // trois lignes de 39 caractères utiles
1 char turlu[10] = {‘t’, ‘u’, ‘t’, ‘u’, ‘0’}; // ou : char turlu[10] = "tutu";
III. 2. Accès aux lettres
L'intérêt de voir une chaîne de caractères comme un tableau de lettres, c'est qu'on peut
accéder à ces lettres et les modifier. Voir l’exemple suivant :
2 #include <string>
4
5 int main()
6 {
7 string nomUtilisateur("Youssouf");
8 cout << "Vous etes : " << nomUtilisateur << "." <<endl;
9
10 nomUtilisateur[3] = 'n'; //On modifie la 4eme lettre
11 nomUtilisateur[4] = 'n'; //On modifie la 5eme lettre
12 nomUtilisateur[7] = 's'; //On modifie la derniere lettre
13
14 cout << "Apres modification"<< endl;
15 cout << "Vous etes : " << nomUtilisateur << "." <<endl;
16
17 return 0;
18 }
Testons pour voir :
On peut faire encore mieux en utilisant les fonctions de manipulation de chaînes de
caractères qui sont très nombreuses (environ une quarantaine). Le paragraphe suivant
représente un bref aperçu de certaines de ces fonctions.
III. 3. Les fonctions de manipulation de chaînes de caractères
De nombreuses fonctions de manipulation de chaîne sont directement fournies. Ces
fonctions se trouvent dans le fichier d'en-tête <string.h>, c'est la raison pour laquelle
il faut ajouter la ligne suivante en début de programme :

13 | 16
1 #include <string.h>
Le fichier <string.h> contient les prototypes de nombreuses fonctions permettant de
simplifier l'utilisation et la manipulation de chaînes (environ une quarantaine). Voici un
bref aperçu de certaines de ces fonctions :
Fichier Fonction Ce qu’elle fait
string.h
strlen(s) donne la longueur de la chaîne s
strcpy(dest, source) recopie la chaîne source dans dest
strcmp(s1,s2)
compare les chaînes s1 et s2 : renvoie une valeur
< 0, nulle ou > 0 selon que s1 est
inférieure, égale ou supérieure à s2
pour l’ordre alphabétique.
size() pour connaître le nombre de lettres d’une chaîne
push_back() pour ajouter des lettres à la fin d’une chaîne
pop_back() pour supprimer la dernière lettre d’une chaîne
stdio.h gets(s)
lit une chaîne de caractères tapée au clavier,
jusqu’au premier retour à la ligne (inclus) ; les
caractères lus sont rangés dans la chaîne s, sauf le
retour à la ligne qui y est remplacé par ’0’.
ctype.h
tolower() convertit une lettre majuscule en minuscule
toupper() convertit une lettre minuscule en majuscule
III. 4. Exemples
Nous en donnerons deux exemples.
Exemple 1 :
Fonction qui indique si une phrase est un palindrome (c’est-`a-dire qu’on peut la lire aussi
bien à l’endroit qu’à l’envers) :
14 int Palindrome(Phrase s) // teste si s est un palindrome
15 {
16 int i = 0, j = strlen(s) - 1;
17 while (s[i] == s[j] && i < j)
18 i++, j--;
19 return i >= j;
20 }
Exemple 2 :
Instructions qui, à partir d’une chaîne s, fabrique la chaîne t obtenue en renversant s :
7 for (int i = 0, j = strlen(s) - 1; i < strlen(s); i++, j--)
8 t[i] = s[j];
9 t[strlen(s)] = ‘0’;

14 | 16
IV. Tri des tableaux en C++
Les tableaux permettent de stocker plusieurs éléments de même type au sein d’une seule
entité. Lorsque le type de ces éléments possède un ordre total, on peut donc les ranger
en ordre croissant ou décroissant. Trier un tableau c’est donc ranger les éléments d’un
tableau en ordre croissant ou décroissant.
Dans ce cours on ne fera que des tris en ordre croissant. Il existe plusieurs méthodes de
tri qui se différencient par leur complexité d’exécution et leur complexité de
compréhension pour le programmeur.
Dans cette partie nous examinons le tri à bulles, le tri par sélection et le tri par insertion.
Un tableau récapitulatif, présentant les principaux algorithmes de tri, est fourni à la fin
de cette partie.
IV. 1. Tri à bulles1
Le tri à bulles ou tri par propagation est un algorithme de tri. Son principe est de
comparer deux à deux les éléments t[i] et t[i+1] consécutifs d'un tableau et d'effecteur
une permutation si t[i] > t[i+1] . On continue de trier jusqu'à ce qu'il n'y ait plus de
permutation.
Voici comment :
62 void triABulles(int t[], int n)
63 {
64 int x;
65 for (int i=n-1; i>0; i--)
66 {
67 for (int j=0; j<i; j++)
68 {
69 if (t[j+1]<t[j])
70 {
71 x = t[j];
72 t[j] = t[j+1];
73 t[j+1] = x;
74 }
75 }
76 }
77 }
IV. 2. Tri par sélection2
Le tri par sélection (ou tri par extraction) est un algorithme de tri par comparaison. Sur
un tableau de n éléments (numérotés de 0 à n-1), le principe de cet algorithme est le
suivant :
- rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice
numéro 0 ;
1
https://fr.wikipedia.org/wiki/Tri_%C3%A0_bulles
2
https://fr.wikipedia.org/wiki/Tri_par_s%C3%A9lection

15 | 16
- rechercher le second plus petit élément du tableau, et l'échanger avec l'élément
d'indice 1 ;
- continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.
L'algorithme s'écrit en C++ ainsi :
38 void triParSelection(int t[], int n)
39 {
40 int min, x;
41 for (int i=0; i<n; i++)
42 {
43 min = i;
44 //bool estTrouve(false);
45 for (int j=i+1; j<n; j++)
46 {
47 if (t[j]<t[min])
48 {
49 min=j;
50 //estTrouve=true;
51 }
52 }
53 if (min!=i)
54 {
55 x = t[i];
56 t[i] = t[min];
57 t[min] = x;
58 }
59 }
60 }
IV. 3. Tri par insertion3
C'est le tri du joueur de cartes. On fait comme si les éléments à trier étaient donnés un
par un, le premier élément constituant, à lui tout seul, une liste triée de longueur 1. On
range ensuite le second élément pour constituer une liste triée de longueur 2, puis on
range le troisième élément pour avoir une liste triée de longueur 3 et ainsi de suite...
Le principe du tri par insertion est donc d'insérer à la nième itération le nième élément à
la bonne place.
22 void triParInsertion(int t[], int n)
23 {
24 int x, j;
25 for (int i = 1; i<n; i++)
26 {
27 x = t[i];
28 j=i;
29 while(j>0 && t[j-1]>x)
30 {
31 t[j] = t[j-1];
32 j=j-1;
33 }
34 t[j] = x;
35 }
3
https://fr.wikipedia.org/wiki/Tri_par_insertion

16 | 16
36 }
IV. 4. Autres algorithmes de tri4
Le tableau suivant présente les principaux algorithmes de tri :
Algorithmes de tri stable Algorithmes de tri non stable
Le tri par insertion Le tri par sélection
Le tri bulle Le tri à peigne
Le tri Shaker Le tri Shell
Le tri Gnome Le tri maximier
Le tri fusion Le tri rapide
V. Ce que vous devez retenir !
 Les tableaux sont des successions de variables en mémoire. Un tableau à 4 cases
correspond donc en mémoire à 4 variables les unes à la suite des autres.
 Un tableau s'initialise comme ceci : int meilleurScore[4]; (pour 4 cases).
 La première case est toujours numérotée 0 (meilleurScore[0]).
 Si la taille du tableau est susceptible de varier, créez un tableau dynamique de
type vector : vector<int> tableau(5);.
 On peut créer des tableaux multi-dimensionnels. Par exemple, int
tableau[5][4]; revient à créer un tableau de 5 lignes et 4 colonnes.
 On ne peut pas écrire une fonction qui renvoie un tableau statique. C'est
impossible.
 Un tableau statique est toujours passé en paramètre d’une fonction par référence.
Et il n'y a pas besoin d'utiliser l'esperluette (&) : c'est fait automatiquement. Cela
veut dire que, lorsqu'on passe un tableau à une fonction, cette dernière peut le
modifier.
 Les chaînes de caractères string peuvent être considérées comme des tableaux.
Chacune des cases correspond à un caractère.
4
http://lwh.free.fr/pages/algo/tri/tri.htm

Chapitre05 : Les tableaux

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Chapitre05 : Les tableaux

Similaire à Chapitre05 : Les tableaux (20)

Dernier

Dernier (18)

Chapitre05 : Les tableaux