Cours d’algo

Progression

Chap1 INTRODUCTIONS GENERALES

1.1. Notions d’algorithmes

1.2. Les variables et types
1.2.1. variables
1.2.2. Types de variables et la déclaration

1.3. Entrées/Sorties: lecture et écriture

1.3.1. Lecture
1.3.2. Ecriture
1.3.3. Affectation

1.4.Les tests et les conditions

1.4.1. Structure de choix
1.4.2. Structure de répétition

1.5. Quelques primitives

1.5.1. L’affectation
1.5.2. Les opérateurs arithmétiques
1.5.3. Expressions logiques

1.6. Procédures et fonctions

1.6.1. les procédures
1.6.2. les fonctions
1.6.3. Modes de passage des paramètres
1.6.4. La récursivité et les fonctions récursives

1.7.Les tableaux
1.7.1. le tableau à une dimension
1.7.2. tri d’un tableau à une dimension
1.7.3. le tableau à deux dimensions

KOFFI K Yves Professeur à l’INP-HB Page 1

 Cours d’algo

1.8. les enregistrements

1.8.1. Déclaration
1.8.2. Accès aux champs

1.9.les fichiers
1.9.1. introduction
1.9.2. définition et déclaration
1.9.3. codage des informations dans le fichier
1.9.4. méthode d’accès
1.9.5. manipulation des fichiers

Chap2 Structures de données avancées

2.1. les listes
2.1.1. introduction
2.1.2. les listes chaînées
2.1.3. les listes doublements chaînées
2.1.4. les piles
2.1.5. les files

Chap3 les arbres

3.1. introduction
3.2. représentation des arbres
3.3. parcours
3.4. arbres binaires de recherches

KOFFI K Yves Professeur à l’INP-HB Page 2

 Cours d’algo

Chap1 INTRODUCTIONS GENERALES

1. Notions d’algorithmes

1.1. Introduction
L'ordinateur effectue des traitements sur des données. Mais celui-ci ne serait capable de rien si quelqu'un (le
programmeur en l'occurrence) ne lui avait fourni la liste des actions à exécuter. Cette description doit être faite
de manière non ambigüe. Le programmeur se sert de l’algorithmique pour décomposer un problème en
problèmes plus simples afin de les résoudre en les adaptant au langage de son Choix.
En d’autre terme un algorithme est l’énoncé d’une suite d’opérations permettant de donner la réponse à un
problème.
Le programme ne sera que la traduction de l'algorithme dans un langage de programmation, un langage plus
simple que le français dans sa syntaxe, sans ambiguïtés, que la machine peut utiliser et transformer pour
exécuter les actions qu'il peut décrire : Pascal, C, Java, Visual Basic sont des langages de programmation.
Le mot algorithme provient du nom d'un célèbre mathématicien arabe de la première moitié du IXe siècle:
Muhammad ibn Musa al Khuwarizmi et défini par l’encyclopédie universelle comme suit :
" Un algorithme est une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini de données
pour arriver, en un nombre fini d'étapes, à un certain résultat, et cela indépendamment des données. "
Cependant en informatique un algorithme est donc une séquence d’étapes de calcul qui transforment l’entrée
en sortie.
La résolution d'un problème passe par toute une suite d'étapes :

Énoncé du problème

Niveau de
l’homme Algorithme

Langage assembleur Langage évolué

Niveau de Assembleur Compilateur ou interpréteur

machine

Programme en langage binaire (langage machine)

KOFFI K Yves Professeur à l’INP-HB Page 3

 Cours d’algo

L’organisation d’un algorithme comporte 3 étapes : la présentation du traitement, le traitement et l’édition

des résultats.
 La présentation du traitement permet d’identifier et de définir les données nécessaires à la résolution
des problèmes
 Le traitement a pour but de d’écrire les procédures permettant d’atteindre les résultats
 L’édition des résultats permet de mettre en forme les résultats du traitement puis de restituer sur un
support externe à l’organe de traitement.

L’algorithme peut se redéfinir comme une machine logique développant des actions, admettant des données
en entrée et fournissant des résultats en sortie.

Données Actions Résultats

Remarque :
Un algorithme doit
 être fini (achevé après un nombre fini d’actions élémentaires)
 être précis (la machine n’a pas à choisir)
 être effectif (On pourrait le traiter “ à la main ” si on avait le temps)
 mentionner les entrées (saisie de données) et les sorties (affichage des résultats)

La programmation quand à elle peut être représenter de la manière suivante :

Problème

Analyse Algorithme

Traduction Programme

Exécution Résultat

et est définie comme des séquences d’instructions qui permettent de donner des ordres à un ordinateur.
Elle sert à développer des applications, à effectuer des calculs complexes, à automatiser des tâches
récurrentes.

KOFFI K Yves Professeur à l’INP-HB Page 4

 Cours d’algo

1.1.1. Structure d’un algorithme

La structure l’algorithme se décompose en 2 grandes parties :

 La première ligne indique le nom de l’algorithme
 La deuxième partie, le traitement, situé entre les mots clés Début et Fin , contient le bloc
d’instructions.
Syntaxe :
Algorithme nom-de-l’algorithme // en-tête
Debut
Bloc d’instruction ; // partie instruction
Fin
Remarque : Chaque ligne comporte une seule instruction.
L’exécution de l’algorithme correspond à la réalisation de toutes les instructions,
ligne après ligne de la première à la dernière dans cet ordre.

Exemple :
Algorithme salutation
Début { Affiche Bonjour à l'écran }
Ecrire ('bonjour tout le monde')
Fin.

2. Les variables et types de variable

2.1. variables
En programmation, une variable est un nom qui sert à repérer un emplacement mémoire par l’ordinateur
pour stocker une information. On peut faire évoluer sa valeur au fil du déroulement du programme. On
donnera aux variables des noms évocateurs des informations qu’elles désignent.
Ces noms de variable sont aussi appelés des identificateurs.
Exemple : montant est certainement un meilleur choix que x pour designer le montant d’une facture.
nom pour designer le nom d’une personne ou un objet.

2.2. Types de variables et la déclaration

2.2.1. Types de variables
Chaque information devra disposer d’un codage approprié, on parle de type d’une variable.
Lorsque l’ordinateur alloue un espace en mémoire, il tient compte du type de la variable pour déterminer
la taille de l’espace à réserver.
On peut rencontrer des types connus: numériques (entiers, réels), les alphanumériques (caractères,
chaînes de caractères), les booléens ( vrai ou faux) ainsi que des types plus complexes et pouvant être
définis par le programmeur. Au niveau des langages de programmation à un type de données correspond
toujours un nombre d’octets (bits) donné.
Généralement les langages de programmation offrent les types suivants :

KOFFI K Yves Professeur à l’INP-HB Page 5

 Cours d’algo
 Entier : Il s’agit des variables destinées à contenir un nombre entier positif ou négatif. Dans notre
langage, la déclaration des variables de type entier est la suivante :
ENTIER : variable, variable1,…
Généralement un entier occupe 2 octets, ce qui limite les valeurs de -32768 à +32768. Cependant cela
dépend des machines, des compilateurs, et des langages. Certains langages distinguent les entiers
courts (1 octet), les entiers longs (4 octets) et les entiers simples (2 octets).
 Réel : Il s’agit des variables numériques qui ne sont pas des entiers, c’est à dire qui comportent des
décimales. Généralement un nombre réel est codé sur 4 octets. La déclaration des variables de type
réel est la suivante:
REEL : variable, variable1
Caractère : Les variables de type caractères contiennent des caractères alphanumériques ou
numériques (de 0 à 9), mais dans ce cas ils ne sont pas considérés comme étant des nombres et on ne
peut pas faire d’opérations dessus. Un caractère occupe 1 octet. La déclaration des variables de type
caractère est la suivante:
CARACTERE : variable, variable,…
 Booleen : les variables de type booléen prennent les valeurs VRAI ou FAUX (OUI ou NON).
Syntaxe :
BOOLEEN : variable, variable,…;
Exemple :
Booleen : petit, moyen ;

2.2.2. La constante
Certaines données sont fixes tout au long du problème. Ce sont les caractéristiques statiques du problème
ou encore des constantes.
Les constantes seront précédées du mot CONST afin de les distinguer des variables.
La déclaration d’une constante doit être suivie de son affectation :

Syntaxe :
CONST TYPE :nomconstante valeurdelaconstante
Exemple :
CONST Reel : Pie 3,14

2.2.3. Variable
Les variables sont des objets manipulés ( modifiables) par les algorithmes.
Elles possèdent 3 caractéristiques de base: son nom (identificateur), son type et sa valeur

KOFFI K Yves Professeur à l’INP-HB Page 6

 Cours d’algo
 L’identificateur d’un objet permet de le designer de façon unique. Il est un nom symbolique
alphanumérique qui sert à distinguer l’objet des autres. Il désigne une zone mémoire ou une adresse
mémoire.
 Le type est le domaine de définition de l’objet ou le référentiel des valeurs prises. Il est constitué de
numériques (entier, réel), alphanumériques (caractère, chaîne de caractère), booléen …
 La valeur est un élément du référentiel ou la fonction pour dire ce à quoi il sert.

2.2.4. Déclaration de variable

Déclarer une variable, c’est réserver une certaine place mémoire adaptée au type de la variable et lui
associer un identificateur.
Syntaxe :
nomtype : identificateur

Exemple :
entier : nombre
réel : nombrereel (déclaration de variables)
caractere : A, B, C
Chaine de caractere : nom, prenom, ville
réel : g = 9.81 (déclaration de constante)

Remarque :
Pour utiliser une variable ou une constante, il faut d’abord la déclarer.
il est possible d’attribuer une valeur initiale à une variable au moment de sa déclaration.

Dans le langage PASCAL, ces types ci dessus se traduisent de la manière suivante :

nombre : Integer;
réel : Real;
reponse : Char ;

Remarque :
 Un identificateur est une suite de caractère commentant par un caractère alphabétique ;
 Tous les caractères ont le même niveau d’écriture (pas d’indice ni d’exposant) ;
 Choisir des identificateurs significatifs ;
 Choisir des identificateurs facilement prononçables ;
 Eviter les abréviations non courantes.

En résumé une variable est caractérisée par un nom et un type.

Le nom sert à repérer un emplacement mémoire. Le type précise la taille de cet emplacement, la manière dont
l’information y est codée, les opérations autorisées ainsi que les valeurs représentables.

KOFFI K Yves Professeur à l’INP-HB Page 7

 Cours d’algo

3. Entrées/Sorties: lecture et écriture

Les instructions d’entrées- sorties permettent la communication entre l’utilisateur et l’ordinateur.

Les instructions sont : Lire et Ecrire.

3.1. Lecture
Nous pouvons transmettre des informations (données) à notre programme en faisant appel à des
instructions de lecture utilisant des périphériques de communication (le clavier).
Ces instructions permettent à l’utilisateur de rentrer des valeurs au clavier lesquelles seront utilisées par le
programme. Cette opération est la lecture.
Instruction lire (A) ou saisir A signifie mettre dans la case A la valeur présente sur l’organe d’entrée de
la machine c'est-à-dire affecter à la variable A la valeur tapée au clavier.
Au moment de l’exécution, il faudrait fournir à la machine la valeur de A
syntaxe :
lire variable
Exemple :
Algorithme lecture
Reel : x1, x2
Debutalgo
Ecrire( 'donner le premier réel')
Lire ( x1)
Ecrire 'donner ledeuxième réel'
Lire ( x2)
Ecrire ('deux réels fournis sont :', x1et x2)
Finalgo

3.2. Écriture ou affichage

Pour qu’un programme présente un intérêt pratique, il devra pouvoir produire des informations (résultats)
qui seront transmis à un périphérique de communication (écran) en faisant appel à des instructions
d’écritures. On parle alors d’affichage
Instruction est écrire (X) ou afficher X signifie mettre sur l’organe de sortie de la machine le contenu de la
case X c’est à dire restituer à l’écran, le contenu de ses données. Il s’agit d’afficher X à l’écran.
Syntaxe :
ecrire variable
Exemple :
algorithme ecriture
Reel : x1, x2
Debutalgo
Ecrire( 'donner le premier réel')
Lire ( x1)
Ecrire( 'donner le deuxième réel')
KOFFI K Yves Professeur à l’INP-HB Page 8
 Cours d’algo
Lire (x2)
Ecrire ('deux réels fournis sont :', x1, x2)
Finalgo

4. Quelques primitives
4.1. L’affectation
L’affectation est l’opération consistant à ranger ou à attribuer une valeur à une variable (un objet).
Syntaxe :
Variable valeur
On lit « variable reçoit valeur » et qui signifie que l’on mémorise la valeur à un endroit nommé variable.
Exemple :
somme 500
somme somme+500

4.2. Les opérateurs

Un opérateur est un signe qui relie deux valeurs pour produire un résultat. Les opérateurs dépendent
du type des valeurs.
4.2.1. Les opérateurs arithmétiques
On a : +, -, *, / , mod

4.2.2. Expressions logiques

Les opérateurs logiques sont : la négation non, la conjonction et, la disjonction ou.

4.2.3. Les opérateurs relationnels

Les opérateurs relationnels sont applicables aux données de types simples ordonnés : < , <=, >, >=, =, <>
Les variables d’entrée sont de type entier ou réel et celles de sortie sont de type booléen.

5. Les tests et les conditions

Un programme est une suite d’instructions exécutée par la machine.
Son exécution correspond à l'exécution de la suite des actions qui le compose.
Les structures de contrôle (tests et contrôles) indiqueront comment s'organisent les actions dans le temps et
comment elles s'enchaînent.
Ces instructions peuvent soit s’enchaîner les unes après les autres, on parle alors de séquence d’instructions.
Soit s’exécuter dans certains cas et pas dans d’autres, on parle alors de structure alternative, ou encore se
répéter plusieurs fois, on parle alors de structure répétitive.

5.1. les structures de choix

Il y a 3 types de structures de choix: la séquence, l'alternative et les conditions multiples.
KOFFI K Yves Professeur à l’INP-HB Page 9
 Cours d’algo

5.1.1. La séquence

La séquence est la structure la plus simple que l'on puisse trouver.

Elle permet l'évaluation ordonnée d'une suite d'expressions. L'exécution d'une telle structure correspond à
l'exécution des instructions les unes à la suite des autres.
Syntaxe
action1
action2
...
actionN

On exécute d'abord action1 puis action2, action3,... et enfin actionN.

Exemple :
Algorithme calcul_somme
entier : montant, somme
Debutalgo
Ecrire ‘ Donner le montant
lire montant saisie la variable au clavier
somme mantant + 500 instruction d’incrémentation
ecrire somme affichage
finalgo

5.1.2. L’alternative
L'alternative est une structure qui permet l'exécution d'une action ou d'une séquence d'actions à partir du
moment où une condition est vérifiée c’est à dire si une certaine condition est réunie.
5.1.2.1. condition SI
Le test si est la forme d'alternative la plus simple: si condition est vérifié on exécute action. Si la condition
n’est pas vérifiée alors action n’est pas exécutée.
Syntaxe :
SI condition Alors action FINSI
Exemple :
Algorithme valeur_absolue
(* Ce programme calcule la valeur absolue d'un nombre donne par un utilisateur. On utilise deux conditionnelles.*)
Reel : nombre, valeurabsolue
Debutalgo
Ecrire ('De quel nombre voulez-vous la valeur absolue ?')
nombre’
Si (nombre >= 0) alors valeurabsolue nombre
Si (nombre < 0) alors valeurabsolue - nombre
Ecrire ('La valeur absolue de ',nombre,' est ',valeurabsolue)
Finalgo

KOFFI K Yves Professeur à l’INP-HB Page 10

 Cours d’algo
Exercice d’application
Ecrire l’algorithme qui permet de résoudre une équation du premier degré dans IR( ax + b = 0 ) . Les
coefficients a, b étant saisis par l’utilisateur.
Algorithme equation
Réel : a, b, x déclaration de variables
Debutalgo
Ecrire ‘ Donner les coefficients a, b des monômes ‘ /* saisie des coefficients */
lire (a, b )
si a = 0 alors
debut
si b = 0 alors
debut
ecrire (‘ la solution est IR’)
finsi
si b<>0 alors
debut
ecrire (‘la solution est l’ensemble vide’)
finsi /* syntaxe de l’ instruction */
finsi
si a<> 0 alors
debut
si b = 0 alors
debut
x 0
ecrire (‘ la solution est ‘ , x)
finsi
si b<> 0 alors
debut
b
x
a
ecrire (‘ la solution est ‘ , x)
fin
finsi
finalgo

Chacune des séquences d'instructions d'un SI condition Alors action FINSI peut contenir des
SI condition Alors action FINSI. On dit alors que les structures sont imbriquées.

5.1.2.2. Condition SINON

Syntaxe:
SI condition Alors
action1
SINON
action2
FINSI

Si la condition est vraie, les instructions dans action1 sont exécutées. Dans le cas contraire, ce sont les
instructions dans action2 qui sont exécutées.
Le mot SINON indique où se termine la première séquence d'instructions et où commence la seconde.
KOFFI K Yves Professeur à l’INP-HB Page 11
 Cours d’algo
Exemple :
Un client achète un article dans un surper marché. Après saisie du prix à payer et de la somme versée par le
client, afficher la monnaie à rendre au client si celle-ci est positive.

Algorithme monnaie_à_rendre
Entier : prix, sompayée, monnaie déclaration de variables
Debutalgo
ecrire (‘Saisir le prix de l’article ’ )
lire (prix)
ecrire (‘saisir la somme à payer ’ ) saisie
lire (sompayée )
monnaie sompayée – prix syntaxe de décrémentation
si monnaie >=0 alors
debut
ecrire (‘La somme à rendre est’ , monnaie)
fin syntaxe de l’instructuin +affichage
sinon
debut
ecrire (‘ La somme payée est insuffisante ’ )
fin
finalgo

Remarque : la partie sinon n'est pas obligatoire. Quand elle n'existe pas et que la condition n'est pas vérifiée,
aucun traitement n'est réalisé. Dans ce cas on a :
Syntaxe
SI condition alors
action1
FINSI

5.1.3. Les conditions multiples

Plutôt que d’effectuer plusieurs tests les uns à la suite des autres, il est plus judicieux d’utiliser le « test à
choix multiples » qui permet d’effectuer un traitement en fonction de la valeur d’une variable.
L’instruction de condition multiple est une spécialisation de l'instruction sinon si.
Cette instruction est utilisée quand on a plusieurs alternatives (au moins 3 alternatives).
On doit tester une condition plusieurs fois, en utilisant toujours la même variable.
Syntaxe :
SELONQUE Variable
CAS Valeur1:
action1
CAS Valeur2:
action2
CAS Valeur3:
Action3
..
CAS Valeurn:
actionn
FINSELONQUE

KOFFI K Yves Professeur à l’INP-HB Page 12

 Cours d’algo

Exemple :
Algorithme test_nombre
Entier : nombre déclaration de variables
Debutalgo
ecrire(‘’Donnez un entier positif : ’’) ;
lire nombre ;
si nombre>=0 alors
selonque nombre
debut
0 : ecrire(‘’le nombre saisie est nul’’)
1 : ecrire(‘’le nombre saisie est un’’)
2 : ecrire(‘’le nombre saisie est deux’’)
sinon
ecrire( ‘’Le nombre saisi est supérieur à deux’’)
finselonque
finalgo

Exemple :
Ecrire un algorithme qui permet de saisir l’âge d’un individu au clavier puis l’afficher à l’écran en précisant
les messages selon les tranches d’âge suivant :
Moins de 17 ans, tu es encore mineur,
à 18 ans « tu as atteint la majorité ». Entre 60 et 99 ans « vous êtes du troisième âge » et dans un autre cas
autre que les âges précités, « vous êtes d’un autre âge ».

Algorithme selonque1
Entier: age
Debutalgo
Ecrire ('Entrez votre âge : ')
Lire (Age)
selonque age
0..17 : Ecrire ('Tu es encore mineur...')
18 : Ecrire('La majorité atteinte !');
18..59 : ecrire (‘Vous être maintenant adulte’)
60..99 : Ecrire ('Vous êtes du troisième âge !!!')
Defaut : { en option }
Ecrire('Vous êtes d''un autre âge...')
Finselonque
finalgo.

5.2. Les structures de répétition

La séquence et l'alternative ne sont pas en elles-mêmes suffisantes pour exprimer des algorithmes dont la
longueur peut varier selon les circonstances. Il est donc nécessaire d'introduire le moyen de répéter certaines
instructions d'un algorithme un nombre quelconque de fois. La structure qui permet cela est appelée structure
répétitive. Dans certains programmes, on connaît à l’entrée le nombre de boucles à effectuer et d’autres dont
on connaît la condition d’arrêt.
La plupart des langages de programmation proposent trois types de structure répétitive.

5.2.1. La boucle : le pour

KOFFI K Yves Professeur à l’INP-HB Page 13
 Cours d’algo
La boucle est une structure utilisée lorsque le nombre d’itération est connu.
Syntaxe:
Pour identificateur valeur initiale Jusqu’à valeur finale faire
action
fin
L’identificateur joue le rôle de compteur, il est donc de type simple énumérable ou ordonné

Exemple :
Ecrire l’algorithme permettant la saisie par l’utilisateur la somme de nombres N(20)premiers entiers
positifs.

Algorithme somme_premierentier
Entier : nombre, som , i déclaration de variables
Debutalgo affectation
som 0
ecrire (‘Calcul de la somme des N premiers entiers positifs ‘) syntaxe de l’instruction
ecrire (‘saisier le nombre positif ’ ) écriture et de lecture
lire (nombre)
pour i de 1 à nombre faire
debut syntaxe de l’instruction
som som + i pour
finpour
ecrire (‘ somme= ’ , som) affichage
finalgo

5.2.2. L’itérative : le tant que

L'itérative ou l’itération est une structure qui permet l'exécution d'une action ou d'une séquence d'actions tant
qu'une condition est vérifiée. Les structures TantQue sont employées dans les situations où l’on doit
procéder à un traitement systématique sur les éléments d’un ensemble dont on ne connaît pas d’avance la
quantité.

Si la condition est vraie, les instructions dans actions sont exécutées. Puis, on retourne tester une nouvelle
condition. Dans le cas contraire (condition bascule à faux), l'itération est terminée.
On dit alors que l'on sort de la boucle. La condition est toujours évaluée avant de faire le traitement (la
condition est d’abord testée). Donc, si la condition n'est jamais vraie, le traitement n'est jamais effectué.
Syntaxe :
TANT QUE condition
actions
FINTANT QUE

KOFFI K Yves Professeur à l’INP-HB Page 14

 Cours d’algo
Exemple :
Ecrire l’algorithme qui permet de saisir les notes d’un étudiant sachant que ces notes sont des entiers
positifs. Ensuite calculer la moyenne de cet étudiant.

Algorithme calcul _de_moyenne

Entier : note ,nbre, som , i déclaration de variables
Reel : moy
Debutalgo
som 0
ecrire (‘Saisir le nombre de note’)
lire (nbre)
i 1 initialisation de la variable i
tantque (i< = nbre) faire syntaxe de instruction tantque
debut
repeter
ecrire (‘saisir la note ’)
lire (note)
jusqu’à (note ente 0 et 20)
som som+ note
i i+1 incrémentation de la variable
fin
moy som / nbre
ecrire (‘la moyenne est ’, moy ) affichage
finalgo
Remarque :
Avec la boucle tant que il faut initialiser d'abord la variable de parcours i avant la boucle, puis l'augmenter
de 1 à chaque passage. Au dernier passage i correspondra à nbre.

5.2.3. La répétitive : répéter … jusqu’à

La répétitive est une variante de l’itérative. On l’utilise lorsqu’on veut que condition soit exécutée une
fois avant de rentrer dans une itérative. L’action précède le test, elle est d’ abord exécutée puis la
condition est testée.
Syntaxe
Repeter
action
jusqu’à ( condition)

Exemple:
Ecrire l’algorithme permettant la saisie par l’utilisateur d’une série de nombres entiers positifs en utilisant
la structure répéter. La saisie prend fin lorsque la somme des nombres devient supérieure ou égale à 100.

KOFFI K Yves Professeur à l’INP-HB Page 15

 Cours d’algo

algorithme somme
Entier : nombre, som déclaration de variables
Debutalgo affectation
som 0
repeter
debut
repeter
ecrire (‘saisier un nombre entier’) syntaxe de l’instruction
lire (nombre)
jusqu’à (nombre >= 0)
som som + nombre
jusqu’ à (som >=100)
fin
ecrire ‘ somme= ’ , som affichage
finalgo

6. Les procédures et les fonctions

Les sous-programmes sont utilisés pour améliorer la structuration d'un programme.
En algorithmique, il existe deux types de sous-programmes :
 Les procédures

 Les fonctions
Le corps du programme s’appelle alors la procédure principale, et ces groupes d’instructions auxquels on a
recours s’appellent des fonctions et des sous procédures. Le programme qui utilise un sous-programme est
appelé programme appelant.
Les écritures de procédures et de fonctions ont principalement deux avantages.
Elles permettent de rendre les algorithmes plus lisibles, et donc plus faciles à comprendre, à corriger, à
modifier. Le programme devient modulaire et il suffit de faire une seule modification au bon endroit, pour que
cette modification prenne effet dans la totalité de l’application.
Ces programmes ajoutent la notion de passage de paramètres.
On appelle paramètre formel ou paramètre réel, les données identifiées lors de la déclaration de la procédure
(fonction). Il est une variable locale particulière.
On appelle paramètre effectif ou argument, les données passées lors de l’activation (exécution) de la
procédure (fonction). Il peut varier d’un appel à l’autre. Ils doivent être le même nombre de paramètre, de
même type et rangés dans le même ordre que les paramètres formels.

6.1. les procédures

Une procédure est une suite d'instructions servant à réaliser une tâche précise en fonction d'un certain
nombre de paramètres. Les procédures sont des sous-programmes qui ne retournent aucun résultat.

KOFFI K Yves Professeur à l’INP-HB Page 16

 Cours d’algo

6.1.1. Procédures sans paramètres

On peut créer des procédures sans paramètres. Il s'agit simplement de donner un nom à un groupe
d'instructions.
Syntaxe :
Algorithme nom_de l’algorithme; { programme principal }
Type : variable
Procedure nom_de_procedure; {définition de la procédure }
debut
...
fin;
debutalgo
...
nom_de_procedure; {appel de la procédure}
...
finalgo.

Écrire un programme qui permet d’échanger deux x et y à l’aide d’une procédure qui fait l’échange de ces
nombres.

Exemple:
algorithme echanger;
entier : x, y, tampon
procedure Echange { Déclaration de la procédure Echange }
debut {début du corps de la procédure }
tampon x;
x y;
y tampon;
fin
debutalgo {Programme principal }
x 3;
y 4;
ecrire (‘Les deux nombres sont :’, x, ' ', y);
Echange; {1er appel de la procedure }
ecrire (‘Les deux nombres sont :’, x, ' ', y);
Echange; {2eme appel de la procedure }
ecrire (‘Les deux nombres sont :’ , x, ' ', y);
finalgo.

6.1.2. Procédures avec paramètres

On peut aussi créer des procédures paramétrées c'est-à-dire qu’elles reçoivent des variables comme
paramètres.
Ces paramètres sont de deux types.
Les paramètres de type VALEUR : ils contiennent une valeur qui sera utilisée dans la procédure.

KOFFI K Yves Professeur à l’INP-HB Page 17

 Cours d’algo
Les paramètres de type ADRESSE ou REFERENCE: ils représentent une variable du programme appelant qui
pourra être lue et modifiée si nécessaire

6.1.2.1.. Passage des paramètres par valeur

Passage par valeur : à l'appel, le paramètre est une variable ou une expression.
C'est la valeur qui est transmise, elle sert à initialiser la variable correspondante dans la procédure.
Syntaxe :
algorithme nom_de_l’algorithme
Procedure nom_de_procedure ( noms_de_variables : types )
debut
...
fin
debutalgo
nom_de_procedure ( noms_d_autres_variables_ou_valeurs )
finalgo.

Exemple :
algorithme echanger;
reel: a, b
Procedure echange ( x , y : réel)
: reel: tampon
debut
tampon x
x y
y tampon
fin
debutalgo {Programme principal }
a 3
b 4
echange(4,8) {1er appel de la procédure}
ecrire (‘Les deux nombres sont :’, a, ' ',b)
echange(a, b) {2eme appel de la procédure}
ecrire (‘Les deux nombres sont :’ , a, ' ',b)
finalgo

6.1.2.2. Passage des paramètres par adresse ou par référence

Lors de la déclaration de paramètre au sein de la procédure paramétrée, le mot-clé Var (placée devant
l'identificateur de la variable) permet de déclarer des paramètres formels dont la valeur à l'intérieur de la
procédure ira remplacer la valeur dans le programme principal, de la variable passée en paramètre.

KOFFI K Yves Professeur à l’INP-HB Page 18

 Cours d’algo
Syntaxe :
 Paramètre de même type
algorithme nom_de_algorithme;
Procedure nom_de_procedure (Var variable1, variable2 : type1 ; variable3 : type1);
debut
...
fin
debutalgo
nom_de_procedure ( noms_d_autres_variables );
finalgo.

 Paramètre de types différents

Syntaxe :
algorithme nom_de_programme;
procedure nom_de_procedure (Var variable1 : type1 ; Var variable2 : type2);
debut
...
fin
debutalgo
nom_de_procedure ( noms_d_autres_variables );
finalgo.

Exemple:
algorithme echanger
reel; a, b
Procedure echange (var x, y : reel)
reel; tampon
debut
tampon x
x y
y tampon
fin
debutalgo {Programme principal }
ecrire('donner deux réels');
lire(a,b)
ecrire(‘Les deux reels sont’, a, b) {affichage avant échange}
echange(a,b
ecrire(‘Les deux reels échangés sont’, a, b) {affichageaprèst échange }
finalgo.

6.2. Les fonctions

Les fonctions sont des sous-programmes retournant un seul résultat.

Syntaxe :
algorithme nom_procedure
type fonction nom_fonction { déclaration de variables locales }
debut
...
nom_fonction une_valeur; { valeur de retour de la fonction }
fin

KOFFI K Yves Professeur à l’INP-HB Page 19

 Cours d’algo
debutalgo
….
Variable nom_fonction
finalgo

6.2.1. Modes de passage des paramètres

Les paramètres sont de deux types. On distingue les paramètres de type valeur et les paramètres de type variable.
6.2.2. Passage par valeur :
On recopie la valeur du paramètre effectif dans le paramètre formel c’est à dire la procédure appelée ne
reçoit que la copie des valeurs des paramètres effectifs qui sont transmis aux paramètres formels
correspondants.
Exemple:
Syntaxe:
algorithme nom_de_l’algorithme ;
Type fonction nom_fonction (variable : type )
{ déclaration de variables locales }
debut
...
nom_fonction une_valeur; { valeur de retour de la fonction }
fin
debutalgo
….
Variable nom_fonction
Finalgo

Exemple :
algorithme classer ;
reel: a, b, c
reel fonction max (x, y : reel) { définition de la fonction }
debut
si x >= y alors
max x { valeur de retour }
else
max =y
fin
debutalgo
ecrire('Entrez deux valeurs : ');
lire(a,b);
c max(a,b); { appel de la fonction }
ecrire('Le plus grand est ',c)
finalgo

6.2.3. Passage par variable ou adresse (référence):

On recopie l’adresse du paramètre effectif dans le paramètre formel. Lorsque nous utilisons le passage d’une
valeur par référence, nous indiquons non sa valeur mais la référence en mémoire de celle-ci.

KOFFI K Yves Professeur à l’INP-HB Page 20

 Cours d’algo
Ainsi, la procédure ou la fonction manipule donc le même espace de mémoire. Ce mode de passage permet de
changer la valeur du paramètre.
La déclaration des paramètres formels est précédée du mot var c'est-à-dire que les paramètres de type var
représentent une variable du programme appelant qui pourra être lue et modifiée si nécessaire. Il s’agit du
passage par référence.
Exemple :
algorithme classer ;
reel: a, b, c
reel fonction max (var x, y : reel) { définition de la fonction }
debut
si x >= y alors
max x { valeur de retour }
else
max =y
fin
debutalgo
ecrire('Entrez deux valeurs : ');
lire(a,b);
c max(a,b); { appel de la fonction }
ecrire('Le plus grand est ',c)
finalgo

6.4. La récursivité et les fonctions récursives

La récursivité met en œuvre une action qui s’appelle c'est-à-dire elle est partiellement définie à partir
d’elle-même. Il s’agit d’une référence à une copie de la version précédente. La terminaison est assurée par le
fait que cette suite de versions doit converger vers un état connu.
Exemple1 :
procedure factorielle (k : entier) : entier
fact : entier
debutalgo
si k= 0 alors fact 1
sinon fact factorielle(k-1)* k
finsi
finalgo

Exemple:2
fonction factorielle (k : entier) : entier
fact : entier
debutalgo
si k= 0 alors fact 1
sinon fact factorielle(k-1)* k
finsi
retourner fact
finalgo

KOFFI K Yves Professeur à l’INP-HB Page 21

 Cours d’algo
7. Les tableaux
Problème : Si nous voulons écrire un programme qui lit 5 valeurs avant d’en afficher les différents carrés.
Ce programme doit absolument conserver les 5 valeurs fournies avant de commencer à écrire les résultats.
Dans ces conditions, il est impossible d’utiliser une seule variable à laquelle on affecterait successivement
chacune des différentes valeurs entrées.

Alors certains problèmes en algorithme nécessitent l’utilisation de variables structurées possédant

simultanément plusieurs valeurs. La notion de structure de données permet à un langage évolué de manipuler
des variables plus élaborées permettant de donner un nom, non plus à une seule valeur, mais à un ensemble de
valeurs. La structure de données la plus répandue est le tableau.
Il existe deux genres de tableaux selon l’allocation mémoire: les tableaux statiques, dont la taille est connue
à la compilation, et les tableaux dynamiques, dont la taille est connue à l'exécution. Nous ne nous
intéresserons pour l'instant qu'aux tableaux statiques.

7.1. le tableau à une dimension

Le tableau à une dimension est une liste ordonnée de valeurs de même type (numériques, logiques,
caractères,…), désignée par un nom unique.
Chaque valeur de la liste étant repérée par un ‘numéro d’ordre’ qu’on nomme indice du tableau c'est-à-dire
on accède aux différentes composantes par un index.

7.1.1. Déclaration du tableau

Lors de la déclaration, on indique le nombre total d'éléments du tableau (que ceux-ci soient affectés ou
non). Ce nombre sera le nombre d'éléments maximum que l'on pourra mettre dans le tableau.
Syntaxe1 :
NomType: nomTableau [intervalle d’indice]

Exemple :
Réel : noteetudiant [0..9] ; /* déclaration du nom du tableau permettant le stockage de 10 nombres réels */

noteetudiant /* nom de la variable tableau*/

[0..9] /* intervalle d'indices indiquant indice minimum et indice maximum (obligatoire )* /
Réel /*type de chaque élément*/

Ou
Syntaxe2
NomTableau : Tableau [indice] de type

Exemple :
Tab : Tableau [0..n] de caractères ; /*déclaration des tableaux*/
noteetudiant : Tableau [1..10] de réels ;

Remarque :
L'indice maximum indique le nombre maximum d'éléments. Dépasser ce nombre provoque une erreur. Tous
les éléments ont toujours le même type.
KOFFI K Yves Professeur à l’INP-HB Page 22
 Cours d’algo

Le premier élément d’un tableau est souvent numéroté 0 en informatique.

noteetudian[0] désigne la première valeur du tableau noteetudiant
noteetudiant[1] désigne la 2ieme valeur du tableau noteetudiant
noteetudiant[i] désigne la ieme valeur du tableau noteetudiant
noteetudiant[9] désigne la 10 ieme valeur du tableau noteetudiant ( la dernière valeur)

En langage C, l’indice commence toujours par 0 mais dans d’autres langages tel que Pascal on peut
commencer par 1.

7.1.2. Saisie des éléments du tableau

Pour remplir ou saisir tous les 10 éléments du tableau appelé note, on utilisera alors une boucle 'pour'.
Syntaxe
pour i de 0 à 9 faire
debut
ecrire(' note ',i)
lire(note[i])
finPour

7.1.3. Parcours d'un tableau (affichage des éléments du tableau)

Pour lire tous les 10 éléments du tableau note, on aura :
Syntaxe
pour i de 0 à 9 faire
debut
ecrire('les 10 notes saisies sont : ')
ecrire(note[i])
finPour

Exemple1 :
Ecrire un programme qui lit une liste de 6 notes à l’aide d’n tableau et affiche les notes saisies.
algorithme tableau
Entier : i ; {déclarations des variables}
note : tableau [1..6] de réel {déclaration du tableau}
debutalgo
repeter
pour i de 1 à 6 faire
debut
ecrire('saisir les 6 notes ')
lire(note[i])
finPour
jusqu’à (nbre compris entre 0 et 20)
pour i de 1 à 6 faire
debut
ecrire('les 6 notes saisies sont : ')
ecrire(note[i])
finPour
finalgo

KOFFI K Yves Professeur à l’INP-HB Page 23

 Cours d’algo

exemple2 :
Ecrire un programme qui lit une suite de N notes (10 au maximum), calcule la moyenne puis affiche les notes
et la moyenne à l’aide d’n tableau.

algorithme moyenne
Entier : nbre, i, somme {déclaration des variables}
Reel :, moy,
note : tableau [1..10] de réel {déclaration du tableau}
debutalgo
repeter
ecrire ('Saisir le nombre de notes (10 maxi)?')
lire(nbre)
jusqu’à (nbre compris entre 0 et 20)
{saisie des notes et calcul de la somme}
somme 0
pour i de 1 à nbre faire
debut
ecrire(i,'è note ')
lire(note[i])
{ calcul de la somme}
somme somme + note[i]
fin
{ affichage des6 notes}
pour i de 1 à nbre faire
debut
ecrire('les 6 notes saisies ')
ecrire(note[i])
finpour
{calcul et affichage de la moyenne}
moy somme / nbre
ecrire('Moyenne est: ',moy)
finalgo.

7.2. tri d’un tableau à une dimension

Les opérations de tri représentent une part importante des traitements informatiques. Trier c’est classer un
ensemble d’éléments selon une relation d’ordre. L’utilisation d’un tableau permet de résoudre un problème
assez fréquent, à savoir ordonner par exemple de manière croissante une suite de valeur. On place les valeurs
dans un tableau puis on fait le tri des valeurs de ce tableau. Plusieurs techniques existent à cet effet : tri par
sélection, tri bulle, tri par insertion, ….

7.2.1. Tri par sélection

Nous écrirons l’algorithme du tri par sélection (extraction) qui se définit par la donnée de n nombre
d’éléments du tableau.
Il s’agit de :
 Rechercher le plus petit des n éléments du tableau ;
KOFFI K Yves Professeur à l’INP-HB Page 24
 Cours d’algo
 Échanger cet élément avec le premier du tableau ;
 Le plus petit élément se trouve alors en première position. on peut alors appliquer les 2 opérations
précédentes aux n-1 éléments restants, puis aux n-2 …et cela jusqu’à ce qui ne reste plus qu’un seul
élément (le dernier) qui est alors le plus grand.

Visualisation du traitement sur 4 éléments :

8 1 7 5
1 8 7 5
1 5 7 8
1 5 7 8

Exemple :
Ecrire un programme qui affecte des valeurs entières saisies au clavier à un tableau de 8 entiers, trie le tableau
par ordre croissant et l'affiche par la méthode de tri de sélection.

algorithme tri_selection
Entier : i ,j; déclaration de variables
val : tableau[1..8] d’entiers; /* 8 valeur à trier */
Entier : tampon ; /* pour l’échange de 2 valeurs */
Debutalgo
ecrire ‘Donner 8 valeurs entières ‘
pour i de 1 à 8 faire /* lecture des valeurs*/
debut
lire val[i ]
finpour
pour i de 1 à 7 faire /* passe toutes les valeurs sauf le dernier */
debut
pour j de i +1 à 8 faire /*comparaison de val[i ] avec tous ses suivants*/
debut
si (val[i ] > val[j] ) alors
debut
tampon val[i ]
val[i ] val[j ]
val[j] tampon
Finsi
finpour
finpour
ecrire ‘Voici nos valeurs triées par ordre décroissent ‘
pour i de 1 à 8 faire
debut
ecrire (val[i ] ) /* affichage*/
finpour

finalgo

KOFFI K Yves Professeur à l’INP-HB Page 25

 Cours d’algo
Remarque :
Chaque échange met un élément en position définitive, l'autre par contre est mal placé. Mais aucun échange
n'est inutile. Un élément qui a été bien placé ne sera plus testé par la suite. Le nombre de boucles internes est
environ N(N-1)/2, ce qui est meilleur que le tri bulle, mais toujours de l'ordre de N2. Par contre le nombre de
déplacements d'éléments est au maximum de 2(N-1), la moitié étant des déplacements nécessaires, ce qui est
faible pour un fichier en désordre total, mais n'est pas optimal pour les fichiers dont la première partie est
déjà classée.

7.2.2. Tri bulle

Le principe est de comparer chaque élément du tableau à celui qui le suit c'est-à-dire on fait l’échange de
deux éléments successifs si ils ne sont pas ordonnés et répéter tant qu'il y a des échanges.
Dans le cas d’un rangement dans l’ordre croissant, si l’élément qui le suit est plus petit que lui on les permute.
On fera ce travail aussi longtemps que le tableau n’est pas entièrement trié.

Visualisation du traitement sur 5 éléments :

5 18 14 4 26
5 14 18 4 26
5 14 4 18 26
5 4 14 18 26
4 5 14 18 26
4 5 14 18 26

Comme nous n’avons procédé à aucun échange, nous avons terminé.

Ecriture de l’algorithme :
On suppose qu’on a un tableau de n +1éléments (n>=1)

Algorithme tri_bulle
Entier : i, temp /*indice de parcours*/
Tab : tableau[1..8] d’entiers
Booleen : yatrie
Debutalgo
yatrie vrai
Tant Que yatrie =vrai
yatrie  faux
Pour i0 à n-1 faire
Si tab[i] >tab[i+1] alors
temp tab[i]
tab[i] tab[i+1]
tab[i+1] temp
Yatrie vrai
finsi
finpour
fintantque
finalgo

KOFFI K Yves Professeur à l’INP-HB Page 26

 Cours d’algo
Remarque :
Pour un tableau à n éléments.
Ce tri va nécessiter un grand nombre de déplacements d'éléments, il est donc inutilisable dans les cas où ces
déplacements sont coûteux en temps. Il va nécessiter N-1 boucles principales dans le cas où le dernier
élément doit être placé en premier. Le nombre de boucles internes maximal est donc de l'ordre de (N-1)2. Il
peut par contre être intéressant quand le tableau initial est déjà pré-trié, les éléments n'étant pas disposés
trop loin de leur position finale.

7.3. le tableau à deux dimensions

Un tableau à 2 dimensions est une structure contenant des éléments de même type dans laquelle chaque
élément est repéré par 2 indices. Le tableau à 2 dimensions correspond donc à la notion mathématique de
matrice. Ainsi on peut représenter les notes des 4 étudiants dans 3 matières de la manière suivante :
L’indice i correspond aux étudiants de (1 à 4) et l’indice j correspond aux matières de (1 à 3)
SE logiciel architecture
koffi 12 15 11
soro 10 8 11
digbeu 9 13 8
coulibaly 14 7 17

(ligne3 ; colonne1) (ligne2 ; colonne3)

Chaque note est repérée par 2 indices qui en précisent la position :

(ligne3 ; colonne1) = note [3][1]
(ligne2 ; colonne3) = note [2][3]

Exemple de tableau à plusieurs dimensions :

Dimension 1 = vecteur ; dimension 2 = feuille Excel ; dimension 3 =classeur Excel.

7.3.1. Déclaration du tableau

Syntaxe
Type matrice = tableau [1..4,1..3] d’entiers
ou
nom_ du_tableau [premier indice ,second indice]

Exemple :
matrice1[0..10, 0..10] de bytes
matrice1[2..5, 1..10] d’entiers

7.3.2. Affichage des éléments du tableau

exemple
Écrire un algorithme qui permet se saisir par l’utilisateur les notes du tableau ci-dessus puis de les afficher.

KOFFI K Yves Professeur à l’INP-HB Page 27

 Cours d’algo

Algorithme tableau_des_notes
Entier : i ,j ;
note = tableau [1..4,1..3] d’entiers /* déclaration de variable* /
Debutalgo
pour i de 1 à 4 faire
debut
pour j de 1 à 3 faire
debut
ecrire ("Saisir la note " , i, " ; ", j )
lire note[ i,j] /* lecture */
finpour
finpour
pour i de 1 à 4 faire
debut
pour j de 1 à 3 faire
debut
ecrire ‘Saisir la note ‘ , note[i, j] /* écriture*/
finpour
finour
finalgo

KOFFI K Yves Professeur à l’INP-HB Page 28

 Cours d’algo

8. Enregistrements
Une structure d’enregistrement est une structure de données ou une collection d’objet de types différents.
Les objets sont appelés les champs de la structure. L’intérêt des structures est de regrouper des variables qui
peuvent être de types différents sous un seul nom pour les manipuler facilement.
8.1. Déclarations
On déclare une catégorie de variable : un type d’enregistrements ou structure d’enregistrements puis on
utilise ce type pour déclarer les variables de la structure.
Syntaxe
identifiant_du_type = enregistrement
type_premier_champ : identifiant_premier_champ
type_deuxième_champ : identifiant_deuxième_champ
........
Finenregistrement

exemple:
Type Produit = enregistrement
Entier : Numero
Entier : quantite / * déclaration de type d’enregistrement contenant des
Reel : prix champs de différents types */
Finenregistrement

Produit : article /* déclaration de la variable enregistrement*/

Type Personne = enregistrement

Chaine 10 : Nom
Chaine 20 : Prenoms /* déclaration de type d’enregistrement contenant des
Entier : Age champs de différents types */
Chaine 20 : Fonction
Finenregistrement
8.2. Accès aux champs
Personne : etudiant, employé /* déclaration de la variable enregistrement*/

Une fois le type d’enregistrement déclaré, on peut déclarer les variables de ce type.
Lire ou écrire un enregistrement consiste à lire ou écrire chaque variable de champ qui le compose.
L'accès aux champs se fait avec un point.
Pour accéder à un champ de la variable enregistrement, nous utiliserons l'expression ci-dessous.
Syntaxe :
KOFFI K Yves Professeur à l’INP-HB Page 29
 Cours d’algo
identifiant_variable.identifiant_champ

Exemple:
Ecrire ‘ Saisir le nom de la personne’
Lire etudiant.Nom
Ecrire ‘ Saisir le prenoms de la personne’
Lire etudiant.Prenoms
Ecrire ‘ Saisir le l’age de la personne’
Lire etudiant.Age
Ecrire ‘ Saisir la fonction de la personne’
Lire etudiant.Fonction

Exemple :
Nous souhaitons implémenter l’enregistrement de type rationnel. Pour cela, nous allons utiliser un type
enregistrement composé de deux champs de type entier : numérateur et dénominateur.

Algorithme nombre_rationnel
Type rationnel = enregistrement
entier : numerateur /* déclaration de type d’enregistrement et les champs*/
entier : denominateur
finenregistrement
entier : a, b
rationnel : nouveauRationnel /* déclaration de la variable enregistrement*/
Debutalgo
si b=0 alors
debut
ecrire ’le dénominateur ne peut être nul’
finsi
sinon
debut
nouveauRationnel.numerateur ← a
nouveauRationnel.denominateur ← b
finsinon
ecrire’ Le nombre rationnel saisi est :’, a / b /* affichage */
finalgo

KOFFI K Yves Professeur à l’INP-HB Page 30