INTRODUCTION A L’ALGORITHMIQUE

OBJECTIFS

A la fin de ce chapitre, l’étudiant devra être capable de :

- Ecrire un algorithme simple ;

- Utiliser les structures de données telles que les tableaux et les enregistrements ;
- Utiliser les structures algorithmiques de contrôle pour structurer un raisonnement ;
- Réaliser des opérations de tri et de recherche sur les tableaux ;
- Exécuter des algorithmes ;
- Utiliser des sous-algorithmes.
 CHAPITRE I : ECRITURE DES ALGORITHMES SIMPLES

Objectifs :

- Déclarer et utiliser les variables et les constantes ;

- Utiliser convenablement les instructions algorithmiques de base (lecture, écriture,
affectation) pour écrire des algorithmes séquentiels ;
- Ecrire un algorithme séquentiel ;
- Lister quelques exemples de structure de contrôle ;
- Utiliser les structures alternatives (Si, Si…Sinon) ;
- Identifier les instructions d’incrémentation, de décrémentation et d’initialisation ;
- Identifier une boucle/condition ; Identifier la condition d’arrêt d’une boucle ;
- Utiliser les structures itératives (Pour …Faire, Tant que … Faire, Répéter …Jusqu’à).

LEÇON 1 : INSTRUCTIONS ALGORITHMIQUES DE BASE.

COMPÉTENCES ATTENDUES : A partir d’une liste de tâches présentée aux étudiants,

chaque étudiant d’une classe de 1ère année, … après observation et échange, doit être capable
à la fin de cette leçon de :

 Déclarer les variables et constantes ;

 Utiliser les variables et constantes ;
 Utiliser convenablement les instructions algorithmiques de base (lecture, écriture,
affectation) ;
 Ecrire un algorithme séquentiel.

L’étudiant performant sera celui qui pourra identifier à 100% les éléments et structures de
contrôle d’un algorithme présenté à lui.

Situation problème :

Votre petit frère André est un étudiant en classe de seconde. Après sa journée de cours, il rentre
directement à la maison et constate que Maman lui a servie deux plats (un plat contenant le riz
et l’autre la sauce). Cependant, le plat contenant la sauce a un petit trou et laisse couler la sauce.
Il veut permuter les contenus des deux plats mais ne sait pas comment procéder. Il sollicite
votre aide et vous lui dites qu’il s’agit là d’un problème algorithmique séquentiel. Troublé par
ces nouveaux concepts, il vous demande de nouveau de l’expliquer ces notions
d’algorithmiques. En vous basant sur les cours d’algorithmique des classes antérieures,
apprenez à votre petit frère des instructions algorithmiques.
 Introduction

L’homme fait face chaque jour à une multitude de problèmes auxquels il se doit de proposer
des solutions. La recherche de la solution à un problème est une démarche algorithmique, qui
est loin d’être figée ou universelle. Chaque solution algorithmique respecte un standard selon
le type de problème à résoudre. Dans cette leçon, il sera question pour nous d’aborder les
notions liées aux instructions algorithmiques de base.

I. Définition et structure de base d’un algorithme

Avant d’aller plus loin nous rappelons les notions de base d’un algorithme. Telles que la
définition et la structure de base d’un algorithme.

1. Définitions

• Un algorithme est une suite finie et ordonnée d’instruction donnée à un utilisateur lui
permettant de résoudre un problème donné.

• Variable : C’est un objet contenant une valeur pouvant être modifiée au cours de
l’exécution d’un algorithme. Une variable est caractérisée par un nom et un type. En
outre, la valeur de la variable peut être modifiée au cours de l’exécution de l’algorithme.

• Constante : C’est un objet dont la valeur du contenu ne change pas lors de l’exécution
d’un algorithme. De même qu’une variable, une constante est caractérisée par un nom
et un type.

• Une instruction : est un verbe d’action qui caractérise la nature des opérations à
effectuer sur une ou plusieurs données. Ainsi, nous avons les instructions de base telles
que : les instructions de lecture, d’écriture et d’affectation.

2. Structure de base d’un algorithme

algorithme // nom de l’algorithme : c’est l’entête du programme

const ou constantes // déclaration des constantes si elles existent
var ou variables // déclaration des variables si elles existent
début
Bloc d’instruction : C’est le corps de l’algorithme
fin

• L’en-tête : il permet tout simplement d’identifier l’algorithme

• Les déclarations : c’est une liste exhaustive des objets, grandeurs utilisés et manipulés
dans le corps de l’algorithme. Cette liste est placée en début d’algorithme.
 • Le corps : dans cette partie de l’algorithme sont placées les tâches (instructions opérations
…) à exécuter.
II. Les types de données de base

Un algorithme peut être amené à manipuler plusieurs types de données. Nous avons vu que
l’une des deux caractéristiques de la variable ou de la constante est le type. On peut citer cinq
types de base ;

 Les entiers : mot clé Entier

 Les réels : mot clé Réel
 Les booléens : ces types ne manipulent que 2 valeurs qui sont : Vrai ou Faux mot clé
Booléen
 Les caractères : mot clé car
 Les chaînes de caractères : mot clé chaîne
III. Déclaration des variables et constantes
1- Déclaration des variables

Pour déclarer une variable, nous utilisons le Mot clé : var ou variable
Syntaxe : var NomVariable : [Type]
Exemples : var Rayon : Réel ;
variable Compteur : Entier ;
NB : Les variables de mêmes types peuvent être déclarées ensemble sur une même ligne.
Cependant, elles doivent être séparées par des virgules.

Exemples : var delta, x1, x2, a, b, c : réel ;

2- Déclaration des constantes

Pour déclarer une constante, nous utilisons le Mot clé : const ou constante (selon les
ouvrages).
Syntaxe : const NomConstante = Valeur : [Type] ;
Exemples : const Pi : Réel = 3.141559 ;

IV. Les Instructions algorithmiques de base.

On distingue plusieurs types d’instructions entre autres nous pouvons citer les instructions de
lecture, d’écriture et les instructions d’affectation.
 1- Les instructions de lecture

Une instruction de lecture permet de récupérer la valeur d’une variable entrée au clavier
par un utilisateur. Le mot clé est Lire () ; Ex : Lire (A) cette instruction permet de récupérer la
valeur de la variable A entré au clavier par un utilisateur.

2- Les instructions d’écriture

Une instruction d’écriture permet d’afficher à l’écran une chaîne de caractère ou d’afficher
la valeur du contenu d’une variable. Le mot clé est : Ecrire () ou Ecrire (" ") ; Ex :

 Ecrire(A) permet d’afficher la valeur du contenu de la variable A ;

 Ecrire("A") permet d’afficher la variable A elle-même.
3- Les instructions d’affectation

L’affectation est une opération qui permet d’attribuer une valeur à une variable. Sa
syntaxe d’utilisation est la suivante : NomVariable Expression ; et son symbole est «  ».

Une expression peut être : une constante, une variable ou le résultat d’une fonction. Une
affectation se fait en 3 étapes. L’évaluation, le calcul et le transfert de donnée. Une affectation
se comporte de deux manières : copie la valeur de l’expression et écrase l’ancienne valeur de
NomVariable. Exemples : c←a ; d←b ; b←b ; b←10 ; b← "Bonjour !" ; delta ← b*b –
4*a*c ;

V. Utilisation des instructions algorithmiques de base pour écrire un algorithme

séquentiel

Un algorithme séquentiel est une suite finie et ordonnée d’instruction sans aucune instruction
de contrôle comme (si, tant que, pour, répéter…) à exécuter dans l’ordre pour aboutir à un
résultat. Il est délimité par les mots clés début et fin. Exemples : les notices des appareils
électroniques, des médicaments, les recettes de cuisine…

Activité 1 : Individuel, écrire un algorithme séquentiel qui permet de permuter deux entiers
naturels entrés au clavier par un utilisateur.

Solution :

Algorithme permutation ;

Var : a, b, c : Entier ;
Début

Ecrire (" Entrer la valeur de A : ") ;

Lire(a) ;

Ecrire (" Entrer la valeur de B : ") ;

Lire (b) ;

c←a ;

a←b ;

b←c;

Ecrire (" A vaut maintenant : ", a) ;

Ecrire (" B vaut maintenant : ", b) ;

Fin algorithme
 LEÇON 2 : LES STRUCTURES DE CONTRÔLE.

COMPÉTENCES ATTENDUES : A partir de plusieurs catégories de problèmes à traiter,

chaque étudiant du niveau 1, … après observation et échange, doit être capable à la fin de cette
leçon de :

 Lister quelques exemples de structure de contrôle ;

 Utiliser les structures alternatives (Si, Si…Sinon) ;
 Identifier les instructions d’incrémentation, de décrémentation et d’initialisation ;
 Identifier une boucle/condition ; Identifier la condition d’arrêt d’une boucle ;
 Utiliser les structures itératives (Pour …Faire, Tant que … Faire, Répéter …Jusqu’à).

Situation problème : Votre petit frère André a résolu son problème grâce à vous. Après avoir
pris son repas, Papa l’a envoyé au marché chez son ami le boutiquier Mamadou acheter un sac
de riz pour le mois. Cependant, il menace de pleuvoir dehors et votre petit frère est dans
l’embarras. Il pose ses conditions à papa (S’il pleut, « je n’y vais pas », sinon « j’irais dans un
instant »). Vous souriez et il vous demande qui y a-t-il grand frère ? vous lui répondez en lui
disant que ses conditions vous rappellent les structures de contrôle. Curieux, il vous pose des
questions par rapport à ces structures de contrôle. En vous basant sur la documentation et les
cours d’algorithmiques vu en classe de seconde C, aidez votre petit frère à mieux comprendre
ces notions des structures algorithmiques.

Introduction

Les opérations élémentaires relatives à la résolution d’un problème, peuvent en fonction de

leur enchainement, être organisées suivant une famille de structures de contrôle ou
algorithmiques fondamentales :

- Les structures séquentielles ;

- Les structures alternatives ;

- Les structures de choix ;

- Les structures itératives ou répétitives.

I. Les structures séquentielles

Les structures séquentielles sont une suite finie et ordonnée d’instruction à exécuter dans l’ordre
pour aboutir à un résultat. Elle est délimitée par les mots clés début et fin. Sans aucune
instruction de contrôle comme (si, tant que, pour, …).

La syntaxe peut être la suivante :

 Exemple : soit l’algorithme suivant : il permet de
Début : permuter deux variables A et B de type Entier. Et de les
Instruction 1 afficher.
Instruction 2 Algorithme permutation ;
.... ……………… Var : a, b, c : Entier ;
Instruction n Début
Fin Ecrire (‘‘ Entrer la valeur de A : ’’) ;
Lire(a) ;
Ecrire (‘‘ Entrer la valeur de B : ’’) ;
Lire (b) ;
c←a ;
a←b ;
b←c;
Ecrire (‘‘ A vaut maintenant : ’’, a) ;
Ecrire (‘‘ B vaut maintenant : ’’, b) ;
Fin algorithme

II. Les structures alternatives

La résolution de certains problèmes nécessite parfois la mise en place d’un test pour
effectuer une tâche :

• Si le test est positif, on effectue un certain traitement ;

• Sinon, c’est-à-dire si le test est négatif, on effectue un autre traitement.

En algorithmique, on traduit cette situation par la structure alternative.

Une structure alternative : est une situation dans laquelle on ne peut choisir qu’entre deux
solutions possibles. Ainsi, on distingue deux types de structures alternatives : la structure
alternative simple ou réduite et la structure alternative complexe ou complète.

1. La structure alternative complète

Dans cette structure il est question d’effectuer un nombre de traitement si une condition fixée
dans la résolution du problème est vérifiée. Ainsi, sa syntaxe est la suivante ci-dessous :

Si C Alors // Dans ce cas C est une condition.

traitement 1 ; (instructions à effectuer si la condition est vérifiée)
Sinon
traitement 2 ; (instructions à effectuer si la condition n’est pas vérifiée)
 FinSi
Lorsque la condition prend la valeur Vrai, alors Traitement1 est exécutée et Traitement2 est
ignorée. Lorsque la condition prend la valeur Faux, alors Traitement2 est exécutée
et Traitement1est ignorée.
Remarque : Il existe des conditions simples et des conditions complexes :
Une condition simple est une simple comparaison entre deux entités. C’est-à-dire qu’elle est
composée de trois éléments

• Une valeur ;

• Un opérateur de comparaison ;

• Une autre valeur

Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…). Les
opérateurs de comparaison sont : = ; != ; < ; > ; =< ; >= ; L’ensemble constitue donc si l’on
veut une affirmation, qui a un moment donné est VRAIE ou FAUSSE.

Une condition complexe est une combinaison logique de conditions simples (par exemple :
A=B et B<C)

Exemple : Étant donnés deux nombres entiers positifs, identifier le plus grand des deux
nombres.

La solution à ce problème est analysée puis traitée dans le tableau ci-dessous.

Solution :
Analyse : si A>B alors le plus grand est A sinon le plus grand est B.
Conception :
Algorithme
variables A, B : entiers
début
écrire("Programme permettant de déterminer le plus grand de deux entiers positifs”)
écrire(“Entrer le premier nombre : ”) ;
lire(A) ;
écrire (“Entrer le second nombre : ”) ;
lire(B) ;
si (A>B) alors
écrire(“Le nombre le plus grand est : ”, A) ;
sinon
 écrire(“Le nombre le plus grand est : ”, B) ;
finsi
fin

2. La structure alternative réduite

La structure proposée ci-dessus est qualifiée de « complète » mais, selon le cas, il se peut que,
si la condition n’est pas vérifiée, il n’y ait pas à effectuer de traitement 2. On écrira ainsi la
structure alternative « réduite » comme sur la syntaxe ci-dessous :
Si C Alors // Où C est une condition.
Traitement (instructions à effectuer si la condition est vérifiée)
FinSi

Exemple : écrire un algorithme qui permet de transformer les nombres entiers positifs en
nombres entiers négatifs.

Solution
Analyse : si nombre > 0 alors le nombre négatif est -nombre.
Conception :

Algorithme nombre_negatif

Variables nbr : entier ;

Début
Ecrire (’’Entrer un nombre positif : ’’) ;
Lire(nbr) ;
Si nbr > 0 alors
Ecrire (’’Le nombre négatif du nombre correspond à : ’’, -nbr) ;
Finsi
Fin

III. Les instructions d’Incrémentation, de Décrémentation et d’Initialisation

1. L’Incrémentation

L’incrémentation est une opération qui permet de façon automatique d’ajouter à chaque
exécution, une valeur à une variable selon un pas donné.

Exemples : i ← i+1 ; i ← i+2 ; i ← i+2*i ; …

2. La Décrémentation
La décrémentation est l’opération inverse de l’incrémentation.

Exemples : i ← i - 1 ; i ← i - 2 ; i ← i - 2*i ; …

N.B : Pour qu’il y ait décrémentation, il faudrait que la valeur de la variable i soit initialement
plus grand que la valeur de l’expression. Exemple : i ← 10 ; ainsi, nous pouvons faire 9 fois :

i←i-1;

3. L’Initialisation

L’initialisation est une opération qui consiste à donner une valeur par défaut à une variable
avant le début du traitement d’un problème. Exemples : i ← 1 ; cpt ← 10 ; somme ← 0 ; …

IV. Les structures itératives ou répétitives

Toutes les structures itératives répètent l’exécution de traitement(s). Deux cas sont cependant à
envisager, selon que :

• Le nombre de répétitions est connu à l’avance : c’est le cas des boucles itératives

• Le nombre de répétitions n’est pas connu ou est variable : c’est le cas des boucles
conditionnelles

1er cas : le nombre de répétitions est connu à l’avance :

1. La Structure Pour…Allant de…à…faire

Cette structure est une BOUCLE ITERATIVE ; elle consiste à répéter un certain
traitement un nombre de fois fixé à l’avance. Sa syntaxe est la suivante :

Pour i allant de vi à vf pas n faire

Action
Finpour
Remarques :

• La variable i est un compteur, dont la valeur augmente automatiquement de 1 à chaque

tour. Cette variable permet en définitive de contrôler le nombre entier de tours. Cette
variable est en d’autres termes la variable de contrôle d’itération, caractérisée par sa
valeur initiale, sa valeur finale et son pas de variation.
 • La sortie de la boucle (ou condition d’arrêt) s’effectue lorsque le nombre souhaité
d’itérations est atteint, c’est-à-dire lorsque i prend la valeur vf.

• Le pas peut ne pas être précisé, dans ce cas il est considéré comme valant 1.

Exemple : Ecrire un algorithme qui calcul le carré des nombres compris entre 1 et 10.

Solution

Analyse : pour chaque nombre i allant de 1 à 10 avec un pas de 1 par défaut calculer le carré
du nombre et l’afficher.
Conception :

Algorithme carre_nombre

Variables i, c : Entier
Debut
Pour i allant de 1 à 10 faire
c←i*i ;
ecrire("le carre est. : ", c) ;
Finpour
Fin

2e cas : le nombre de répétitions n’est pas connu à l’avance :

Dans ce cas on distingue plusieurs variantes. Ici nous allons exposer le cas des boucles tant que
et celui des boucles répéter jusqu’à.

2. La structure TANT QUE …, FAIRE

Parfois, pour réaliser une tâche, on doit effectuer plusieurs fois les mêmes instructions,
sans que le nombre de fois soit déterminé à l’avance. On utilise alors une BOUCLE
CONDITIONNELLE. Dans cette structure, le même traitement est effectué tant qu’une
condition reste valide ; la boucle s’arrête quand celle-ci n’est plus remplie. Cette structure
répétitive est ainsi formulée :

Tant que condition Faire // (on répète un nombre inconnu de fois le même traitement, autant
de fois que la condition est vérifiée)
Traitement (instructions à effectuer)
FinTantq
Remarques :

- Le nombre de répétitions dépendra de la condition.

- Si la condition n’est pas vérifiée au début, alors le traitement 1 ne sera pas exécuté du
tout.

- Si la condition est vérifiée au début et si la condition n’est pas susceptible d’être

modifiée lors du traitement 1, alors le traitement 1 sera indéfiniment exécuté et
l’utilisateur sera contraint d’arrêter le programme. Dans ce cas, il s’agit d’une erreur
majeure car un programme ne doit pas boucler indéfiniment mais au contraire s’arrêter
automatiquement une fois que la condition cesse d’être vérifiée : On appelle cela en
programmation « une boucle infini »

Exemple : écrire un algorithme qui demande un nombre à un utilisateur et qui calcule la somme
des entiers jusqu’à ce nombre en utilisant la boucle tant que.

Solution

Analyse : tant que la variable i ou le compteur i est inférieur au nombre entré par l’utilisateur,
alors on calcul la somme.
Conception :

Algorithme somme
Variables som, i, nbre : entiers ;
i←1 ;
som←0 ;
Début
Ecrire(’’Entrer un nombre : ’’) ;
Lire(nbre) ;
Tant que i< nbre faire
som ← som+nbre ;
i ← i+1;
fintantq
écrire(’’la somme est : ’’, som);
Fin
 3. La boucle Répéter Jusqu’à

Dans cette structure algorithmique, la séquence d'instructions est exécutée au moins une fois et
jusqu'à ce que l'expression soit vraie. Dès que la condition est vraie, la répétitivité s'arrête. La
Syntaxe de la boucle Répéter jusqu'à est la suivante :

Répéter
Liste d'instructions
Jusqu'à condition
Exemple : soit l’algorithme ci-dessous : répondez aux questions
variables N, i, somme : entiers

début • Identifiez les variables de cet

algorithme.
écrire(’’donner la valeur de N’’) ;
• Identifiez le nombre de structures
lire(N) ;
algorithmiques qui sont utilisés.
si N<0 alors
Citez-les.
erreur
• Identifiez la ou les condition(s)
finsi d’arrêt (de sortie) de cet algorithme.

somme ← 0

i←0;

Répéter

somme ← somme + i ;

i ← i+1 ;

Jusqu’à i >=N

écrire("la somme est : ",somme) ;

fin

Solution

• Les variables de cet algorithme sont : N, i et somme

 • Il y a deux structures algorithmiques utilisés. Qui sont : la structure si…alors…finsi et
la structure répéter jusqu’à.

• La première condition c’est sur la valeur de N qui doit être positive. Et la deuxième
condition est sur la variable i qui doit être supérieure ou égale à la valeur de N entrée
par l’utilisateur.

Jeu bilingue

• La structure si … alors … finsi est nommée if … endif en anglais

• La structure si … alors … sinon … finsi est notée if … else … endif

• La structure répéter … jusqu’à est do … until …

• La structure pour a pour syntaxe for…

• La structure tant que : est while

Activités d’intégrations

Activité 1 : soit les algorithmes suivants :

Algorithme permutation ; Algorithme

Var : a, b, c : Entier ; variables A, B : entiers

Début début

Ecrire (‘‘ Entrer la valeur de A : ’’) ; écrire("Programme permettant de déterminer

le plus grand de deux entiers positifs”)
Lire(a) ;
écrire(“Entrer le premier nombre : ”) ;
Ecrire (‘‘ Entrer la valeur de B : ’’) ;
lire(A) ;
Lire (b) ;
écrire (“Entrer le second nombre : ”) ;
c←a ;
lire(B) ;
a←b ;
si (A>B) alors
b←c;
écrire(“Le nombre le plus grand est : ”,
Ecrire (‘‘ A vaut maintenant : ’’, a) ;
A) ;
Ecrire (‘‘ B vaut maintenant : ’’, b) ;
sinon
Fin algorithme
 écrire(“Le nombre le plus grand est : ”,
B) ;

finsi

fin

Consignes :
1) Identifie les parties de chacun de ces algorithmes.
2) Pour chacun des algorithmes ci-dessus, identifies les éléments les constituants.

Activité 2 : D’après toi dire quel est la nature de l’algorithme qui peut permettre
l’organisation du travail d’un étudiant de son réveil jusqu’à son départ pour l’école. Donnes
en ordre quelques-unes de ces tâches à faire avant d’aller à l’école.

Activité 3 : Après le cours de géographie, votre petit frère veut comprendre le problème
qui se cache derrière la température de l’eau. Il vous sollicite. Propose une solution lui
permettant de mieux comprendre la notion de température de l’eau en utilisant la structure
adéquate sachant que : lorsque la température t est tel que : (t<=0 eau glacée ; t>=100 eau
gazeuse ; 0<t<100 eau liquide)

Activité 4 : soit l’algorithme suivant :

Algorithme  Identifies les différentes parties de cet
const msg ← ’’C’est un garçon ’’: chaîne ; algorithme
 Y a-t-il dans cet algorithme les
var sexe : caractère ;
constantes ? si oui identifies les.
Début
 Donnes le type de chaque variable et
Ecrire (’’Entrer le sexe de l’étudiant constante s’il y’en a dans cet
’’) ; algorithme.

Lire(sexe) ;  Adaptes cet algorithme à ce qu’il

permette aussi d’identifier une
Si (sexe = ‘M’ ou sexe = ‘m’) alors
étudiant.
Ecrire(msg) ;
 Finsi

Fin

Activité 5 : Soit l’algorithme ci-dessous :

.

Algorithme somme_nombre  Quelles sont les variables de cet

Variables i, som, nbre : Entiers algorithme ?

 Quelle est la structure algorithmique
som←0 ;
utilisée dans cet algorithme ?
Debut  Identifier cette structure dans
écrire("Entrer un nombre ") ; l’algorithme.

lire(nbre)  D’après vous que fait cet algorithme ?

Pour i allant de 1 à nbre faire

som←som + i ;

écrire("la somme est : ", som) ;

Finpour

Fin

Activité 6 : observez attentivement cet algorithme et répondez aux questions y référant.

Soit :

• Indique la structure utilisée dans cet algorithme

Var p, q, i: entier ; tout en spécifiant la condition.
Début • Quand est-ce qu’on sortira de cette boucle
Ecrire (‘entrer un nombre’) ; (condition d’arrêt) ?
Lire (p) ;
Ecrire (‘entrer un autre
nombre’) ;
Lire (q) ;
 i←0 ;
Tant que p≥q faire
p← p-q;
i←i+1 ;
fintantque ;
Écrire (‘le résultat est :’i) ;
Fin algorithme

Activité 7 : Soit l’algorithme suivant :

Var p, q, i: entier ;  Quelles sont les variables de cet

Début algorithme ?
 Peut-on résoudre ce problème en utilisant
Ecrire (‘entrer un nombre’) ;
une structure différente de celle utilisée ?
Lire (p) ; si oui laquelle ?
Ecrire (‘entrer un autre nombre’) ;

Lire (q) ;

i←0 ;

Tant que p≥q faire

p← p-q;

i←i+1 ;

fintantque ;

Écrire (‘le résultat est :’i) ;

Fin algorithme

Activité 8 : en te servant des différentes structures algorithmiques utilisées dans ce cours,

identifies celle qui est appropriée pour la résolution du problème de la situation problème
énoncé au début de la leçon. Ensuite, propose un algorithme pour la résolution de ce problème.

Solutions des activités

Activité 1

1) L’algorithme 1 a pour parties :

 - L’entête : qui définit le nom permutation
- Les déclarations : définies par la déclaration des variables, a, b et c ;
- Le corps de l’algorithme : qui commence avec le mot clé début et se termine à fin
algorithme ;

Pour l’algorithme 2 on a pour parties :

- L’entête : qui n’a pas le nom de l’algorithme

- Les déclarations : définies par la déclaration des variables, A et B ;
- Le corps de l’algorithme : qui commence avec le mot clé début et se termine à fin
2) Identification des éléments constituants chacun des algorithmes ci-dessus :
 Algorithme 1 : est constitué des éléments suivants :
- Les variables : a, b et c
- Des instructions de lecture exemple : Lire(a) et les instructions d’écriture exemple :
écrire (‘’Entrer la valeur de A’’) ;
 Algorithme 2 : est constitué des éléments suivants :
- Les variables : A, B ;
- Des instructions de lecture et d’écriture exemples : lire(A), et écrire (‘’Entrer le premier
nombre’’) ;
- D’une structure algorithmique : la structure si alors sinon fin si ; qui est la structure
alternative complète.

Activité 2 :

a) Cet algorithme est du type séquentiel.

b) Exemple de séquence d’action (tâches) :
- Dresser son lit,
- Brosser ses dents,
- Balayer le sol de la maison, puis le laver ;
- Laver les assiettes ;
- Prendre son bain ;
- S’habiller ;
- Vérifier son sac en fonction de son emploi du temps ;
- Prendre son petit déjeuner ou prendre l’argent des beignets chez les parents ;
- Prendre le chemin de l’école ;
Activité 3 :

a) Après observation, nous remarquons qu’on peut utiliser la structure alternative

complète pour résoudre le problème de la nature et de température de l’eau ;
b) Proposition de solution (algorithme permettant de résoudre ce problème) ;

Soit donc l’algorithme ci-dessous permettant de résoudre le problème de la nature et de

température de l’eau :

Algorithme mention
Variables t : réel
Début
Ecrire (“Entrer la température de l’eau : ”) ;
Lire (t) ;
Si (t<= 0) alors
Ecrire (“ Eau glacée ”) ;
Sinon
Si (0< t <100) alors
Ecrire (“ Eau liquide ”) ;
Sinon
Si (t >100) alors
Ecrire (“ Eau gazeuse ”) ;
Finsi
Finsi
Finsi
Fin
Activité 4

a) Les parties de cet algorithme sont :

 L’entête :
 Les déclarations : const msg et var sexe ;
 Le corps : début à fin
b) Oui dans cet algorithme il y en a une constante qui est définie par : const msg ← ’’C’est
un garçon ’’: chaîne ;
c) La constante « msg » est de type chaîne et la variable sexe est de type caractère ;
 d) Pour adapter cet algorithme à ce qu’il permette aussi d’identifier une étudiant, on aura
à ajouter une deuxième constante msg2 qui sera « C’est une fille » et par la suite vérifier
une fois de plus le contenu de la variable sexe. D’où nous aurons l’algorithme suivant :
Algorithme
const msg ← ’’C’est un garçon ’’: chaîne ;
msg2 ← ’’C’est un garçon ’’: chaîne ;
var sexe : caractère ;
Début
Ecrire (’’Entrer le sexe de l’étudiant ’’) ;
Lire(sexe) ;
Si (sexe = ‘M’ ou sexe = ‘m’) alors
Ecrire(msg) ;
Sinon Si (sexe = ‘F’ ou sexe = ‘f’) alors
Ecrire(msg2) ;
Finsi
Finsi
Fin

Activité 5

a) Les variables de cet algorithme sont : i, som et nbre ;

b) La structure algorithmique utilisée dans cet algorithme est : la structure pour
c) Identifions cette structure :
Pour i allant de 1 à nbre faire
som←som + i ;
écrire("la somme est : ", som) ;
Finpour
d) Cet algorithme calcul la somme des nombres entiers de 1 jusqu’au nombre entré au
clavier par l’utilisateur.

Activité 6

a) La structure utilisée dans cet algorithme est la structure TantQue ; et la condition est
p≥q
b) On sortira de la boucle lorsque p < q
Activité 7

a) Les variables de cet algorithme sont : p, q et i ;

b) Oui on peut résoudre ce problème en utilisant une structure différente de celle utilisée
dans l’algorithme. Exemple de structure la structure ou boucle « répéter jusqu’à »

Activité 8

a) La structure appropriée pour la résolution du problème de la situation problème est la

structure : « TantQue ou Répéter »
b) Un algorithme pour résoudre son problème est :

Algorithme divisio_entiere
Var p, q, i: entier ;
Début
Ecrire (‘entrer un nombre’) ;
Lire (p) ;
Ecrire (‘entrer un autre nombre’) ;
Lire (q) ;
i←0 ;
Tant que p≥q faire
p← p-q;
i←i+1 ;
fintantque ;
Écrire (‘le résultat est :’i) ;
Fin algorithme
 CHAPITRE II : ECRITURE DES ALGORITHMES

Compétences visées :

A la fin de ce chapitre, les étudiants du niveau 1 devront être capables à 100 % de :

 Enumérer quelques structures de données ;

 Déclarer un tableau à une dimension ;
 Utiliser un tableau dans un algorithme (initialiser, accéder, parcourir, afficher, modifier
les éléments) ;
 Déclarer un enregistrement ;
 Utiliser un enregistrement dans un algorithme (initialiser, accéder, afficher, modifier les
champs) ;
 Décrire le rôle d’un sous-algorithme dans un algorithme ;
 Déclarer une fonction / procédure ;
 Etablir la différence entre les variables locales et les variables globales ;
 Ecrire des fonctions et des procédures simples ;
 Appeler une fonction / procédure dans un algorithme ;
 Différencier les paramètres formels des paramètres effectifs ;
 LEÇON 3 : LES STRUCTURES DE DONNEES.

COMPÉTENCES ATTENDUES : A partir d’une liste de tâches présentée aux étudiants,

chaque étudiant d’une classe de 1ère année, … après observation et échange, doit être capable
à la fin de cette leçon de :

 Enumérer quelques structures de données ;

 Déclarer un tableau à une dimension ;
 Utiliser un tableau dans un algorithme (initialiser, accéder, parcourir, afficher, modifier
les éléments) ;
 Déclarer un enregistrement ;
 Utiliser un enregistrement dans un algorithme (initialiser, accéder, afficher, modifier les
champs) ;

L’étudiant performant sera celui qui pourra identifier à 100% les éléments et structures de
contrôle d’un algorithme présenté à lui.

Situation problème :

Après le cours sur l’algorithmique, vous voulez écrire un algorithme qui permet de gérer les
notes des étudiants par matière par classe. Cependant, vous ne savez pas comment représenter
le type Elève… En vous rapprochant de votre grand frère il vous dit qu’il faut utiliser les
structures de données (enregistrements, tableaux). En vous basant sur la documentation,
expliquez ces nouvelles notions.

Introduction

Une structure de données est une manière d’organiser les données pour les traiter plus
facilement. C’est aussi une mise en œuvre concrète d’un type abstrait (en anglais abstract data
type ou ADT : c’est aussi une spécification mathématique d’un ensemble de données et de
l’ensemble des opérations qu’on peut effectuer sur elles.). Différentes structures de données
existent pour des données différentes ou répondant à des contraintes algorithmiques différentes.
Ainsi, on peut citer : les structures finies (constantes, variables, enregistrements), les structures
composées finies (tableaux…), structures récursives (listes, arbres, graphes, piles). Dans ce
cours nous nous limiterons à la présentation sommaire de quelques-unes telles que les
enregistrements, et les tableaux.
 I. Les tableaux
Un tableau (array en anglais) est un ensemble d’éléments de même type désigné par un
identificateur unique. En d’autres termes, c’est une structure de données permettant d'effectuer
un même traitement sur des données de même nature. Chaque élément y est repéré par une
valeur entière nommée indice indiquant sa position au sein de l’ensemble. Dans un tableau, les
cases (indices) sont numérotées à partir de 0.
 Avantage : accès direct au i -ème élément
 Inconvénients : les opérations d’insertion et de suppressions sont impossibles. Sauf si
on crée un tableau de taille plus grande ou plus petite selon l’opération. Il est alors
nécessaire de copier tous les éléments du tableau original dans le nouveau.

Déclaration d’un tableau à une dimension.

Variable « nom de variable » : tableau [IndiceMin .. IndiceMax] de type des éléments ;

Exemple : variable Note : tableau [0 .. 10] d’entier ;

On peut aussi faire d’une variable un type tableau comme suit :

Type Tab = tableau [0 .. 10] ;

Variable Notes : Tab ; // initialisation d’un tableau vide de nom Notes.

N.B : Pour initialiser un tableau, il suffit de le créer, de le parcourir et de le remplir par des
valeurs correspondantes ou par des 0. Ou tout simplement on se limite à la déclaration de la
variable tableau.

1. Parcourir un tableau

Soit le tableau suivant contenant les notes d’un étudiant : Notes

Algo Physique Algébre E.o.E

2.5 8 14 17

En se donnant un élément i indice du tableau, nous savons que les indices d’un tableau vont de
0 à la taille max – 1 du tableau. Notons que la taille max d’un tableau est le nombre d’éléments
max qu’un tableau peut contenir. Dans notre cas la taille est de 4. Car l’indice min est 0 et
l’indice max est 3. On peut parcourir ce tableau pour plusieurs raisons.

 Pour déterminer par exemple quelle est la note qui est obtenue à le cellule 4 ?
 Pour comparer les notes avec celles d’un autre tableau
 Pour attribuer une note dans une cellule
 Pour savoir si le tableau est plein

Dans ce cas, on aura à effectuer plusieurs fois la même opération qui sera celle de parcourir le
tableau. D’où la nécessité d’un algorithme itératif ou répétitif. Le mieux à utiliser sera donc la
boucle Pour. Car, le nombre de fois qu’on aura à parcourir le tableau sera connu aussi tôt que
la taille (max – 1) du tableau. Exemple soit le parcours du tableau note donné par l’algorithme
suivant :

Pour indice allant de 0 à indice_final faire Ou bien :

Bloc d’opérations ; Pour i allant de indice_initial à indice_final
faire
Finpour
Bloc d’opérations ;
Finpour

Dans le deuxième cas cela veut dire que la valeur de l’indice initial peut changer. Alors que le
premier cas a pour indice initial 0 ;

L’utilisation d’un tableau se fait à partir de son nom suivit des crochets qui encadre l’indice
de la case concernant l’élément sur lequel on veut effectuer le traitement. Exemple Note[i]
pour i=0 on a Note [0] =2.5 c’est-à-dire la valeur du contenu de la cellule numéro 0.

Exercice : donner l’instruction qui permet de retrouver la note de l’informatique ?

Dès lors nous pouvons effectuer des opérations de lecture d’affectation et d’affichage sur
un tableau.

2. Affectation d’un élément dans un tableau à une position donnée

L’affectation d’une valeur dans une cellule d’un tableau utilise toujours le symbole
«  » en algorithmique. Exemple : tab[1]  3 ; ou X  tab[2] ; ces deux instructions veulent
dire respectivement : affecter à la deuxième cellule du tableau tab la valeur 3. Et la deuxième
instruction veut dire affecter à X la valeur de la cellule tab dans la variable X.

Exercice : attribuer la note 12 au tableau Note à la cellule concernant l’informatique.

 3. Lecture d’un élément du tableau à une position donnée

La lecture d’un élément du tableau se fait grâce l’instruction « lire ». Exemple lire(tab[1]) ; qui
permet de lire la donnée que l’utilisateur va saisir au clavier pour l’enregistrer dans la deuxième
cellule ou tout simplement dans la cellule correspondant à l’indice 1.

Exercice : donner la syntaxe de l’instruction permettant à un utilisateur d’entrer une note à

l’INFO.

4. Affichage du contenu d’un tableau à une position donnée

L’affichage du contenu d’un tableau à une position donnée se fait grâce à l’instruction « écrire ».
Exemple : écrire(Note[2]) ; permet d’afficher à l’écran la valeur du contenu de la cellule numéro
2 du tableau note qui est égale à 14.

Exercice : écrire un algorithme qui permet de créer un tableau nommé Note2 de taille 5 qui
prend les différentes notes du tableau Note dans les cellules respectives. Ensuite, modifie la
note de maths de cet étudiant en 5 au lieu de 2.5. Puis, calcule leur somme et affecte cette
somme à la dernière cellule du tableau Note2.

II. Les enregistrements

L’enregistrement est une façon de créer un nouveau type. C’est-à-dire un type qui contient
d’autres variables (appelées champs) de types déjà définis. Ces champs peuvent être de type
différent.

Toute variable déclarée avec ce nouveau type utilise alors une zone mémoire suffisante
pour y stocker tous champs de l’enregistrement.
 Syntaxe de déclaration : Exemple : Créer un enregistrement de Type
Elève.

Type
Type
Nom_type = Enregistrement
Elève= Enregistrement
Champ1 : type1 ;
Matricule : chaîne ;
Champ2 : type2 ;
Nom : chaîne ;
……………
Classe : chaîne ;
ChampN : typeN ;
Age : entier ;
FinEnregistrement
Sexe : caractère ;

FinEnregistrement

Pour initialiser un enregistrement on le fait de la même façon que l’initialisation d’un tableau ;
Pour manipuler un enregistrement, on le fait champ par champ. On accède à un champ de
l’enregistrement en indiquant le nom de l’enregistrement suivi d’un point et enfin du nom du
champ. Exemple : Eleve.Nom ; dès lors nous pouvons effectuer les opérations normales sur les
champs telles que : attribuer une valeur à un champ, accéder à un champ, afficher, modifier un
champ…

Exercice : En se servant du type Elève que nous avons déclaré à l’exemple précédent, écris un
algorithme qui permet de manipuler ce type en répondant aux questions suivantes.

i. Initialise un enregistrement de type Elève ;

ii. Accède aux différents champs et enregistre cet étudiant : « 21Y0606, Daysie Cami, GI1
C, 19, M » ;
iii. Affiche l’âge de cet étudiant ;
iv. Modifie le nom de cet étudiant en le remplaçant par « Bob Karl ».
1. Initialisation d’un enregistrement étudiant

Comme nous avons vu plus haut, nous initialisons l’étudiant comme une simple déclaration de
variable en supposant que le Type Elève a été déjà créé. Ainsi, nous avons :

Var e : Elève ;
 2. Accéder à un champ de l’enregistrement

Pour accéder à un champ de l’enregistrement on utilise juste le nom de l’enregistrement

suivi d’un point et enfin du nom du champ ; Exemple : Eleve.Nom ; permet d’accéder au champ
Nom de l’enregistrement. C’est ainsi que tous les autres champs de l’enregistrement seront
accédés.

Ainsi pour enregistrer un étudiant on peut procéder comme suit :

Var e : Elève ; On peut aussi utiliser l’instruction lire (),

pour récupérer les valeurs entrées au clavier
Début
par un utilisateur pour les champs d’un
e.Matricule ← " 21Y0606 " ;
enregistrement. Exemple :
e.Nom ← " Daysie Cami " ;
Lire (e.Nom) ;
e.Classe ← " GI1 C " ;
Lire (e.Matricule) ; …
e.Age ← 19 ;

e.Sexe ← ' M ' ;

Fin

3. Afficher un champ d’un enregistrement

Pour afficher le contenu d’un champ d’un enregistrement, on utilise l’instruction écrire () ;
comme suit :

Ecrire (e.Nom) ; va afficher « Daysie ». Ainsi de suite …

4. Modifier un champ d’un enregistrement

Cette opération se fait soit par lecture ou par une affectation directe. Exemple modifier le nom
de l’étudiant « Daysie Cami » en « Bob Karl ».

Solution : e.Nom ← " Bob Karl " ;

 LEÇON 4 : FONCTION ET PROCEDURE.

COMPÉTENCES ATTENDUES : Après cette leçon, chaque étudiant de la 1ère année devra
être capable de :

 Décrire le rôle d’un sous-algorithme dans un algorithme ;

 Déclarer une fonction / procédure ;
 Etablir la différence entre les variables locales et les variables globales ;
 Ecrire des fonctions et des procédures simples ;
 Appeler une fonction / procédure dans un algorithme ;
 Différencier les paramètres formels des paramètres effectifs ;

Introduction

Diviser pour mieux régner est généralement la solution la mieux partager pour résoudre
des problèmes un peu plus complexes. C’est ainsi qu’il devient important voir nécessaire
d’étudier et d’utiliser les sous-programmes (sous-algorithme) pour alléger la résolution des
problèmes complexes. Ces sous-algorithmes dont nous verrons dans cette leçon sont des
fonctions et procédures.

I- Définition et Rôle d’un sous-algorithme.

1- Définition

Sous-programme ou sous-algorithme : C’est une suite finie et ordonnée d’instruction

regroupé sous un nom et pouvant être exécuté de manière atomique.

Autrement dit, c’est un programme indépendant de son contexte (autonome), réutilisable

dans plusieurs contextes.

Le terme « sous-programme » est un terme générique qui englobe à la fois les procédures et les
fonctions.

2- Rôle d’un sous-algorithme ou sous-programme

Un sous-programme permet au programmeur d’étendre le langage de programmation en

définissant ses propres instructions et ses propres opérateurs qu’il pourra ensuite réutiliser. En
générale, un sous-algorithme permet de :

 Découper l’algorithme (action) en sous-algorithmes (sous-actions) plus simples,

 Mettre en commun les parties qui se répètent,
 Simplifier et faciliter la maintenance du code,
  Structurer et donner une meilleure lisibilité des programmes,
 Réutiliser dans d’autres algorithmes/programmes,
II- Déclaration de fonction / procédure
1- Déclaration de fonction

Une fonction est un sous-algorithme qui, à partir de donnée(s), calcule et rend à

l’algorithme Un et Un seul résultat.Autrement dit, c’est un bloc d’instructions qui retourne
obligatoirement une et une seule valeur (résultat) à l’algorithme appelant.

Remarque :

Une fonction n’affiche jamais la réponse à l’écran car elle la renvoie simplement à
l’algorithme appelant. Donc, Le rôle d'une fonction est similaire à celui d'une fonction en
mathématique : elle retourne un résultat à partir des valeurs des paramètres.

Une fonction s’écrit en dehors du programme principale sous la forme :

Fonction nom_fonction (paramètres et leurs types) : type_fonction

Déclaration des variables locales…

Début

Instructions;

retourne … ;

FinFonction

 Pour le choix d'un nom de fonction il faut respecter les mêmes règles que celles pour les
noms de variables,
 Type_fonction est le type du résultat retourné,
 L'instruction retourne sert à retourner la valeur du résultat.

Exemples :

 Ecrire la fonction Pair qui permet de déterminer si un nombre est pair ou non.
 Ecrire la fonction Sqrt qui calcule la racine carrée d’un nombre entier.

Pour la fonction Pair : Pour la fonction Sqrt (Racine carrée) :

Fonction Pair (nbre : Entier) : Booléen Fonction Sqrt (nbre : Entier) : Réel
 Variable res : Booléen ; Variable res : Réel ;

Début Début

Si (nbre % 2 = 0) alors res  (nbre)^1/2 ;

res  true ; retourne res ;

Sinon Finfonction

res  false ;

finsi

retourne res ;

Finfonction

Ou tout simplement la fonction Pair ci-

dessous :

Fonction Pair (nbre : Entier) : Booléen

Début

retourne (nbre % 2 = 0) ;

Finfonction

 L’appel (utilisation) d’une fonction se fera par simple écriture de son nom dans le
programme principal.
 Le résultat d’une fonction étant une valeur, devra être affecté ou utilisé dans une
expression, une écriture.
Exemple : écrire un algorithme qui demande un nombre entier à un utilisateur et affiche
la racine carrée de ce nombre s’il est pair.
 L’Algorithme du Problème est le suivant :

Algorithme RacineCarreeNombrePair
Variable nbre : Entier ;

Fonction Pair (nbre : Entier) : Booléen

Début

retourne (nbre % 2 = 0) ;

Finfonction

Fonction Sqrt (nbre : Entier) : Réel

Variable res : Réel ;

Début

res  (nbre)^1/2 ;

retourne res ; Sont des appels des

fonctions respectives Pair
Finfonction
et Sqrt

Début
Ecrire ("Entrer un nombre") ;
Lire (nbre) ;
Si Pair(nbre) alors
Ecrire ("La Racine Carrée de : ",nbre, " est : ", Sqrt (nbre)) ;
Sinon
Ecrire (nbre," n’est pas un nombre pair ") ;
Finsi
Fin

2- Déclaration de procédure

Dans certains cas, on peut avoir besoin de répéter une tâche dans plusieurs endroits du
programme, mais que dans cette tâche on ne calcule pas de résultats. Dans ces cas, on ne peut
pas utiliser une fonction, on utilise plutôt une procédure.
 Une procédure est un bloc d’instructions nommé, déclaré dans l’entête de l’algorithme et
appelé dans son corps à chaque fois que le programmeur en a besoin.

C’est un sous-programme semblable à une fonction mais qui ne retourne rien ou retourne
un ou plusieurs résultats de façon implicite.

Une procédure s'écrit en dehors du programme principal sous la forme :

Procédure nom_Procédure (paramètres et leurs types)

Déclaration des variables locales…

Début

Instructions ;
FinProcédure

Remarque : Une procédure peut ne pas avoir de paramètres.

L'appel d'une procédure, se fait dans le programme principal ou dans une autre procédure par
une instruction indiquant le nom de la procédure :

Exemples : les procédures Ecrire () ; Lire () ;

Remarque :

 Contrairement à l'appel d'une fonction, on ne peut pas affecter la procédure appelée

ou l'utiliser dans une expression.
 L'appel d'une procédure est une instruction autonome.

III- Variables Locales / Variables Globales

On peut manipuler deux (02) types de variables dans un module (procédure ou fonction) qui
sont :

 Des variables locales

 Des variables globales.

Elles se distinguent par ce qu'on appelle leur portée (leur "champ de définition", leur "durée de
vie").

Une variable locale n'est connue qu'à l'intérieur du module ou elle a été définie. Elle est
créée à l'appel du module et détruite à la fin de son exécution.
 Une variable globale est connue par l'ensemble des modules et le programme principal.
Elle est définie durant toute l’application et peut être utilisée et modifiée par les
différents modules du programme.

Remarque :

La manière de distinguer la déclaration des variables locales et globales diffère selon le

langage.

En général, les variables déclarées à l'intérieur d'une fonction ou procédure sont

considérées comme variables locales.
En pseudo-code, on va adopter cette règle pour les variables locales et on déclarera les
variables globales dans le programme principal.

Conseil :

Il faut utiliser autant que possible des variables locales plutôt que des variables globales.
Ceci permet d'économiser la mémoire et d'assurer l'indépendance de la procédure ou de la
fonction.

Exemples :

1. Ecrire une fonction qui calcule le cube d’une valeur.

2. Ecrire une procédure qui calcule la somme des n premiers entiers non nul.

N.B : Sur l'écran apparaît le message :

Entrez la valeur de n :

Si on entre 3, on obtient somme = 6 ;

1. Fonction cube d’un nombre 2. Procédure somme

Fonction Cube (n : Entier) : Entier Procédure Somme ()

Début Variables som, i, n : entiers ;

retourne (n * n * n) ; som ← 0 ;

Finfonction Début

Ecrire ("Entrez la valeur de n : ") ;

Lire (n) ;
 Pour i allant de 1 à n faire

som ← som + i ;

Finpour

Ecrire ("Somme = ", som) ;

Finprocédure

IV- Paramètres formels et Paramètres effectifs

Soit l’exemple suivant :

 Définition de la Fonction :
Fonction Pair (n : entier) : booléen
retourne (n%2=0);
FinFonction

 Appel de la Fonction :

b ← Pair(3) ;

Lors de l'appel de la Fonction Pair(3) ; le paramètre formel n est remplacé par le paramètre
effectif 3.

Les paramètres servent à échanger des données entre le programme principal (ou la
procédure/fonction appelante) et la procédure/fonction appelée.

Les paramètres placés dans la déclaration d'une procédure/fonction sont appelés

paramètres formels. Ces paramètres peuvent prendre toutes les valeurs possibles mais ils
sont abstraits (n'existent pas réellement).
Les paramètres placés dans l'appel d'une procédure/fonction sont appelés paramètres
effectifs. Ils contiennent les valeurs pour effectuer le traitement.
Le nombre de paramètres effectifs doit être égal au nombre de paramètres formels. L'ordre
et le type des paramètres doivent aussi correspondre.
 LECON 09 : LES ALGORITHMES DE TRI

INTRODUCTION

Réaliser un tri (ou un classement) est une opération relativement courante dans la vie
quotidienne. On peut trier par ordre alphabétique les produits d’une pharmacie, les livres d'une
bibliothèque, un agenda téléphonique suivant l’ordre alphabétique des noms des individus
(même au fur et à mesure de l'insertion de nouveaux numéros). Les tris portent aussi sur des
nombres, des nombres assez importants de données. En effet, les tableaux permettent de stocker
plusieurs données de même type. Si ces données possèdent un ordre total, on peut donc les
ranger en ordre croissant ou décroissant. Ainsi, trier un tableau c’est donc ranger ses éléments
suivant un ordre déterminé (croissant ou décroissant). Il existe plusieurs méthodes de tri : les
tris par sélection, les tris par insertion, les tris par bulles, les tris rapides (quick sort), les tris par
fusion, les tris par tas… Tous ces algorithmes de tri utilisent généralement une procédure qui
permet d’échanger (de permuter) la valeur de deux variables.

Rappel Procédure Permuter (a,b : Entier)

vartemp : Entier ;

Début
temp ← a ;

a←b;

b ← temp ;

FinProc

I. L’algorithme de tri par sélection

Principe : Elle consiste à construire petit à petit une tranche triée grandissante du tableau en
cherchant le plus petit (le plus grand) élément du tableau pour le mettre en début (premier), puis
repartir du second élément du tableau pour chercher le 2e plus petit (le 2e plus grand) élément
pour le mettre en second, ainsi de suite jusqu’à ce que le tableau soit trié dans l’ordre de notre
choix.

Soit le tableau T[1..n] de nombres à trier. La procédure pour trier ces éléments dans l’ordre
croissant est la suivante :
Procédure tri_sélection (T[1..n], : tableau de …)
var i, j : entier ;

Début
pour i allant de 1 à n-1 faire
pour j allant de i+1 à n faire
si T[i] > T[j] alors
Permuter(T[i], T[j])
fsi
fpour

Fpour

FinProc

NB :

 Un tableau vide est trié

 Un tableau ne contenant qu’un seul élément est trié
Jeu bilingue : Trier = To sort (en anglais) d’où Tri rapide = Quick sort (en anglais)

Exercice d’application :

1. Exécuter ce programme sur le tableau d’entiers T = [5, 12, 45, 0, 17]

2. Ecrire la procédure de tri par sélection pour classer les éléments dans l’ordre décroissant.

II. Le tri par insertion

Principe : Elle consiste à insérer les éléments les uns après les autres dans la partie triée.
Généralement, La partie de départ qui est triée est le premier élément. En insérant un élément
dans la partie triée, il se pourrait qu’on ait à déplacer plusieurs autres.

Soit le tableau T[1..n] de nombres à trier. La procédure pour trier ces éléments dans l’ordre
croissant est la suivante :
Procédure tri_insertion(T[1..n], : tableau de …)

vari,j : entier ;

Début

Pour i allant de 2 à n faire

j<-i-1 ;

Tant que j>= 1 et t[j]>t[j+1] faire

Permuter (T[j+1], T[j]) ;

j<-j-1 ;

ftantque
fpour
FinProc

Après l'étape i, tous les éléments entre la première et la ième position sont triés.

L’algorithme du tri par fusion suit fidèlement la méthodologie diviser-pour-régner.

Intuitivement, il agit de la manière suivante :

Diviser : Diviser la suite de n éléments à trier en deux sous-suites de n/2 éléments chacune.
Régner : Trier les deux sous-suites de manière récursive en utilisant le tri par fusion.
Combiner : Fusionner les deux sous-suites triées pour produire la réponse triée.

La récursivité s’arrête quand la séquence à trier a une longueur 1, auquel cas il n’y a plus rien
à faire puisqu’une suite de longueur 1 est déjà triée. D’où :

Procédure triFusion(T, debut, fin)

Si debut > fin alors

Milieu = (debut + fin)/2 ;

triFusion (T, debut, milieu)

trifusion (T, milieu +1, fin)

fusion(T, debut, fin, milieu)

Exercice d’application :

1. Exécuter ce programme sur le tableau d’entiers T = [5, 12, 45, 0, 17]

2. Ecrire la procédure de tri par insertion pour classer les éléments dans l’ordre décroissant.