chapitre05 : les tableaux

Introduction au langage C++

Chapitre 5

Les tableaux

Youssouf EL ALLIOUI, [email protected]

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

mailto:[email protected]

http://fr.slideshare.net/yelallioui/

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 16 meilleursScores[1] = 87347; 17 //Remplissage de la troisième case 18 meilleursScores[2] = 64523; 19 //Remplissage de la quatrième case 20 meilleursScores[3] = 31415; 21 //Remplissage de la cinquième case 22 meilleursScores[4] = 118218; 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().

1 #include <iostream> 2 #include "calcul.h" 3 4 using namespace std; 5 6 void afficheTableau(int tableau[], int n); 7 8 int main() 9 { 10 //La taille du tableau 11 int const nombreMeilleursScores(5); 12 //Déclaration du tableau 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 :

1 #include <iostream> 2 #include "calcul.h" 3 #include <vector> 4 using namespace std;

7 | 16


5 6 int main() 7 { 8 //La taille du tableau 9 int const nombreMeilleursScores(5); 10 //Déclaration du tableau 11 vector<int> meilleursScores(nombreMeilleursScores); 12 13 //Remplissage de la première case 14 meilleursScores[0] = 100432; 15 //Remplissage de la deuxième case 16 meilleursScores[1] = 87347; 17 //Remplissage de la troisième case 18 meilleursScores[2] = 64523; 19 //Remplissage de la quatrième case 20 meilleursScores[3] = 31415; 21 //Remplissage de la cinquième case 22 meilleursScores[4] = 118218; 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 :

1 #include <iostream> 2 #include <vector> //A ne pas oublier ! 3 4 using namespace std; 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); 13 notes.push_back(19.5); 14 notes.push_back(6); 15 notes.push_back(12); 16 notes.push_back(14.5); 17 notes.push_back(15); 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 :

1 #include <iostream> 2 #include <string> 3 using namespace std; 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

https://fr.wikipedia.org/wiki/Algorithme_de_tri

https://fr.wikipedia.org/wiki/Tri_%C3%A0_bulles

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

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

http://lwh.free.fr/pages/algo/tri/tri.htm

chapitre05 : les tableaux

Education