CHAPITRE I.

ALGORITHMES ET PROGRAMMATION

1.1. Algorithmes

1.1.1 Concepts et définition

Certains voient, à tort, dans l’ordinateur une machine pensante et intelligente,

capable de résoudre bien des problèmes. En fait, celui-ci ne serait capable de
rien si quelqu’un (le programmeur) ne lui avait fourni la liste des actions à
exécuter.

La description de cette liste doit être faite de manière non ambigüe car il ne
faut pas s’attendre à la moindre interprétation des ordres finis. Ils seront
exécutés de façon purement mécanique.

De plus, les opérations élémentaires que peut exécuter un ordinateur sont en

nombre restreint et doivent lui être communiquées de manière précise dans un
langage qu’il comprendra. Le problème principal de l’utilisateur est donc de lui
décrire la suite des actions élémentaires permettant d’obtenir à partir des
données fournies, les résultats escomptés. Cette description doit être précise,
envisager le moindre détail et prévoir les diverses possibilités de données.

Cette marche à suivre porte le nom d’algorithme dont l’Encyclopaedia

Universalis donne la définition suivante : « 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 ».

Le mot algorithme provient du nom d’un célèbre mathématicien arabe de la

première moitié du siècle : Muhammad ibn Musa al Khawarizmi.
Le rôle de l’algorithme est fondamental. En effet, sans algorithme, il n’y aurait
pas de programme (qui n’est jamais que sa traduction dans un langage
compréhensible par l’ordinateur).

De plus, les algorithmes sont fondamentaux en un autre sens ; ils sont

indépendants à la fois des ordinateurs qui les exécutent et des langages dans
lesquels ils sont énoncés et traduits.

La rédaction d’un algorithme est un exercice de réflexion qui se fait

généralement sur papier.

1
 1.1.2 Représentation d’un algorithme

La représentation d’un algorithme se réalise principalement de deux

manières :
 L’organigramme (ou ordinogramme) : c’est une représentation
graphique d’un algorithme avec des symboles (carrés, losanges, etc.).
De fait, cette représentation est quasiment abandonnée aujourd’hui ;
 Le pseudo-code : c’est une représentation textuelle d’un algorithme
avec une série de conventions ressemblant à un langage de
programmation. Cette représentation est la plus répandue.

1.1.3 Les propriétés d’un algorithme

 Un algorithme doit :
 Avoir un nombre fini d’étapes ;
 Avoir un nombre fini d’opérations par étape ;
 Se terminer après un nombre fini d’opération ;
 Fournir un résultat.

 Chaque opération doit être :

 Définie rigoureusement et sans ambiguïté ;
 Effective, c’est-à-dire réalisable par une machine.

1.1.4 Les qualités d’un algorithme

Un algorithme doit être :

 Lisible : compréhensible même par un non informaticien ;

 De haut niveau : pouvoir être traduit dans n’importe quel langage de
programmation ;
 Précis : chaque élément de l’algorithme ne doit pas prêter à confusion ;
 Concis : ne doit pas être long, si c’est le cas, il faut décomposer le
problème en sous-problèmes ;
 Structuré : être composé de différentes parties identifiables.

1.2. Programmation

1.2.1 Définitions

 Un programme informatique est une suite logique d’instructions

élémentaires écrites dans un langage de programmation, destinées

2
 à être exécutées une par une par un ordinateur suivant l’ordre de
leur rédaction afin d’atteindre un résultat escompté ;
 Un programme est l’implémentation d’un algorithme dans un
langage de programmation.

1.2.2 Etapes à suivre dans la programmation

 Analyse du problème à automatiser ;

 Construction d’algorithme ;
 Codification de l’algorithme dans un langage de programmation
(Implémentation) ;
 Compilation du programme ;
 Correction des erreurs révélées par la compilation (débogage) et
compilation jusqu’à ce qu’il n’y ait plus d’erreurs ;
 Soumission définitive du programme à l’ordinateur pour
exécution.

L'analyse d'un problème posé consiste à définir les différentes étapes de sa

résolution. C'est la partie essentielle dans le processus de programmation.
Elle permet de définir le contenu d'un programme en termes de données et
d’actions. Une démarche descendante permettrait de décomposer le problème
initial en « sous problèmes », plus simples à résoudre. A chacun de ces
derniers sera associée une spécification formelle ayant des conditions d'entrée
et le(s) résultat(s) que l'on souhaiterait obtenir. L'ensemble de ces
spécifications représente l’algorithme.

3
La phase suivante consiste à traduire l’algorithme dans un langage de
programmation donné. Ce travail, quoiqu’il semble facile, exige le respect strict
de la syntaxe du langage.
Lors de l’étape d’exécution, soit des erreurs syntaxiques sont signalées, ce qui
entraîne des corrections en général simples à effectuer, soit des erreurs
sémantiques plus difficiles à déceler. Dans le cas d’erreur syntaxique, les
retours vers le programme peuvent être fréquents. Dans le cas d’erreur
sémantique, le programme produit des résultats qui ne correspondent pas à
ceux escomptés : les retours vers l’analyse (algorithme) sont alors inévitables.

1.2.3 Mécanisme d’exécution d’un programme par un ordinateur

Les programmes sont exécutés au niveau de l’unité centrale de l’ordinateur.

Celle-ci comprend deux éléments importants à savoir le microprocesseur et la
mémoire centrale.
Le microprocesseur est l’organe important qui exécute les programmes soumis
à l’ordinateur. Il est logiquement composé de deux unités :

 L’unité arithmétique et logique ;

 L’unité de commande et de contrôle.
L’unité arithmétique et logique est la partie du microprocesseur qui exécute les
instructions du programme sous la supervision de l’unité de commande et de
contrôle.
La mémoire centrale, précisément la RAM (Random Access Memory) est
l’endroit où le microprocesseur vient :

 Chercher l’instruction du programme qui doit être exécutée

ainsi que les données concernées par cette exécution (les
opérandes) ;
 Stocker le résultat de l’exécution d’une instruction.

L’ordinateur n’exécute qu’une seule instruction du programme à la fois et que

pour se rappeler d’une donnée ou d’un résultat intermédiaire, celui-ci doit avoir
été stocké en mémoire centrale (RAM).

1.2.4 Structure générale d’un algorithme (ou d’un programme)

La structure générale d’un algorithme ou d’un programme informatique se

présente de la manière suivante :

4
Ces instructions peuvent être : les tests (instructions alternatives), les boucles
(instructions itératives), les structures de données (tableau, liste, etc.). Dans la
suite, nous aborderons plus en détails toutes ces instructions.

1.2.5 Notion de zone mémoire

Lorsqu’une donnée comme 291 ou "ANGLAIS" est stockée en mémoire

centrale, elle peut prendre plusieurs octets et ceux-ci peuvent ne pas être
contigus vu le caractère aléatoire de l’accès à la RAM.

Une zone mémoire est l’ensemble d’octets utilisés par le système

d’exploitation pour stocker une donnée comme 291 ou "ANGLAIS" pendant
l’exécution d’un programme. Les numéros de différents octets d’une zone
mémoire constituent son adresse physique et celle-ci n’est connue que du
système d’exploitation. Pour retrouver une donnée stockée dans la RAM, le
programmeur doit donner un nom significatif à la zone mémoire dans laquelle
elle sera stockée. Ce nom est l’identificateur de la donnée ; c’est l’adresse
logique de la donnée.

Le système d’exploitation fait alors une association entre l’adresse physique et

l’adresse logique de chaque donnée stockée dans la RAM.
A la fin de l’exécution d’un programme, le système d’exploitation libère la
mémoire centrale, c’est-à-dire, les instructions, les données ainsi que les
résultats et les adresses logiques sont effacées pour laisser l’espace à
d’autres programmes.

1.2.6 Types de données

Une donnée peut être considérée comme une boîte, portant une étiquette
(nom), d'une certaine forme (type) et qui contient une information (valeur).
Une donnée peut être :
 Une constante si sa valeur ne change jamais durant
l’exécution du programme ;
 Une variable si sa valeur est susceptible de changer durant
l’exécution du programme.

Nous pouvons classer les données selon 3 grandes classes en fonction de la

nature des valeurs qu'elles peuvent prendre :
1. Les données numériques ;
2. Les données alphanumériques ;
3. Les données logiques.
Mais il peut y avoir aussi les types de données définies par l’utilisateur ; auquel
cas on parlera de types utilisateurs. Venons-y en détails.

5
 1. Les types numériques

Le type numérique caractérise les valeurs entières ou réelles (et parfois

complexes). Ainsi, nous avons :

 Le type entier : nombres entiers compris entre à 231-1. Toute

donnée appartenant à ce type occupe 4 octets en mémoire centrale.
 Le type entier long : nombres entiers compris entre -263 et 263-1. Toute
donnée appartenant à ce type occupe 8 octets en mémoire centrale.
 Le type octet (ou byte) : les nombres entiers compris entre -27 et 27-1.
Toute donnée appartenant à ce type de données occupe un octet en
mémoire centrale.
 Le type entier court : nombres entiers compris entre -215 et 215-1.
Toute donnée appartenant à ce type de données occupe 2 octets en
mémoire centrale.
 Le type réel simple précision : nombres réels compris entre
-3.40 10-38 et 3.40 1038. Les données de ce type occupent 4 octets en
mémoire centrale.
 Le type réel double : nombres réels compris entre -1.79 10-308 et
1.79 10308. Les données de ce type occupent 8 octets en mémoire
centrale.

A noter que certains langages autorisent d’autres types numériques,

notamment :

 Le type monétaire (avec strictement deux chiffres après la virgule)

 Le type date (jour/mois/année).

2. Les types alphanumériques

Le type alphanumérique caractérise les valeurs caractère (notées Car) ou

chaîne de caractères (notées Chaîne) :

6
 1) Le type caractère

Sa valeur est un caractère quelconque. Un caractère peut appartenir au

domaine des chiffres de ‘0’ à ‘9’, des lettres de ‘A’ à ‘Z’ (majuscules ou
minuscules) et des caractères spéciaux (‘+’ ‘-‘ ’,‘ ’;’ ‘.’ ‘(‘ ‘{‘ ‘[‘ ‘]’ ‘}’ ‘)’ ‘$’ ‘%’...).
Un caractère sera toujours noté entre des apostrophes. Le caractère blanc
(espace) s’écrit ‘ ‘, le caractère apostrophe ‘’’.
Exemple: 'A', 'B', 'C', '5', '8', '@', '♠', etc. Toute donnée appartenant à ce
type occupe un octet si le codage est en ASCII ou 2 octets si le codage
est en Unicode.
Les opérations qu’on définit sur les données de type caractère sont :
 égal (=)
 différent (<> ou !=)
 supérieur ou égal (>=)
 supérieur (>)
 inférieur ou égal (<=)
 inférieur (<)
A noter que l’ordre de supériorité des caractères se présente comme suit :
‘ ‘ < ‘0’ < ‘1’ < ... < ‘9’ < ‘A’ < ‘B’ < ... < ‘Z’ < ‘a’ < ‘b’ < ... < ‘z’
Les minuscules et les majuscules étant considérées comme des caractères
différents.
Cet ordre est déterminé par la codification ASCII.

2) Le type chaine de caractères

Sa valeur est une suite finie de caractères quelconques. Ce type n'est pas
toujours prédéfini et doit faire l'objet d'un « paramétrage », en fonction de sa
longueur (le nombre de caractères).

Une variable chaîne peut être vide, si elle est de longueur nulle, et sera notée :
' '. Si cette dernière est égale à 1, la variable est considérée aussi comme Car.

Exemples :

'BONSOIR' 'LA VIE EST BELLE '.

Les opérations définies sur les variables de type Chaîne sont les mêmes que
celles définies sur des variables de type Car.

ChaîneA < ChaîneB : si le mot contenu dans ChaîneA est 'inférieur' à celui de
ChaîneB dans le sens du dictionnaire; (inférieur : avant ; supérieur : après).

Exemple :
'BAL' < 'BALLES' < 'BALLON' < 'BAR' < 'Bar' < 'bar'

7
De plus, il existe une autre opération définie sur les variables chaîne, la
concaténation (|| ou +). Elle crée une nouvelle variable chaîne en juxtaposant
deux ou plusieurs mots.

Exemple :
„TOURNE'||'VIS' = 'TOURNEVIS'

3. Le type logique

Une valeur logique (ou booléenne) est l'une des deux valeurs 'vrai' ou 'faux'.
Elle intervient dans l'évaluation d'une condition.
Les opérations définies sur les variables de type logique sont la négation,
l'intersection et l'union.

- La négation (notée : ￢ , non)

Soit A une variable booléenne :

- L'intersection (notée : , et, .)

Soient A et B : deux variables booléennes :

- L‟union (notée : , ou, +)

Soient A et B : deux variables booléennes :

Les valeurs, dans ce type, occupent 1 octet en mémoire centrale, mais seul le
premier bit de l’octet compte. La valeur VRAI équivaut à la suite 11111111 et

8
la valeur FAUX à 00000000. En effet 00000000 est le complément à 2 de
11111111.

2. Le type utilisateur

Supposer qu’on doit écrire un programme pour un distributeur automatique de

jus de fruits. Remarquer que l’ensemble des fruits n’est pas un type prédéfini.
Il est demandé de chercher une solution.
Deux possibilités se présentent :

1ère possibilité :

Désigner pour chaque fruit une valeur numérique ou caractère.

Exemple : orange=1, fraise=2, etc. ou bien orange=’’o’’, fraise=’’f’’, etc.
Problème : il faut se rappeler de ce codage par exemple par l’ajout de
commentaires ; ce qui rend le programme difficile à suivre.

2ème possibilité :

Le programmeur a la possibilité de définir lui-même et suivant son choix de

nouveaux types. Donc on peut définir un type Fruits qui contiendra des noms
de fruits. Il s’agit d’un nouveau type dit type utilisateur.

Déclaration
Type Nom_type(val1, val2,…, valn)
Var Nom_variable : Nom_type;

Exercice
Déclarer les types suivants :
 Un type intitulé mention qui n’acceptera que les mentions attribuées à
une moyenne d’un étudiant (satisfaction, distinction, grande distinction,
la plus grande distinction).
 Un type saison comportant les quatre saisons (Automne, Hiver,
Printemps, Eté).

2.2.7 Notion de variable et constante

Une variable est une zone mémoire réservée pour stocker une donnée
susceptible de changer (varier) pendant l’exécution du programme.
Une constante est une zone mémoire dans laquelle on a stocké une donnée
qui ne peut pas changer pendant l’exécution du programme.

9
 2.2.7.1 Déclaration d’une variable

La déclaration d’une variable est une opération qui consiste à faire une
réservation de la zone mémoire dans laquelle on va stocker une donnée ou un
résultat. La déclaration d’une variable se fait en fournissant le type de donnée
ainsi que l’identificateur de la zone mémoire et éventuellement la valeur initiale
à y stocker.

 Syntaxes

Déclaration d’une seule variable :

Var identificateur : type

Déclaration d’une variable avec initialisation (en lui affectant une valeur initiale)
:
Var identificateur = valeur : type

Déclaration de plusieurs variables de même type :

Var identificateur1, identificateur2, … : type
Déclaration de plusieurs variables de même type avec initialisation :
Var identificateur 1 = valeur, identificateur 2 = valeur,…, type

Déclaration des variables de types différents

Var identificateur 1 = valeur : type identificateur 2 = valeur : type

Exemple 1.
Déclarer les variables pour un programme qui calcule l’intérêt simple d’un
capital placé à un taux donné pendant un certain nombre de jours donné
sachant que l’intérêt simple est calculé par la formule :
Intérêt simple = capital * taux * nombre de jours / 36000

Analyse du problème

Les données nécessaires à la résolution de ce problème sont : le capital, le

taux d’intérêt et le nombre de jours. Le microprocesseur ira chercher ces
données dans la mémoire centrale. D’où, il faut déclarer des zones mémoires
pour chacune de ces données. On donnera à ces zones mémoires les mêmes
identificateurs (capital, taux, nombre_de_Jours).
Après avoir calculé l’intérêt simple, le microprocesseur ira le stocker dans la
mémoire centrale. Il faut donc déclarer une zone mémoire pour l’intérêt simple.
Son identificateur peut être tout simplement interet.
Le capital, le taux d’intérêt et l’intérêt simple sont des valeurs numériques
comprenant une partie décimale. Il s’agit du type de données dit simple

10
précision (ou double précision). Nous opterons pour double précision par
mesure de prudence parce que le capital peut être une valeur très grande.
Leurs zones mémoires peuvent être initialisées à 0 en attendant que leurs
valeurs réelles leur soient affectées.
Le nombre de jours quant à lui doit être un nombre entier.
Toutes ces données peuvent changer. Il s’agit des variables.
Après cette analyse, la déclaration sera :

Déclaration

Var capital, taux, interet : double précision

nombre_de_Jours : entier

Exemple 2
Déclarer les variables pour un programme qui résout une équation du second
degré à une inconnue.

Analyse du problème

Avant de calculer les valeurs de X1 et X2, on doit d’abord connaître la valeur

de delta.
Delta est calculé par la formule
Delta = B*B – 4*A*C
A, B et C sont des coefficients d’une équation du second degré à une
inconnue.
Pour calculer delta, le microprocesseur ira chercher dans la mémoire centrale
les valeurs de A, B et C. Ainsi faut-il déclarer les zones mémoires
correspondantes avec les identificateurs respectifs A, B et C.
Après avoir calculé delta, le microprocesseur ira le stocker dans la mémoire
centrale.
Il faut donc déclarer aussi une zone mémoire pour delta.
Après avoir calculé et stocké la valeur de delta, le microprocesseur calculera
les valeurs de X1 et X2. Ces valeurs seront stockées dans la mémoire
centrale. Il faut donc déclarer les zones mémoires respectives sous les
identificateurs de X1 et X2.

Déclaration

Var A, B, C, delta, X1, X2 : double précision

1.2.7.1 Déclaration d’une constante

La syntaxe générale de la déclaration des constantes est :

Const IDENTIFICATEUR = valeur : type

11
On peut déclarer plusieurs constantes de même type :
Const IDENTIFICATEUR1=valeur,…,
IDENTIFICATEURN=valeur : type

On peut déclarer plusieurs constantes de types différents :

Const IDENTIFICATEUR1=valeur : type
Const IDENTIFICATEUR2=valeur : type
…
Exemple
Ecrire un programme qui calcule l’intérêt simple d’un capital placé au taux de
2.5 % pendant un certain nombre de jours donné sachant que l’intérêt simple
est calculé par la formule :
Intérêt simple = capital * taux * nombre de jours / 36000

Analyse du problème

Ce problème a déjà été analysé. Mais cette fois-ci le taux d’intérêt est connu
d’avance et ne doit pas être modifié quel que soit le capital et le nombre de
jours. Donc, le taux sera stocké dans la mémoire centrale comme constante
avec identificateur TAUX. Dans la même logique, nous pouvons stocker le
nombre 36000 au dénominateur comme une constante avec
identificateur JOURS_ANNEE.
Par convention, les identificateurs des constantes sont toujours en majuscule.

Déclaration

2.2.8 Opération d’affectation (assignation)

L’opération d’affectation consiste à attribuer une valeur à une variable (c’est-à-

dire remplir ou modifier le contenu d'une zone mémoire), autrement dit, cela
consiste à stocker une valeur dans une zone mémoire. Cette valeur peut être
un littéral (valeur donnée explicitement dans le code source d’un programme)
de même type que la zone mémoire ou provenir d’une autre zone mémoire ou
de l’évaluation d’une expression ou de la lecture d’un fichier ou du clavier
(lecture d’une donnée externe).
L’opérateur d’affectation est le symbole .

Mais en pseudo langage l’affectation se fera aussi avec le symbole ←. Dans la

suite, nous utiliserons plus le caractère ( ) car il est le principal symbole
d’affectation utilisé dans beaucoup de langages de programmation.
12
La syntaxe de l’affectation est :

ou
identificateur_zone_provenance
ou

ou

sachant que et identificateur_zone_provenance

sont des identificateurs de zones mémoires préalablement déclarées.

A remarquer que lors de l’opération d’affectation, la valeur affectée écrase tout

le contenu de la zone de stockage, c’est-à-dire le contenu de la zone de
stockage est remplacé par la valeur d’affectation. Mais cette valeur
d’affectation n’est pas effacée dans la zone de provenance. Il y a tout
simplement copie du contenu de la zone de provenance vers la zone de
stockage.

Exemple 1

A 2;
B C + 3;

Contre exemples :
A + 1 2;
A 3D; (3D n'est pas un identificateur; il n'est pas non plus une expression)

Exemple 2

A B ; affecte à la variable A la valeur de la variable B.

Notez bien que cette instruction n’a pas modifié la valeur de B : une
instruction d’affectation ne modifie que ce qui est situé à gauche de la flèche.
Exemple :
Si A contenait 12, B vaut maintenant 16. De même que précédemment, A vaut
toujours 12.
Exemple :
Si Tutu valait 6, il vaut maintenant 7. La valeur de Tutu est modifiée, puisque
Tutu est la variable située à gauche de la flèche
.
Voyons à présent le rôle des guillemets dans les chaînes de caractères ;
comparons maintenant deux algorithmes suivants :

13
Algorithme 1
Debut
Riri ← "Loulou"
Fifi ← "Riri"
Fin

Algorithme 2
Debut
Riri ← "Loulou"
Fifi ← Riri
Fin
La seule différence entre les deux algorithmes consiste dans la présence ou
dans l’absence des guillemets lors de la seconde affectation. Et l'on voit que
cela change tout.
Dans l'algorithme 1, ce que l'on affecte à la variable Fifi, c'est la suite de
caractères R – i – r - i.
Et à la fin de l’algorithme 1, le contenu de la variable Fifi est donc « Riri ».
Dans l’algorithme 2, en revanche, Riri étant dépourvu de guillemets, n'est pas
considéré comme une suite de caractères, mais comme un nom de variable.
Le sens de la ligne devient donc : « affecte à la variable Fifi le contenu de la
variable Riri ». A la fin de l’algorithme 2, la valeur de la variable Fifi est donc «
Loulou ». Ici, l’oubli des guillemets conduit certes à un résultat, mais à un
résultat différent.

A noter, car c’est un cas très fréquent, que généralement, lorsqu’on oublie les
guillemets lors d’une affectation de chaîne, ce qui se trouve à droite du signe
d’affectation ne correspond à aucune variable précédemment déclarée et
affectée. Dans ce cas, l’oubli des guillemets se solde immédiatement par une
erreur d’exécution.
Ceci est une simple illustration. Mais elle résume l’ensemble des problèmes
qui surviennent lorsqu’on oublie la règle des guillemets aux chaînes de
caractères.

2.2.9 Ordre des instructions

Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un rôle
essentiel dans le résultat final. Considérons les deux algorithmes suivants :

Algorithme 1
Variable A : Numérique
Début
A ← 34 ;
A ← 12 ;
Fin

14
Algorithme 2
Variable A : Numérique
Début
A ← 12
A ← 34
Fin
Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle
est 34.

Il est tout aussi clair que ceci ne doit pas nous étonner. Lorsqu’on indique le
chemin à quelqu’un, dire « prenez tout droit sur 1km, puis à droite » n’envoie
pas les gens au même endroit que si l’on dit « prenez à droite puis tout droit
pendant 1 km ».

Enfin, il est également clair que si l’on met de côté leur vertu pédagogique, les
deux algorithmes ci-dessus sont parfaitement idiots ; à tout le moins ils
contiennent une incohérence. Il n’y a aucun intérêt à affecter une variable pour
l’affecter différemment juste après. En l’occurrence, on aurait tout aussi bien
atteint le même résultat en écrivant simplement :

Algorithme 1
Variable A : Numérique
Début
A ← 12 ;
Fin

Algorithme 2
Variable A : Numérique
Début
A ← 34 ;
Fin

Exemple

Soit un algorithme qui permet de calculer la moyenne de 3 notes et de

l’afficher.

Algorithme Moyenne ;
Const Note1 12 ; Note2 7.5 ; Note3 14 ;
Var Som, Moy : réel
début
Som Note1
Som Som + Note2
Som Som + Note3
15
Moy Som / 3
Afficher („ La moyenne est de : ,‟ ; Moy)
fin.

EXERCICES

Exercice 1
Quelles seront les valeurs des variables A et B après exécution des
instructions suivantes ?
Var A, B : Entier
Début
A 1
B A+3
A 3
Fin

Exercice 2
Quelles seront les valeurs des variables A, B et C après exécution des
instructions suivantes ?
Var A, B, C: Entier
Début
A 5
B 3
C A+B
A 2
C B–A
Fin

Exercice 3
Quelles seront les valeurs des variables A et B après exécution des
instructions suivantes ?
Var A, B : Entier
Début
A 5
B A+4
A A+1
B A–4
Fin

Exercice 4
Quelles seront les valeurs des variables A, B et C après exécution des
instructions suivantes ?
Var A, B, C : Entier
Début
A 3
16
B 10
C A+B
B←A+B
A←C
Fin

Exercice 5
Quelles seront les valeurs des variables A et B après exécution des
instructions suivantes ?
Var A, B : Entier
Début
A 5
B 2
A B
B A
Fin
Les deux dernières instructions permettent-elles d’échanger les deux valeurs
de B et A ? Si l’on inverse les deux dernières instructions, cela change-t-il
quelque chose ?

Exercice 6
Plus difficile, mais c’est un classique absolu, qu’il faut absolument maîtriser :
écrire un algorithme permettant d’échanger les valeurs de deux variables A et
B, et ce quel que soit leur contenu préalable.

Exercice 7
Une variante du précédent : on dispose de trois variables A, B et C. Ecrivez un
algorithme transférant à B la valeur de A, à C la valeur de B et à A la valeur de
C (toujours quels que soient les contenus préalables de ces variables).

Exercice 8
Que produit l’algorithme suivant ?
Var A, B, C : Chaîne
Début
A ← "423"
B ← "12"
C←A+B
Fin
Exercice 9
Que produit l’algorithme suivant ?
Variables A, B, C : Chaîne
Debut
A ← "423"
B ← "12"
C←A&B
Fin
17
 2.2.10 Opération de lecture des données externes

L’opération de lecture consiste à récupérer une donnée externe à la mémoire

centrale en provenance d’un fichier sur disque ou de la saisie au clavier par
l’utilisateur et ensuite de l’affecter à une variable. Chaque langage de
programmation possède des fonctions spécifiques pour la lecture des données
externes. Mais au niveau algorithmique, nous utiliserons simplement le verbe
Lire.
Une fois lue, une donnée externe doit être stockée en mémoire centrale par
l’opération d’affectation. D’où la syntaxe suivante :

où est une zone mémoire

(variable) préalablement déclarée.

Exemple

Ecrire un programme qui lit à partir du clavier le capital et le nombre de jours et

affiche l’intérêt simple calculé au taux de 2.5 % sachant que l’intérêt simple est
calculé par la formule :
Intérêt simple = capital * taux * nombre de jours / 36000
Algorithme (incomplet) :
var capital = 0.0, interet = 0.0 : double précision
var jours = 0 : entier
const TAUX = 2.5 : double précision
const JOURS_ANNEE = 36000 : entier
capital = lire jours = lire
Remarque
Certaines notations algorithmiques utilisent la syntaxe
Lire identificateur
Ainsi l’exemple ci-dessus s’écrirait :
var capital = 0.0, interet = 0.0 : double
précision var jours = 0 : entier
const TAUX = 2.5 : double precision
const JOURS_ANNEE = 36000 : entier
lire capital
lire jours
Toujours est-il que, quelque soit la syntaxe utilisée, la lecture de données
externes consiste en deux opérations :
 Obtenir la donnée saisie au clavier par une instruction ou fonction de
lecture
 Assigner cette donnée à une variable.

18
EXERCICES

Exercice 1
Quel résultat produit le programme suivant ?
Var val, double : simple précision;
Début
Val←231
Double ← Val * 2
Ecrire Val
Ecrire Double
Fin.

Exercice 2
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et
affiche le carré de ce nombre.

Exercice 3
Ecrire un programme qui lit le prix HT(hors taxes) d’un article, le nombre
d’articles et le taux de TVA, et qui fournit le prix total TTC (toutes taxes
comprises) correspondant. Faire en sorte que des libellés apparaissent
clairement.

Exercice 4
Ecrire un algorithme utilisant des variables de type chaîne de caractères, et
affichant quatre variantes possibles de la célèbre « belle marquise, vos beaux
yeux me font mourir d’amour ». On ne se soucie pas de la ponctuation, ni des
majuscules.

2.2.11 Opération de conversion des données

Le stockage d’une donnée se fait suivant le type de la variable. Il est possible

de convertir une donnée d’un type vers un autre type. Par exemple, une
donnée de type double précision comme 45.0 peut être convertie en entier 45
et vice versa. Une chaîne de caractère "45.0" peut être convertie en double
précision 45.0.

Conversion d’un type numérique vers un autre type numérique

Lorsqu’une opération arithmétique doit être exécutée, les opérandes sont
d’abord automatiquement convertis avec la précision du plus précis des
opérateurs, puis l’opération est effectuée avec cette précision. Aucune
instruction de conversion n’est nécessaire.
Ainsi, le résultat d’une opération entre un opérande simple précision et un
opérande double précision est en double précision.
Exemple :

19
var capital = 45678.25 : double précision
const TAUX =2.5 : double précision
var jours = 35 : entier
var interet = capital * TAUX * jours / 36000 : double précision
Le résultat qui sera stocké dans la variable interet doit être en double précision
parce que c’est le type le plus précis des opérandes. Par conséquent, la
variable interet doit absolument être déclarée comme une variable du type
double précision.

2.2.12 Opérateurs arithmétiques

Les opérateurs arithmétiques dans l’ordre décroissant de leurs priorités sont :

^ Exponentiation
* / Multiplication Division
+ - Addition Soustraction
% \ Modulo Division entière
L’évaluation des expressions arithmétiques se fait selon l’ordre des priorités
des opérateurs défini ci-dessus. Par exemple, l’expression 2+5*4 donne 22.
Des parenthèses permettent de changer cet ordre. Ce sont d’abord les
expressions entre parenthèses qui sont évaluées. Par exemple, l’expression
(2+5)*4 donne 28.
Les langages de programmation Basic et Java utilisent les mêmes opérateurs
arithmétiques à l’exception de Basic qui utilise MOD au lieu de % pour modulo.

Remarque :
En cas de conflit entre deux opérateurs de même priorité, on commence par
celui situé le plus à gauche.
Exemples :
a +b-c : on fait d'abord a + b, ensuite - c
a/b*c : on fait d'abord a / b, ensuite * c
soit l'expression suivante :

20
Exemple

Ecrire un programme qui lit à partir du clavier le capital et le nombre de jours et

affiche l’intérêt simple calculé au taux de 2.5 % sachant que l’intérêt simple est
calculé par la formule :
Intérêt simple = capital * taux * nombre de jours / 36000
Algorithme (dans la perspective Basic) :
var capital = 0.0 : double précision ;
interet = 0.0 : double précision
var jours = 0 : entier
const TAUX = 2.5 : double précision
const JOURS_ANNEE = 36000 : entier
capital = lire
jours = lire
interet = capital * TAUX * jours / JOURS_ANNEE

2.2.13 Opérateurs relationnels

Les opérateurs relationnels comparent deux valeurs. Le résultat est de type

booléen (vrai ou faux).
Le type booléen n’a que deux valeurs stockées sur un bit. Nous savons qu’un
bit peut être soit 0 soit 1. 0 est interprété comme FAUX et 1 est interprété
comme VRAI.
Les opérateurs relationnels sont :
= Egalité
< Inférieur
> Supérieur
<= Inférieur ou égal
>= Supérieur ou égal
<> Différent
Ils sont utilisés dans les structures conditionnelles.
Exemple :
Var A = 8, B = 5 : entiers
Var C : booléen
C A>B
C A<B
C A <= B
C A >= B
C A <> B
C A=B

21
La valeur de la variable C est 0 (FAUX) à la troisième instruction, 1 (VRAI) à la
quatrième instruction, 1 (VRAI) à la cinquième instruction et 0 (FAUX) à la
dernière instruction.
Les langages de programmation utilisent les mêmes opérateurs excepté Java
qui utilise == au lieu de = pour éviter la confusion entre égalité et affectation et
= ! au lieu de <>.
Le langage Basic ne connait pas le type booléen. Le résultat d’une opération
relationnelle est un entier -1 (interprété comme VRAI) ou 0 (interprété comme
FAUX).
En Java, le type booléen est noté boolean et ses valeurs sont TRUE (VRAI)
et FALSE (FAUX) codées sur 1 bit. Il convient de noter que TRUE et FALSE
ne sont pas de chaînes de caractères et ne doivent pas être entourés des
guillemets.

2.2.14 Opérateurs logiques

Les opérateurs logiques testent des opérations multiples. Le résultat d’une

opération logique est un booléen (VRAI ou FAUX) et permet de prendre une
décision dans les structures conditionnelles (voir chapitres 2 et 3).
L’ordre des priorités d’évaluation des opérateurs logiques est le suivant : NON,
ET, OU, XOU (OU Exclusif), IMP (Implication), EQV (Equivalence).
Dans les tables de vérité ci-dessous, 0 signifie FAUX et 1 signifie VRAI.

22
CHAPITRE II. STRUCTURES DE CONTROLE ET
ORDINOGRAMMES

Avant d’aborder les structures de contrôles, il apparaît nécessaire de définir un

ordinogramme.
Définition : Un ordinogramme est une représentation purement symbolique des
instructions d’un algorithme. Dans un ordinogramme chaque instruction est
représentée par une forme géométrique. Les formes les plus utilisées sont:

- Le rectangle : pour les calculs ou affectations ;

- Le parallélogramme pour les opérations d’entrée/sortie ;
- Le losange pour les tests ;
- L’ellipse pour le début et la fin ;
- Le cercle pour la connexion.
Nous allons y revenir plus en détail plus bas dabs ce chapitre.

II.1. Structures de contrôle

Une structure de contrôle peut être définie comme la manière d’organiser

l’exécution des instructions dans un algorithme (ou programme informatique).
Elle a pour but de déterminer l’ordre dans lequel les opérations doivent être
effectuées dans un algorithme.

II.1.1. Structure conditionnelle (structure alternative) : si ...alors…sinon

La structure si …alors...sinon permet d'exécuter une ou plusieurs instructions

si certaines conditions sont remplies
Elle est une instruction de décision. (si oui ou non deux valeurs de
champs sont égales et, si elles ne le sont pas, laquelle est la plus grande).

V F

Ces structures conditionnelles sont de trois types :

1° Alternative simple

Syntaxe

Si condition Alors
Action
23
Fin si

Ordinogramme

La logique de cette structure correspond à l’ordinogramme suivant :

Non
Condition ?

Oui

Action1

Si la condition est vérifiée, l’action1 qui peut être constituée d’une ou

plusieurs instructions est exécutée. Dans tous les autres cas, l’action1 est
sautée et le contrôle est transféré à l’étape suivante de l’algorithme.

2° Alternative double

Syntaxe

Si condition Alors
Action1
Sinon
Action2
Finsi

Ordinogramme

La logique de cette structure est représentée par le schéma ci-après :

Condition ? Non

Oui

Action1 Action2

24
Comme il est indiqué sur l’ordinogramme, si la condition est vérifiée, l’action1
est exécutée. Dans tous les autres cas, il y a exécution de l’action2.

Exemple

Var A, B : entier
Var Grand, Petit : entier
Lire A, B
Si A>B
alors
Grand = A
Petit = B
Sinon
Grand = B
Petit = A
Finsi

3° Alternative multiple (Conditionnel généralisé)

Syntaxe

Si condition 1 Alors
Instruction 1
Sinon si condition 2 Alors
Instruction 2
.
.
.
Sinon si condition N Alors
Instruction N
Sinon
Instruction X
Finsi
La logique de cette structure ne permet l’exécution que d’une seule action.
Plus précisément, soit l’action qui suit la première condition vérifiée est
exécutée, soit est exécutée celle qui suit la dernière instruction « sinon ».
Condition est une expression dont la valeur est VRAI ou FAUX.

Exemple

Prenons le cas d’un programme devant donner l’état de l’eau selon sa

température. Ce programme doit pouvoir choisir entre trois réponses possibles
(solide, liquide ou gazeuse).
25
Une première solution serait la suivante :

Variable Temp : Entier

Début
Ecrire "Entrez la temperature de l‟eau :"
Lire Temp
Si Temp =< 0 Alors Ecrire "C‟est de la glace"
FinSi
Si Temp > 0 Et Temp < 100 Alors
Ecrire "C‟est du liquide"
Finsi
Si Temp > 100 Alors Ecrire "C‟est de la vapeur"
Finsi
Fin

Vous constaterez que c’est un peu laborieux. Les conditions se ressemblent

plus ou moins, et surtout on oblige la machine à examiner trois tests
successifs alors que tous portent sur une même chose, la température de
l'eau (la valeur de la variable Temp). Il serait ainsi bien plus rationnel
d’imbriquer les tests de cette manière :

Variable Temp : Entier

Début
Ecrire "Entrez la temperature de l‟eau :"
Lire Temp
Si Temp =< 0 Alors Ecrire "C‟est de la glace"
Sinon
Si Temp < 100 Alors
Ecrire "C‟est du liquide"
Sinon
Ecrire "C‟est de la vapeur"
Finsi
Finsi
Fin

Nous avons fait des économies : au lieu de devoir taper trois conditions, dont
une composée, nous n’avons plus que deux conditions simples. Mais aussi, et
surtout, nous avons fait des économies sur le temps d’exécution de
l’ordinateur. Si la température est inférieure à zéro, celui-ci écrit dorénavant «
C’est de la glace » et passe directement à la fin, sans être ralenti par l’examen
d’autres possibilités (qui sont forcément fausses).
Cette deuxième version n’est donc pas seulement plus simple à écrire et plus
lisible, elle est également plus performante à l’exécution.
Les structures de tests imbriqués sont donc un outil indispensable à la
simplification et à l’optimisation des algorithmes.

26
NB :
L’informatique met à notre disposition quatre opérateurs logiques : ET, OU,
NON, et XOR.
• Le ET a le même sens en informatique que dans le langage courant.
Pour que "Condition1 ET Condition2" soit VRAI, il faut impérativement
que Condition1 soit VRAI et que Condition2 soit VRAI. Dans tous les
autres cas, "Condition 1 et Condition2" sera faux.
• Il faut se méfier un peu plus du OU. Pour que "Condition1 OU
Condition2" soit VRAI, il suffit que Condition1 soit VRAI ou que
Condition2 soit VRAI. Le point important est que si Condition1 est VRAI
et que Condition2 est VRAI aussi, Condition1 OU Condition2 reste
VRAIE. Le OU informatique ne veut donc pas dire « ou bien ».
• Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que
"Condition1 XOR Condition2" soit VRAI, il faut que soit Condition1 soit
VRAI, soit que Condition2 soit VRAI. Si toutes les deux sont VRAI, ou
que toutes les deux sont FAUX, alors le résultat global est considéré
comme FAUX. Le XOR est donc l'équivalent du "ou bien" du langage
courant.
• Enfin, le NON inverse une condition : NON(Condition1) est VRAI si
Condition1 est FAUX, et il sera FAUX si Condition1 est VRAI. Retenons
que plutôt d’écrire NON(Prix > 20), il serait plus simple d’écrire tout
bonnement Prix=<20.

II. 1.2. Rupture de séquence

On appelle séquence, une suite d’actions dont l’exécution commence par la

première ligne d’instruction et passe par toutes les instructions jusqu’à la
dernière. C'est-à-dire le contrôle passe d’une instruction à l’autre selon l’ordre
dans lequel elles apparaissent dans l’algorithme.
De manière générale, un algorithme se présente comme suit :

Il peut arriver dans un algorithme qu’une séquence subisse une interruption

pour une raison quelconque, qu’elle poursuive l’exécution à un autre endroit
spécifique de l’algorithme. Il s’agit dans ce cas d’un branchement. C’est un
transfert du contrôle de l’algorithme vers un endroit spécifique. Il faut définir

27
une étiquette ou un label sur la ligne à laquelle on se branche. (numéro de
l’instruction choisi par le programme).

1° Rupture inconditionnelle (Branchement inconditionnel)

C’est un transfert à une ligne spécifique de l’algorithme basé sur aucune
condition.

Exemple :
Lire A, B
S=A+B
D=A-B
Aller à 10
Afficher “ la somme de ces deux termes est” ; S
10 Afficher “ la différence du 1er par le 2ème terme est” ; D

2° Rupture conditionnelle (Branchement conditionnel)

C’est un transfert à une ligne spécifique de l’algorithme basé sur une ou
plusieurs conditions.
Exemple :
Début
Var s : car
Afficher "si vous êtes un homme tapez H,
sinon F"
Lire s
Si s="H" alors Aller à 10
Afficher "Bonjour madame"
Aller à 20
10 Afficher "Bonjour monsieur"
20 Afficher "merci"
Fin

Aller à 10 est un branchement conditionnel car le transfert à l’instruction 10

n’est réalisé que lorsque s="H". Par contre, le branchement Aller à 20 est
inconditionnel.

II. 1. 3. Le sélecteur des cas

L’instruction conditionnelle SELON permet de choisir d'exécuter une action ou

une autre en fonction de la valeur d'une expression.

La syntaxe est la suivante :

28
SELON Variable de comparaison
Cas Expression1: Action1
Cas Expression2: Action2.1
Action2.2
…
[AUTRE[S] CAS : Action autre(s)cas]
FIN

Exemple :
En langage C ou C++, case s'emploie obligatoirement à l'intérieur d'une
instruction switch :

switch (expression)
{
case exp1 :
//…instructions exécutées si expression est égale à la valeur de exp1…
break ;
case exp2 :
//…instructions exécutées si expression est égale à la valeur de exp2…
break ;
…
default :
//…instructions exécutées si expression n’est égale à aucune valeur de
case…

Les valeurs de chaque case doivent être uniques.

II.1.4 Structure répétitive (schéma itératif)

Lorsqu'on a plusieurs actions qui se répètent, on écrit celles-ci dans une

même action composée et l’on réitère plusieurs fois l’exécution. Le nombre
d'itérations peut être connu à priori ou pas. Dans ce dernier cas c’est
l’exécution de l’action itérative qui déterminera son arrêt.

Structure d’une action itérative :

Boucle Condition
...
Action composée
29
...
Fin Boucle

Il existe plusieurs façons d'exprimer une action itérative :

1° La boucle « Tant que »

La boucle Tant que permet d'exécuter un bloc d'instructions un nombre infini

de fois. Il existe plusieurs variantes de l'instruction Tant que, mais elles
évaluent chacune une condition numérique pour déterminer si l'exécution doit
être poursuivie. Comme pour Si...Alors, condition doit être une valeur ou une
expression dont le résultat est False (zéro) ou True (différent de zéro).

Dans la boucle Tant...que suivante, les actions sont exécutées aussi

longtemps que condition est True :

C'est-à-dire, qu’on ne connaît pas à priori le nombre de répétitions

d’instructions à effectuer. La condition d’arrêt de la boucle est par exemple
calculée au sein même de la boucle.
Les instructions de la boucle sont répétées tant qu’une variable n’a pas atteint
une certaine valeur. Elle est utilisée quand le nombre de répétitions est non
prédéterminé.
Syntaxe :
Tant que Condition Faire
Actions
Fin Faire

Ordinogramme :

Lors de l'exécution de cette boucle , le programme teste d'abord condition.

Si condition est False (zéro), il ignore toutes les instructions. Si elle est True
(différente de zéro), le programme exécute les instructions, puis revient à
l'instruction Tant que et teste de nouveau la condition.

30
La boucle peut donc être exécutée un nombre infini de fois, aussi longtemps
que condition est différent de zéro ou True. Les instructions ne sont jamais
exécutées si condition est initialement False.

Exemple :

Début
Var S, I : Entiers
S 0
I 1
Tant que I ≤ 100 faire
S S+I
I I+1
Fin Faire
Afficher S
Fin

2° La boucle Répéter …… Jusqu’à ce que

La boucle Répéter est utilisée quand le nombre de répétitions est non
prédéterminé. Elle est aussi utilisée comme la boucle Tant que sauf qu’ici la
condition est inversée. Sa syntaxe est :
Syntaxe :
Répéter
Actions
Jusqu’à ce que Condition

Ordinogramme :

31
Exemple :
Début
Var S, I : Entiers
S 0
I 1
Répéter
S S+I
I I+1
Jusque à ce que I 100
Afficher S
Fin

2° La boucle Pour

Les boucles Tant que sont particulièrement utiles lorsque vous ne savez pas
combien de fois les instructions doivent être exécutées dans la boucle.
Cependant, lorsque vous savez combien de fois les instructions doivent être
exécutées, il est préférable d'utiliser une boucle Pour. Contrairement à la
boucle Tant que, la boucle Pour inclut une variable appelée compteur dont la
valeur augmente (ou diminue) à chaque itération de la boucle.

Syntaxe :

Pour V ← vd à vf (inc n)
Actions
Fin pour

Où V est le nom de la variable qui a pour valeur de départ vd et pour valeur

final vf, avec n comme pas de progression (ou incrémentation).

32
Ordinogramme :

A remarquer que Si vd vf, on écrit à la place de , et devient le pas

de décrémentation.

A noter aussi que l'argument peut être positif ou négatif. Dans le premier
cas, la valeur de vd doit être inférieure ou égale à celle de vf pour que les
instructions soient exécutées. Dans le second cas, il faut que la valeur de vd
soit supérieure ou égale à celle de vf pour que le corps de la boucle soit
exécuté. Si le pas n'est pas défini, la valeur par défaut de l'argument est 1.

Lors de l'exécution de la boucle Pour, le programme procède comme suit :

• Il affecte la valeur vd à v. ****

• Il vérifie si la valeur de v est supérieure à celle de vf. Si tel est le cas,
le programme sort de la boucle.

(Si la valeur de inc est négative, le programme vérifie si la valeur de v est

inférieure à celle de vf.)

• Il exécute les instructions.

• Il augmente la valeur de v de 1, ou de la valeur spécifiée pour .
• Il répète les étapes 2 à 4.

Exemple 1
On se propose d’écrire un algorithme qui calcule et affiche la somme
S = 1+2+3+…+100. On peut procéder de la manière suivante :

33
 Début
Var S, I : Entiers
S 0
I 1
5 S S+I
I I+1
Si I 100 alors Aller à 5
Afficher S
Fin
Noter que la ligne 5 et les deux autres qui suivent, seront exécutées 100 fois de
manière répétitive. Cette partie s’appelle boucle ; et I est le compteur de la
boucle.
On peut améliorer cet algorithme en utilisant le schéma itératif.
Début
Var S, I : Entiers
S 0
Pour I 1 à 100
S S+I
Fin pour I
Afficher S
Fin

Exemple 2:

Pour i = 1 à 10
Tant que
Afficher "Personne N°"; i
Lire "Introduire son âge", Age
Faire Age > 18
Fin pour i

Imbrication de boucles

Plusieurs boucles peuvent être imbriquées l'une dans l'autre, à la manière des
poupées russes. Il faut tout de même respecter une certaine logique. Le haut de
la petite poupée ne s'emboîte pas avec la base de la grande :

Pour i = 1 à 10
Pour j = 1 à 10
34
 Afficher j; " fois "; i;" égal "; j * i
Fin pour j
Fin pour i

2° La boucle « Sans fin »

Il s’agit d’une boucle dont les instructions se répètent à l’infini. On peut sortir
d’une telle boucle par une instruction de débranchement effectuée par
exemple à l’issue d’un test.
A noter que l’oubli d’une instruction de débranchement dans une telle boucle
génère un programme qui ne s’arrête pas !

Exercices

Exercice 1
Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et
3 jusqu’à ce que la réponse convienne.

Exercice 2
Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à
ce que la réponse convienne. En cas de réponse supérieure à 20, on fera
apparaître un message : « Plus petit ! », et inversement, « Plus grand ! » si le
nombre est inférieur à 10.

35
Exercice 3
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche
les dix nombres suivants. Par exemple, si l'utilisateur entre le nombre 17, le
programme affichera les nombres de 18 à 27.

Exercice 4
Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la
table de multiplication de ce nombre, présentée comme suit (cas où
l'utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70

Exercice 5
Ecrire un algorithme qui demande un nombre de départ, et qui calcule la
somme des entiers jusqu’à ce nombre. Par exemple, si l’on entre 5, le
programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
NB : on souhaite afficher uniquement le résultat, pas la décomposition du
calcul.

Exercice 6
Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa
factorielle.
NB : la factorielle de 8, notée 8 !, vaut
1x2x3x4x5x6x7x8

Exercice 7
Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur,
et qui lui dise ensuite quel était le plus grand parmi ces 20 nombres :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
etc.
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est : 14
Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en
quelle position avait été saisie ce nombre : C’était le nombre numéro 2

Exercice 8
Réécrire l’algorithme précédent, mais cette fois-ci on ne connaît pas d’avance
combien l’utilisateur souhaite saisir de nombres. La saisie des nombres
s’arrête lorsque l’utilisateur entre un zéro.
36
Exercice 9
Lire la suite des prix (en dollars entiers et terminée par zéro) des achats d’un
client. Calculer la somme qu’il doit, lire la somme qu’il paye, et simuler la
remise de la monnaie en affichant les textes "10 dollars", "5 dollars" et
"1 dollar" autant de fois qu’il y a de coupures de chaque sorte à rendre.

Exercice 10
Écrire un algorithme qui permette de connaître ses chances de gagner au
tiercé, quarté, quinté et autres impôts volontaires.
On demande à l’utilisateur le nombre de chevaux partants, et le nombre de
chevaux joués. Les deux messages affichés devront être :
Dans l’ordre : une chance sur X de gagner
Dans le desordre : une chance sur Y de gagner
X et Y nous sont donnés par la formule suivante, si n est le nombre de
chevaux partants et p le nombre de chevaux joués (on rappelle que le signe !
signifie "factorielle", comme dans l'exercice 6 ci-dessus) :
X = n ! / (n - p) !
Y = n ! / (p ! * (n – p) !)
NB : cet algorithme peut être écrit d’une manière simple, mais relativement
peu performante. Ses performances peuvent être singulièrement augmentées
par une petite astuce. Vous commencerez par écrire la manière la plus simple,
puis vous identifierez le problème, et écrirez une deuxième version permettant
de le résoudre.

II.2. Ordinogrammes et leurs langages

Un ordinogramme est la représentation visuelle d’un algorithme. C’est un

diagramme constitué de symboles et de flèches qui les connectent. Ces
symboles ont des formes qui indiquent chacune le type d’action exécuté au
cours de l’étape en question.

Le tableau ci-dessous indique les symboles les plus couramment usités dans
le tracé des ordinogrammes :

37
Symbole Nom

Terminal

Entrée / Sortie

Traitement

Décision

1. Symbole terminal

Le symbole ovale est utilisé pour précisément marquer le début ou la

fin d’un algorithme par Début ou Stop (Fin) respectivement.

2. Symbole d’entrée/sortie

Ce symbole appelé parallélogramme, est utilisé pour indiquer toute opération

d’entrée ou de sortie par Lire ou Ecrire respectivement.

3. Symbole de traitement

38
 Le symbole rectangulaire est utilisé pour indiquer une opération de traitement.
Il peut être une instruction d’affectation.

Exemple
:
Produit = A x B

indique que le résultat de A x B doit être affecté à la variable Produit.

4. Symbole de décision

Le symbole losange est utilisé pour indiquer toute question posée au cours de
l’algorithme ; la réponse amenant à une décision.

Le tableau ci-dessous indique les différents symboles utilisés lors de la

question posée :

Symbole Signification
Egal à
Différent de
< Plus petit que
Plus petit ou égal à
Plus grand que
>
Plus grand ou égal à

A noter que dans un algorithme, on utilise parfois le symbole comme

instruction d’affectation.

Exemple

Ecrire un algorithme et son ordinogramme correspondant qui résolvent

l’équation du second degré Ax2 + Bx + C = 0 dans .
Algorithme
Début
Var A, B, C, D, X, X1, X2 : Réels
Lire A, B, C

39
 D B2 – 4*A*C
Si D < 0 Alors
Afficher "Pas de solution"
Sinon si D = 0 Alors
X - B / 2*A
Afficher "La racine double est " ; X1
Sinon
X1 (- B √ ) / 2*A
X2 (- B √ ) / 2*A
Afficher "Les racines distinctes sont " ; X1 ; X2
Fin Si
Fin.

Ordinogramme
Début

Lire A, B, C

D B2 – 4*A*C

V F
D<0
V F
D=0
"Pas de solutions »
X - B / 2*A X1 (- B + D ) / 2*A
X2 (- B - D ) / 2*A

Afficher X
Afficher X1, X2

Fin

40
CHAPITRE III. SOUS-PROGRAMMES
III.1 Procédures et fonctions

Dans la résolution d’un problème, on peut constater qu'une suite d'actions

revient plusieurs fois. Dans ce cas, il serait judicieux de l'écrire une seule fois,
et de l'utiliser autant de fois que c'est nécessaire, en effectuant des calculs
avec des données différentes. Cette suite d'actions sera définie dans un sous-
programme, qui peut prendre soit la forme d’une procédure, soit la forme d’une
fonction.

D’autre part, on peut observer que certains groupes d’actions se rapportent à

des traitements précis et différents. Il est souhaitable alors de représenter
chacun d’eux dans un sous-programme, ce qui permettra d’améliorer la
conception du programme et sa lisibilité. On perçoit alors un programme
comme un ensemble de procédures/fonctions. La structuration d’un
programme par morceaux (modules) est la base de la programmation
structurée et modulaire.

Un sous-programme (ou sous-algorithme) est un module algorithmique

complet, défini et indépendant qui peut être utilisé ou appelé par un
quelconque algorithme principal ou par d’autres sous-programmes. Un sous-
programme reçoit des valeurs, les arguments, à partir de l’algorithme appelant,
il exécute des calculs et transmet ensuite les résultats obtenus au programme
appelant.

Dans son utilisation, les modules offrent plusieurs avantages :

• La simplification des programmes en permettant de ne pas répéter
plusieurs fois une même séquence d’instructions au sein du programme.
• La localisation des erreurs est facile.
• La lisibilité des programmes.
• Le fait de favoriser un travail en équipe.
• Réutilisation de modules déjà existant. Etc.
Un sous-programme est défini de manière indépendante afin qu’il puisse être
appelé par de nombreux programmes différents et/ou plusieurs fois
successivement par le même programme.
La différence essentielle entre le format d’un programme et celui d’un sous-
programme réside en ce que ce dernier sera généralement précédé d’un
entête de la forme : NOM (PAR1, PAR2, …,PARk) ; les paramètres qui sont
utilisées pour la transmission des données entre le sous-programme et le
programme appelant.

41
Une autre différence réside en ce que le sous-programme comportera une
instruction « Retour » plutôt qu’une instruction « Sortie » ; ceci permet
d’insister sur le fait que le contrôle est transféré au programme appelant après
que l’exécution du sous-programme ait été achevée.
Les sous-programmes se classent fondamentalement en deux catégories : les
sous-programmes de fonction et les sous-programmes de procédure. Une
de grandes différences entre eux est qu’une fonction ne renvoie qu’une seule
valeur au programme appelant, alors qu’une procédure peut en renvoyer plus
d’une.

III.1.1. La procédure

Une procédure est un sous-programme qui peut retourner 0, 1 ou plusieurs

résultats.
a. Définition d’une procédure

Procédure nom (liste d'arguments : type);

début
corps de la procédure fin;
La première ligne s’appelle l’en-tête (ou la signature) de la procédure. La liste
d’arguments est une suite de données à échanger avec d’autres programmes.
b. Appel d’une procédure
nom-de-la-procédure (liste d'arguments);
A remarquer que :
 Si une liste d’arguments apparaît dans la définition d’un sous-
programme, lors de l’appel à ce dernier, elle doit également apparaître
dans l’action d’appel.
 Les listes d'arguments dans la définition d’un sous-programme et dans
son appel doivent se correspondre. C'est à dire, il doit y avoir le même
nombre d'arguments dans les deux listes. L’ordre d’apparition des
arguments dans les deux listes doit être le même. Chaque argument
d'une liste doit être de même type que son homologue de l'autre liste.
 La liste d'arguments dans la définition d’un sous-programme contient le
type de chaque argument. Ce n’est pas le cas de celle de l’appel.

42
Exemple

On veut écrire un algorithme qui calcule le salaire des commerciaux d’une

entreprise. Celui-ci est composé d’un fixe différent d’un employé à un autre et
d’une prime d’intéressement de 10% du chiffre d’affaire réalisé si celui-ci
dépasse les 50 000 F, de 3% sinon.
On isolera la suite d'actions qui permet de rentrer les salaires fixes de chacun
ainsi que leur chiffre d’affaire.

Procédure Saisie( Var Sal , CA : entier) ;

début
Lire (‟ Entrer le salaire du commercial :,‟‟ Sal);
Lire (‘‘Entrer son chiffre d’affaire :,’’CA) ;
fin.

III.1.2. La fonction

Une fonction est un sous programme qui retourne obligatoirement une valeur.
Cette dernière sera stockée dans une variable qui porte le même nom que la
fonction.

a. Définition d’une fonction

Fonction nom (liste d'arguments : type) : type;

début
corps de la fonction
fin;
Le nom de la fonction est utilisé comme identificateur d’une variable, on
déclare alors le type de cette dernière.
b. Appel d’une fonction
var =expression (... fonction (liste d'arguments.) ...)

Exemple (suite)

De la même manière, on isole les actions permettant de calculer la

commission de chaque commercial.

Fonction Commission(Montant : réel) : réel ;

Const plafond = 50000 ;
Var taux : réel ;
début

43
 Si Montant ≥ plafond Alors
taux = 0,1 Sinon
taux = 0,03
Fin Si ;
Commission = Montant * taux ;
fin.

On peut construire un troisième sous-programme qui calculera le salaire de

chacun.

Procédure Calcul_Salaire ;
Var Salaire, Sal_fixe, Chif_Aff : réel ;
début
Saisie(Sal_fixe, Chif_Aff) ;
Salaire = Sal_fixe + Commission(Chif_Aff )
Afficher(„‟ Le salaire est de : ‘’ Salaire) ;
fin.

Commentaires :

 Les listes d’arguments sont optionnelles.

 La procédure Calcul_Salaire est le programme appelant. La procédure
Saisie et la fonction Commission sont les programmes appelés.
N’importe quel sous-programme peut être appelant ou appelé (il faut
éviter les appels circulaires).
 Les arguments des Procédures/Fonctions appelées sont les paramètres
formels (ou fictifs). Ils peuvent porter les mêmes noms (ou des noms
différents) que leurs correspondants des programmes appelant qualifiés
de paramètres réels (ou effectifs).
 Dans la procédure Calcul_Salaire, à l’appel de la procédure Saisie, les
paramètres réels Sal_fixe, Chif_Aff sont vides (ou contiennent plutôt
n’importe quoi). Au retour du sous programme, ils posséderont
respectivement le salaire et le chiffre d’affaire réalisé.
 Dans l’appel à la fonction Commission, le paramètre réel Chif_Aff
possède déjà la valeur du chiffre d’affaire retournée par Saisie. Au
retour de cette fonction la variable commission contiendra la valeur de la
prime.

III.2 Variables locales et globales

Les sous-programmes communiquent entre eux par des paramètres. Une

Procédure/Fonction peut avoir des variables internes qui ne sont pas visibles
par les autres. Il s’agit de variables locales. Elles ne sont accessibles que par
le sous-programme où elles sont définies. Par conséquent, différents sous-

44
programmes peuvent avoir des variables locales portant le même nom
éventuellement. Celles-ci n’auront pas la même signification pour chacun
d’eux. On dira également que la portée d’une variable locale est le sous-
programme où elle a été définie.

Exemple :
Sal_fixe et Chif_Aff sont des variables locales à Calcul_Salaire.

Si une variable doit être accessible par tous les sous-programmes, il faut la
définir comme une variable globale. Ce qui veut dire qu’elle est visible par tout
sous-programme et que sa valeur peut être utilisée ou modifiée n’importe où.
La portée d’une variable globale est l’ensemble des sous-programmes
pouvant l’utiliser.

A remarquer que :

• La déclaration des variables globales dépend du langage de

programmation utilisé. Certains les définissent dans le programme
principal (programme d’appel aux Procédures/Fonctions) ; d’autres dans
une section spéciale.
• La notion de portée s’applique également aux constantes et aux types.
Exemple :
Dans la fonction Commission, plafond est une constante locale.

Fonctions de bibliothèque
On appelle fonctions de bibliothèque d’un langage donné, les fonctions
incorporées au compilateur du langage du fait de leur utilisation fréquente.
C’est la cas des fonctions : mod, sqrt, div, abs, int, cos, sin, etc.

Exemple :

Opérateur Fonction Exemple de code Résultat

/ Division Afficher 100/3 33
MOD Modulo Afficher 19 MOD 3
4
SQR Racine carré Afficher SQR(25) 5
^ Exposant Afficher 2 ^ 4 16

La plupart des langages proposent les fonctions suivantes, même si le nom et

la syntaxe peuvent varier d’un langage à l’autre :
• Len(chaîne) : renvoie le nombre de caractères d’une chaîne

45
 • Mid(chaîne,n1,n2) : renvoie un extrait de la chaîne, commençant au
caractère n1 et faisant n2 caractères de long.
Ce sont les deux seules fonctions de chaînes réellement indispensables.
Cependant, pour nous épargner des algorithmes fastidieux, les langages
proposent également :
• Left (chaîne,n) : renvoie les n caractères les plus à gauche dans
chaîne.
• Right (chaîne,n) : renvoie les n caractères les plus à droite dans chaîne
• Trouve (chaîne1,chaîne2) : renvoie un nombre correspondant à la
position de chaîne2 dans chaîne1. Si chaîne2 n’est pas comprise dans
chaîne1, la fonction renvoie zéro.

III.3 Mode de passage de paramètres

Un sous-algorithme avec paramètres est très utile parce qu’il permet de répéter
une série d’opérations complexes pour des valeurs qu’on ne connaît pas à
l’avance. Il existe deux types de passage de paramètres : par valeur et par
variable (dite aussi par référence ou encore par adresse).

III.3.1 Passage de paramètres par valeur

C’est le mode de transmission par défaut, il y a copie de la valeur, des

paramètres effectifs dans les variables locales issues des paramètres formels de
la procédure ou de la fonction appelée. Dans ce mode, le contenu des
paramètres effectifs ne peut pas être modifié par les instructions de la fonction
ou de la procédure ; car nous ne travaillons pas directement avec la variable,
mais sur une copie. À la fin de l’exécution du sous-algorithme la variable
conservera sa valeur initiale. Les paramètres dans ce cas sont utilisés comme
données.

Syntaxe :
Procédure nom_procédure (param1 :type1 ; param2, param3 :type2) ;
Fonction <nom_fonction> (param1 :type1 ; param2 :type2) : Type_fonction ;

Exemple :
Soit l’algorithme suivant.
Algorithme pas-val ;
Déclaration
M : entier ;
Procédure P1 (nombre : entier) ;

46
Début
Si nombre < 0 Alors
nombre nombre
FinSi ;
Ecrire (nombre)
Fin ;
Début
Lire (M) ;
P1 (M) ;
Ecrire (M)
Fin.

Exécutons cet algorithme pour la valeur ( )

Avant l’appel de procédure : la seule variable déclarée est la variable globale
(M).

M Ecran

Après l’appel de procédure : la variable-paramètre "nombre" est déclarée et

reçoit en copie la valeur de M.

M Nombre Ecran

Au retour à l’algorithme (au niveau de l’appel), il ne reste que la variable

globale avec sa valeur initiale.
M Ecran

III.3.2 Passage de paramètres par variable

Ici, il s’agit non plus d’utiliser simplement la valeur de la variable, mais

également son emplacement dans la mémoire (d’où l’expression ‘‘par
adresse’’). En fait, le paramètre formel se substitue au paramètre effectif
durant le temps d’exécution du sous-programme et à la sortie il lui transmet sa
47
nouvelle valeur. Un tel passage de paramètre se fait par l’utilisation du mot-clé
Var.

Syntaxe :
Procédure nom_procédure (Var param1 :type1, param2, param3 :type2) ;
Fonction <nom_fonction> (Var param1 : type1, param2 :type2) : Type_fonction
;

III.3.3 Remarque

Les paramètres passés par valeur et par adresse peuvent cohabiter à

l’intérieur d’un même sous-algorithme. Il suffit de partager les deux types de
passage par un (;).

Syntaxe :
Procédure nom_procédure (Var param1 :type1 ; param2, param3 :type2) ;
Dans ce cas param1 est passé par variable(ou par adresse ou par référence)
alors que les deux autres le sont par valeur.

Fonction <nom_fonction> (param1 :type1 ; Var param2 :type2) : Type_fonction

; Dans ce cas param1 est passé par valeur alors que le deuxième est passé
par variable.

Exemple :
Soit l’algorithme précédent modifié dans le type de passage de paramètre.
Algorithme pas-val ;
Déclaration
M : entier ;
Procédure P1 (nombre : entier) ;
Début
Si nombre < 0 Alors
nombre nombre
FinSi ;
Ecrire (nombre)
Fin ;
Début
Lire (M) ;
P1 (M) ;
Ecrire (M)
Fin.

Exécutons cet algorithme toujours pour la valeur ( )

48
Avant l’appel de procédure : la seule variable déclarée est la variable globale
(M).
M Ecran

Après l’appel de procédure : la variable-paramètre nombre se substitue à la

variable M.
Ecran
M

nombre

Exemple

Ecrire un algorithme qui calcule et affiche la valeur absolue d’une valeur en

utilisant une fonction.

Algorithme val_abs ;
Déclaration
a, b : Entier ;
Fonction abs (unEntier : Entier) : Entier ;
Déclaration
valeurAbsolue : Entier ;
Début
si unEntier ≥ 0 alors
valeurAbsolue unEntier
sinon
valeurAbsolue unEntier
finsi ;
abs valeurAbsolue
Fin ;
Début
Ecrire ('Entrez un entier : ') ;
Lire (a) ;
b abs (a) ;
Ecrire ('la valeur absolue de ', a, ' est ', b)
Fin.

Lors de l’exécution de la fonction abs, la variable a et le paramètre unEntier

sont associés par un passage de paramètre en entrée : La valeur de a est
copiée dans unEntier.

49
 Exercices

Exercice 1
Pour chacun des cas suivants donner un sous- programme qui permet de :
a) Saisir un caractère Majuscule.
b) Saisir une chaîne de caractère non vide et de longueur maximale égale à
20.
c) Vérifier est-ce qu’une chaîne de caractère donnée est alphabétique ou
non.
d) Remplir un tableau T par N entiers positifs croissant.
e) Afficher un tableau T de N éléments.
f) Compter l'occurrence (nombre d'apparition) d'un caractère dans une
chaîne.
g) Vérifier la présence d'un caractère dans une chaîne.
h) Déterminer le maximum d’un tableau.
i) Inverser une chaîne de caractère.
j) Inverser une chaîne de caractère.

Exercice 2
Soit l'Algorithme suivant :
Fonction Traitement (T : Tab ; N : Entier) : Entier
NB  0
Pour i de 1 à N faire
Si Non (majus (T [i]) dans ["A", "E", "O", "I", "U", "Y"]) alors
NB  NB + 1
Fin si
Fin Pour
Traitement  NB
Fin Traitement
1. Préciser le rôle de la fonction Traitement suite à l'exécution suivante :

T ‘’T’’ ‘’e’’ ‘’c’’ ‘’h’’ ‘’n’’ ‘’o’’ ‘’I’’ ‘’o’’ ‘’g’’ ‘’i’’ ‘’e’’
1 2 3 4 5 6 7 8 9 10 11

2. Transformer la fonction Traitement en une procédure

Exercice 3
Ecrire un programme permettant d’afficher tous les couples d’entiers (m,n)
vérifiant la propriété suivante :
m [1,100] et n[2,15]
Et m figure dans l’écriture du produit m.n
Exemples :
1. Si m=20 et n=6

50
 Alors le produit m.n = 120 contient le nombre ; dans ce cas
le couple (20,6) sera affiché.
2. Si m=20 et n=12
Alors le produit m.n = 20 * 12 = 240 ne contient pas le
nombre 20.

Exercice 4
Soit l'algorithme suivant :
Fonction Somme (p : entier) : entier
S 0
Pour i de 1 à (p div 2) faire
Si (p mod i = 0) Alors
S S+i
FinSi
Fin pour
Somme S
Fin Somme

1. Exécuter cet algorithme pour p=6 puis donner son rôle.

2. Transformer la fonction Somme en une procédure.

3. Ecrire un algorithme d'une procédure Saisie, permettant de saisir

deux entiers positifs non nuls.

4. En utilisant les deux modules Somme et saisie, écrire un

algorithme d'un programme intitulé Amis, qui permet de saisir
deux entiers positifs non nuls et d'afficher s'ils sont amis ou non.
Sachant que deux entiers m et n sont dits amis, si la somme des
diviseurs de n est égale à m et inversement.

Exercice 5
Un nombre est dit parfait s’il est égal à la somme de ces diviseurs (sauf lui
même).
Exemple : 6=3+2+1.
Ecrire un algorithme du programme intitulé parfait qui permet de saisir un
entier strictement positif puis il vérifie s’il est parfait.

Exercice 6
La « multiplication Russe » est une méthode particulière permettant la
multiplication de deux entiers A et B en utilisant seulement la multiplication par
2, la division par 2 et l’addition.

Exemple :

51
 Pour A =17 et B = 19, le produit de A par B se fait comme suit :
A B
17 19
Le premier nombre est divisé par 2 (division entière) et le deuxième est
multiplié par 2 : on aura
8 38
Le processus se répète jusqu’à avoir dans la première colonne 1 :
17 19
8 38
4 76
2 152
1 304
Le résultat est la somme des nombres de la deuxième colonne qui sont en
face des nombres impairs de la première colonne (donc les nombres de la
deuxième colonne qui sont en face des nombres pairs de la première colonne
seront ignorés).
 17 19
8 38 Ignoré
4 76 Ignoré
2 152 Ignoré
 1 304

17 * 19 = 19+304 = 323

On veut écrire un programme qui lit deux entiers positifs non

nuls et inférieur à 100, calcule et affiche le produit de deux
entiers par la méthode Russe.

Exercice 7
Ecrire un algorithme intitulé info qui permet de :

- Saisir la taille N d’un tableau T, avec (1<N<15).

- Remplir un tableau T par N chaînes des caractères tel que la taille
de chacune est dans [3..20].
- Chercher et afficher toutes les chaînes Totalogrammes contenues
dans T.
« Une chaîne de caractères est dite Totalogramme si elle commence et se
termine par la même lettre. » (Sans distinction entre majuscule et minuscule)

Exemple : Pour N=6 :

T
52
Samir Système temporairement Bonjour ses Elle

Les mots totalogrammes sont : temporairement, ses, elle

Exercice 8
Un texte est dit tautogramme si tous les mots commencent par la même lettre.
Exemple :
« Mazarin, ministre malade, méditait même moribond malicieusement mille
maltôtes »
On suppose que la phrase est écrite correctement. (Pas d’espace en double)
Ecrire un algorithme qui permet de vérifier si une chaîne de caractère saisie au
clavier est tautogramme ou non.

Exercice 9
Il est demandé d’écrire un algorithme qui demande à l’utilisateur d’entrer une
valeur entière positive appelée (Valeur) puis
a. qui indique à l’utilisateur si Valeur est un nombre à 2 chiffres,
b. qui affiche la factorielle de Valeur,
c. et qui saisit des valeurs au nombre de Valeur puis affiche la plus
grande valeur saisie.

53
CHAPITRE IV STRUCTURES DE DONNEES

En informatique, une structure de données est une manière d’organiser les

données dans un programme. On distingue plusieurs structures de données
parmi lesquelles les tableaux, les enregistrements, les fichiers, etc.
IV.1. Tableaux

Un tableau est une structure de données qui permet de conserver dans une
seule entité plusieurs valeurs de même type. Un tableau nous évite de
multiplier des variables lorsque les données sont nombreuses et de même
type.

IV.1.1. Tableaux linéaires

Un tableau linéaire (ou à une dimension) est une liste d’un nombre fini
d’éléments de même type, dont chacun est repéré par un indice unique. On
l’appelle vecteur en mathématiques.

Exemple :
Un tableau linéaire TEMP qui donne les températures moyennes de 12 mois de
l’année.

28 27 29 24 28 25 26 24 22 23 27 29

Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le
nom du tableau, suivi de l’indice de l’élément, entre parenthèses.
Exemple :
Note (4) = 24 (quatrième élément du tableau).

On peut créer des tableaux contenant des variables de tous types : tableaux
de numériques, tableaux de caractères, tableaux de booléens, etc.
Pour affecter une valeur dans un tableau, il faut préciser l’emplacement exact
dans ce tableau. Le rang de cet emplacement est appelé l’indice du tableau.

Les traitements courants sur les tableaux linéaires sont : le parcours du

tableau, la recherche de l’élément dans le tableau, la fusion de tableaux, la
mise à jour des informations dans un tableau (ajout, suppression, modification)
et le tri des informations dans un tableau.

A noter qu’il est obligatoire de déclarer un tableau avant son utilisation.

Exemple :
54
Déclarer Temp[n], où Temp est le nom du tableau et n est l’indice. -

IV.1.2 Tableaux dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre

d’éléments que devra comporter un tableau. Bien sûr, une solution consisterait
à déclarer un tableau gigantesque (10 000 éléments, pourquoi pas ?) pour être
sûr que « ça rentre ». Mais d’une part, on n’en sera jamais parfaitement sûr,
d’autre part, en raison de l’immensité de la place mémoire réservée et la
plupart du temps non utilisée, c’est un gâchis préjudiciable à la rapidité, voire à
la viabilité, de notre algorithme.

Aussi, pour parer à ce genre de situation, a-t-on la possibilité de déclarer le

tableau sans préciser au départ son nombre d’éléments. Ce n’est que dans un
second temps, au cours du programme, que l’on va fixer ce nombre via une
instruction de redimensionnement : Redim
.
A noter que tant qu’on n’a pas précisé le nombre d’éléments d’un tableau,
d’une manière ou d’une autre, ce tableau est inutilisable.

Exemple :

On veut faire saisir des notes pour un calcul de moyenne, mais on ne sait pas
combien il y aura de notes à saisir. Le début de l’algorithme sera quelque
chose du genre :

Tableau Notes () en Numérique

Variable nb en Numérique
Début
Ecrire "Combien y a-t-il de notes à saisir ?"
Lire nb
Redim Notes (nb-1)

IV.1.3 Quelques algorithmes de traitement courant sur les tableaux

1. Parcours d’un tableau

Tous les éléments d'un tableau possèdent le même type de données.

Évidemment, lorsque le type est Variant, chaque élément peut contenir
différents types de données (objets, chaînes, nombres, etc.). Vous pouvez
déclarer un tableau avec n'importe quel type de données fondamental, y
compris les types définis par l'utilisateur.

55
Un tableau doit être déclaré comme tel avant son utilisation, en précisant la
taille (intervalle de sa définition) et le type de valeurs qu’il contiendra. La
syntaxe retenue est :
Var Tableau NomTableau (taille du tableau) : type d’éléments
Dans notre exemple, nous créerons donc un tableau appelé Tab. Chaque note
individuelle (chaque élément du tableau Note) sera donc désignée Tab(0),
Tab(1), etc. La déclaration est : Var Tableau Tab(15) : réels.
Exemple
Les tableaux ont beaucoup d’avantage du fait que pour les traiter, on utilise
des boucles. Par exemple, pour effectuer notre calcul de moyenne, cela
donnera :
Début
Var Tableau Note(15) : réels
Var Moy, Som : réels
Pour i ← 1 à 15
Afficher "Entrez la note n°", i
Lire Note(i)
FinPour i
Som ← 0
Pour i ← 1 à 15
Som ← Som + Note(i)
Fin Pour i
Moy ← Som / 15
Afficher Moy
Fin

A noter qu’à la place de deux boucles ci haut, on aurait pu faire une seule
dans laquelle on aurait tout fait d’un seul coup.
Remarque générale : lors de parcours d’un tableau, l’indice sert à désigner
les éléments d’un tableau et doit être souvent un nombre en clair, mais il peut
être aussi une variable, ou une expression calculée. La valeur de cet indice
doit être égale au moins 1, doit être un nombre entier et doit nécessairement
être inférieure et égale au nombre d’élément du tableau

Définition des limites supérieure et inférieure

Quand vous déclarez un tableau, faites suivre son nom par la limite
supérieure entre parenthèses. La limite supérieure ne peut pas dépasser la
plage d'un type de données Long (-2 147 483 648 à 2 147 483 647). Par
exemple, ces déclarations de tableaux peuvent apparaître dans la section
Déclarations d'un module :

56
Declarer Counters(14) : Entiers ' 15 éléments.
Declarer Sums(20) : Réels ' 21 éléments.

3. La recherche dans un tableau

a. Recherche linéaire

Soit un tableau comportant, disons, 20 valeurs. L’on doit écrire un algorithme

saisissant un nombre au clavier, et qui informe l’utilisateur de la présence ou
de l’absence de la valeur saisie dans le tableau.

Tableau Tab(19) en Numérique

Variable N en Numérique
Début
Ecrire "Entrez la valeur à rechercher" ;
Lire N
Trouve ← Faux
Pour i ← 0 a 19
Si N = Tab(i) Alors
Trouve ← Vrai
FinSi
i suivant
Si Trouve Alors
Ecrire "N fait partie du tableau"
Sinon
Ecrire "N ne fait pas partie du tableau"
FinSi Fin

La difficulté est de comprendre que dans une recherche, le problème ne se

formule pas de la même manière selon qu'on le prend par un bout ou par un
autre. On peut résumer l'affaire ainsi : il suffit que N soit égal à une seule
valeur de Tab pour qu'elle fasse partie du tableau. En revanche, il faut qu'elle
soit différente de toutes les valeurs de Tab pour qu'elle n'en fasse pas partie.
Voilà la raison qui nous oblige à passer par une variable booléenne. Et cette
technique de flag (que nous pourrions élégamment surnommer « gestion
asymétrique de variable booléenne ») doit être mise en œuvre chaque fois que
l’on se trouve devant pareille situation.
Autrement dit, connaître ce type de raisonnement est indispensable, et savoir
le reproduire à bon escient ne l'est pas moins.

b. Recherche de l’élément maximum et de l’élément minimum dans

un tableau linéaire

Soit un tableau Temp contenant 12 températures dans un tableau de

57
single. Lorsqu’on veut chercher la température maximale et minimale dans ce
tableau de 12 températures, on procédera comme suit :
Recherche de l’élément maximal
On doit parcourir le tableau et de conserver la valeur maximale dans
une variable dite temporaire « TempMax ».
Au départ, on suppose que la température maximale est la première du
tableau.
Var TempMax : réel
TempMax = Temp (1)
Pour i ← 2 à 12
Si Temp (i) > TempMax alors TempMax ← Temp (i)
Fin Pour i
A la fin du processus, la variable TEMPMAX contiendra la valeur
recherchée.
Recherche de l’élément minimal
Pareillement que lors de la recherche de l’élément maximal, mais ici, il suffit de
conserver la valeur minimale dans une variable dite temporaire
« TempMin».
Au départ, on suppose que la température minimale est la première du
tableau.
Var TempMin : réel
TempMin = Temp (1)
Pour i ← 2 à 12
Si Temp (i) TempMin alors TempMin ← Temp (i)
Fin Pour i
A la fin du processus, la variable TEMPMin contiendra la valeur
recherchée.

c. Recherche dichotomique
La recherche dichotomique (en anglais : binary search) est un algorithme de
recherche efficace et rapide qui recherche la position d’un élément dans une
structure de données triée, en l’occurrence ici un tableau trié. .
Lorsqu’on veut rechercher la position d’un élément dans un tableau trié selon
l’ordre croissant des nombres entiers concernés dans ce tableau, on procède
à la recherche dichotomique. On peut aussi procéder à la recherche
séquentielle, mais cette méthode, pourtant facile à écrire et à mettre en œuvre,

58
n’est pas facile en termes de temps d’exécution, à moins que le tableau
parcouru soit très petit.
On développe ici la version dichotomique qui est la plus efficace en temps
d'exécution.

Principe : On effectue la comparaison de l'élément cherché par rapport à celui

qui se trouve au milieu du tableau. Si l'élément cherché est plus petit, on
continue la recherche dans la première moitié du tableau sinon dans la
seconde. On recommence ce processus sur la moitié. On s'arrête lorsqu'on a
trouvé ou lorsque l'intervalle de recherche est nul.
Exemple
Recherche dans le tableau d'entiers suivant défini sur l'intervalle [1..8] :
T 5 13 18 23 46 53 89 97

Recherche de 46 :
Etape 1 : comparaison de 46 avec t(4) (4=(8+1)÷2), t(4)<46 => recherche dans
[5..8]
Etape 2 : comparaison de 46 avec t(6), (6=(8+5)÷2), t(6)>46 => recherche
dans [5..5]
Etape 3 : comparaison de 46 avec t(5), t(5)=46 => élément cherché est trouvé
à l'indice 5
Recherche de 10 :
Etape 1 : comparaison de 10 avec t(4), t(4)>10 => recherche dans [1..3]
Etape 2 : comparaison de 10 avec t(2), t(2)>10 => recherche dans [1..1]
Etape 3 : comparaison de 10 avec t(1), t(1)<10 => recherche dans [2..1],
Borne inférieure devient supérieure à la borne supérieure, donc on met fin à
l'algorithme et l'élément cherché n'a pas été trouvé !
Voyons l'implémentation de cette fonction :
Fonction RechercheDicho(e : entier, n : entier, Tableau t(n) : entier):entier
Début
D←1
F←n
trouve ← faux
Tant que D <= F et non (trouve) faire
i ← (D + F) / 2
Si t[i] = e alors
trouve ← vrai sinon
si t[i] > e alors
F ← i -1
Sinon
D ← i +1
Fin si
59
Fin Si
Fin faire
Si trouve alors
indice ← i
sinon
indice ← -1
Fin Si
retourne indice
Fin

Légende :

- e désigne l’élément recherché

- n : taille du tableau
- t : tableau trié par ordre croissant
- D : début de la zone de recherche
- F : fin de la zone de recherche
- trouve : booléen, faux tant que l'élément cherché n'est pas trouvé
- i : indice de la case du milieu de la zone de recherche
- indice : indice de l'élément recherché ou -1 s'il n'est pas trouvé.

On peut illustrer l’intérêt de la recherche dichotomique par l’exemple suivant :

A et B jouent au jeu suivant : A choisit un nombre entre 1 et 20, et ne le
communique pas à B ; B doit trouver ce nombre en posant des questions à A
dont les réponses ne peuvent être que « Non, plus grand », « Non, plus petit »
ou « Oui, trouvé ». B doit essayer de poser le moins de questions possible.
Une stratégie pour B est d'essayer tous les nombres, mais il peut aller plus
rapidement comme le montre le scénario suivant :
A choisit 14 et attend les questions de B :

 B sait que le nombre est entre 1 et 20 ; au milieu se trouve 10 (ou 11),

B demande donc : « Est-ce que le nombre est 10 ? ». A répond « Non,
plus grand ».
 B sait maintenant que le nombre est entre 11 et 20 ; au milieu se
trouve 15 (ou 16), il demande donc : « Est-ce que le nombre est 15 ? »
A répond « Non, plus petit »
 Et ainsi de suite : « Est-ce 12 ? » (12 (11+14) ÷2), « Non, plus
grand », « Est-ce 13? » (13 = (13+14) ÷2), « Non, plus grand », « Est-
ce bien 14 ? », « Oui, trouvé »

B a trouvé le nombre choisi par A en seulement 5 questions

60
 3. Tri d’un tableau
Il existe plusieurs stratégies possibles pour trier les éléments d’un tableau ;
nous en verrons deux : le tri par sélection, et le tri à bulles.

a) Tri par sélection

Si l’on veut trier un tableau de 12 éléments dans l’ordre croissant, la technique

du tri par sélection est la suivante : on met en bonne position l’élément numéro
1, c’est-à-dire le plus petit. Puis on met en bonne position l’élément suivant. Et
ainsi de suite jusqu’au dernier. Par exemple, si l’on part de :

On commence par rechercher, parmi les 12 valeurs, quel est le plus petit
élément, et où il se trouve. On l’identifie en quatrième position (c’est le nombre
3), et on l’échange alors avec le premier élément (le nombre 45). Le tableau
devient ainsi :

On recommence à chercher le plus petit élément, mais cette fois, seulement à

partir du deuxième (puisque le premier est maintenant correct, on n’y touche
plus). On le trouve en troisième position (c’est le nombre 12). On échange
donc le deuxième avec le troisième :

On recommence à chercher le plus petit élément à partir du troisième (puisque

les deux premiers sont maintenant bien placés), et on le place correctement,
en l’échangeant, ce qui donnera:

Etc. jusqu’à l’avant dernier.

Nous pourrions décrire le processus de la manière suivante :
• Boucle principale : prenons comme point de départ le premier
élément, puis le second, etc. jusqu’à l’avant dernier.

61
 • Boucle secondaire : à partir de ce point de départ mouvant,
recherchons jusqu’à la fin du tableau quel et le plus petit élément.
Une fois que nous l’avons trouvé, nous l’échangeons avec le point de
départ. Cela s’écrit : boucle principale : le point de départ se décale à
chaque tour
Pour i ← 0 a 10
On considère provisoirement que t(i) est le plus petit élément
posmini ← i
on examine tous les éléments suivants
Pour j ← i + 1 a 11
Si t(j) < t(posmini) Alors
posmini ← j
Finsi
j suivant
A cet endroit, on sait maintenant où est le plus petit élément. Il ne reste plus
qu'a effectuer la permutation.
temp ← t(posmini)
t(posmini) ← t(i)
t(i) ← temp
On a placé correctement l'élément numéro i, on passe à présent au suivant.
i suivant

b) Tri à bulles

L’idée de départ du tri à bulles consiste à se dire qu’un tableau trié en ordre
croissant, c’est un tableau dans lequel tout élément est plus petit que celui qui
le suit.
En effet, prenons chaque élément d’un tableau, et comparons-le avec
l’élément qui le suit. Si l’ordre n’est pas bon, on permute ces deux éléments.
Et on recommence jusqu’à ce que l’on n’ait plus aucune permutation à
effectuer. Les éléments les plus grands « remontent » ainsi peu à peu vers les
dernières places, ce qui explique la charmante dénomination de « tri à bulle ».
En fait, tout ce qu’on peut dire, c’est qu’on devra effectuer le tri jusqu’à ce qu’il
n’y ait plus d’éléments qui soient mal classés.
Ceci est typiquement un cas de question « asymétrique » : il suffit que deux
éléments soient mal classés pour qu’un tableau ne soit pas trié. En revanche,
il faut que tous les éléments soient bien rangés pour que le tableau soit trié.
Nous utiliserons une variable booléenne Yapermute qui va nous indiquer si
nous venons ou non de procéder à une permutation au cours du dernier
balayage du tableau (dans le cas contraire, c’est signe que le tableau est trié,
et donc qu’on peut arrêter la machine à bulles). La boucle principale sera alors
:

Variable Yapermute en Booleen

62
Debut
…
TantQue Yapermute
…
FinTantQue
Fin

Que va-t-on faire à l’intérieur de la boucle ? Prendre les éléments du tableau,

du premier jusqu’à l’avant-dernier, et procéder à un échange si nécessaire.

Variable Yapermute en Booleen

Debut
…
TantQue Yapermute
Pour i ← 0 a 10
Si t(i) > t(i+1) Alors
temp ← t(i)
t(i) ← t(i+1)
t(i+1) ← temp
Finsi i suivant
Fin

Mais il ne faut pas oublier un détail capital : la gestion de la variable

booléenne. L’idée, c’est que cette variable va signaler le fait qu’il y a eu au
moins une permutation effectuée. Il faut donc :
• lui attribuer la valeur Vrai dès qu’une seule permutation a été faite (il
suffit qu’il y en ait eu une seule pour qu’on doive tout recommencer
encore une fois).
• la remettre à Faux à chaque tour de la boucle principale (quand on
recommence un nouveau tour général de bulles, il n’y a pas encore eu
d’éléments échangés),
• dernier point, il ne faut pas oublier de lancer la boucle principale, et pour
cela de donner la valeur Vrai a Yapermute tout au départ de
l’algorithme.

La solution complète donne donc :

Variable Yapermute en Booleen

Debut
…
Yapermut ← Vrai
TantQue Yapermut
Yapermut ← Faux
Pour i ← 0 a 10

63
Si t(i) > t(i+1) alors
temp ← t(i)
t(i) ← t(i+1)
t(i+1) ← temp
Yapermut ← Vrai
Finsi
i suivant
FinTantQue
Fin

4. Fusion de deux tableaux

Principe :

i. Si le tableau n'a qu'un élément, il est déjà trié.

ii. Sinon, séparer le tableau en deux parties à peu près égales.
iii. Trier récursivement les deux parties avec l'algorithme du tri
fusion
iv. Fusionner les deux tableaux triés en un seul tableau trié
Exemple
Soient S et T deux tableaux ayant respectivement m et n éléments. Nous
voulons fusionner S et T en un seul tableau trié F.
Voici l’algorithme de fusion :
Début
Lire T ;
Lire S ;
;
k ;
10 F(k) T(i) ;
;
← ;
Si alors aller à 10
Sinon ;
;
20 ;
;
← ;
64
 Si alors aller à 20
Sinon afficher F
Fin

5. Mise à jour
Nous parlerons ici de l’ajout et de la suppression d’un élément dans un
vecteur. Supposons que nous voulions insérer un élément dans un vecteur
A de taille n. Si les éléments de A ne sont pas ordonnés, il n’y a qu’à ajouter
à la fin du vecteur. Si B est le vecteur mise à jour déclaré avec une taille
supérieure à celle de A, la mise à jour se fait par des actions suivantes :
Pour i de 1 à n,
:
Fin Pour i.
Cependant , si le vecteur A est trié, il faut d’a bord trouver la position où
doit être inséré avant de le faire. C’est de nouveau un travail de recherche.
Une fois trouvé, on ne peut pas affecter à de peur d’écraser ,
par conséquent, il faut d’abord libérer la place en déplaçant la partie du
vecteur d’une position vers la droite. Appelons B le
vecteur mise à jour ; la taille de B sera taille(A)+1 en cas d’ajout et taille(A)-1
en cas de suppression.
L’ajout correspondant à l’action :
Pour i de n à p (déc 1)
Faire
Fin faire

Pour supprimer un élément , il suffit de déplacer les éléments

d’un rang vers la gauche si n’est pas le dernier
élément du vecteur, ce qui correspond à l’action :
Pour i de p+1 à n-1
Faire
Fin faire
A noter que si p=n, il suffit de mettre les éléments dans B, ce
qui correspond à l’action :
Pour i de 1 à n-1
Faire

65
Fin faire.

EXERCICES

Exercice 1
Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs
numériques en les mettant toutes à zéro.

Exercice 2
Ecrire un algorithme qui déclare et remplisse un tableau contenant les six
voyelles de l’alphabet français.

Exercice 3
Ecrire un algorithme qui déclare un tableau de 9 notes, dont on fait ensuite
saisir les valeurs par l’utilisateur.

Exercice 4
Que produit l’algorithme suivant ?
Tableau Nb(5) : Entier
Variable i : Entier
Début
Pour i ← 0 a 5
Nb(i) ← i * i
i suivant
Pour i ← 0 a 5
Ecrire Nb(i)
i suivant
Fin
Peut-on simplifier cet algorithme avec le même résultat ?

Exercice 5
Que produit l’algorithme suivant ?
Tableau N(6) : Entier
Variables i, k : Entier
Début
N(0) ← 1
Pour k ← 1 a 6
N(k) ← N(k-1) + 2
k Suivant
Pour i ← 0 a 6
Ecrire N(i)
i suivant
Fin

66
Exercice 6
Que produit l’algorithme suivant ?
Tableau Suite(7) : Entier
Variable i : Entier Debut
Suite(0) ← 1
Suite(1) ← 1
Pour i ← 2 a 7
Suite(i) ← Suite(i-1) + Suite(i-2)
i suivant
Pour i ← 0 a 7
Ecrire Suite(i)
i suivant
Fin

Exercice 7
Ecrivez un algorithme permettant à l’utilisateur de saisir un nombre
quelconque de valeurs, qui devront être stockées dans un tableau. L’utilisateur
doit donc commencer par entrer le nombre de valeurs qu’il compte saisir. Il
effectuera ensuite cette saisie. Enfin, une fois la saisie terminée, le programme
affichera le nombre de valeurs négatives et le nombre de valeurs positives.

Exercice 8
Ecrivez un algorithme calculant la somme des valeurs d’un tableau (on
suppose que le tableau a été préalablement saisi).

Exercice 9
Ecrivez un algorithme constituant un tableau, à partir de deux tableaux de
même longueur préalablement saisis. Le nouveau tableau sera la somme des
éléments des deux tableaux de départ.

Tableau 1 :

Tableau 2 :

Tableau à constituer :

67
Exercice 10
Ecrivez un algorithme qui permette de saisir un nombre quelconque de
valeurs, et qui les range au fur et à mesure dans un tableau. Le programme,
une fois la saisie terminée, doit dire si les éléments du tableau sont tous
consécutifs ou non. Par exemple, si le tableau est :

ses éléments sont tous consécutifs. En revanche, si le tableau est :

ses éléments ne sont pas tous consécutifs.

Exercice 11
Ecrivez un algorithme qui trie un tableau dans l’ordre décroissant.
Vous écrirez bien entendu deux versions de cet algorithme, l'une employant le
tri par insertion, l'autre le tri à bulles.

Exercice 12
Ecrivez un algorithme qui inverse l’ordre des éléments d’un tableau dont on
suppose qu'il a été préalablement saisi (« les premiers seront les derniers… »)

Exercice 13
Ecrivez un algorithme qui permette à l’utilisateur de supprimer une valeur d’un
tableau préalablement saisi. L’utilisateur donnera l’indice de la valeur qu’il
souhaite supprimer. Attention, il ne s’agit pas de remettre une valeur à zéro,
mais bel et bien de la supprimer du tableau lui-même! Si le tableau de départ
était :

Et que l’utilisateur souhaite supprimer la valeur d’indice 4, le nouveau tableau

sera :

68
Exercice 14
Ecrivez l'algorithme qui recherche un mot saisi au clavier dans un dictionnaire.
Le dictionnaire est supposé être codé dans un tableau préalablement rempli et
trié.

IV.1.4 Tableaux multidimensionnels

Un tableau multidimensionnel est un tableau dont les éléments sont

respectivement repérés par deux ou trois indices (voire plus) ; c'est-à-dire un
tableau à plusieurs dimensions et il utilise souvent des boucles imbriquées lors
de sa mise en place. Et chaque niveau des boucles correspond au parcours
selon une dimension.

Un tableau multidimensionnel doit être déclaré comme tel également avant

son utilisation, en précisant la taille (intervalle de définition selon chaque
dimension) et le type de valeurs qu’il contiendra. La syntaxe retenue est :
Var Tableau NomTableau (taille du tableau) : type d’éléments

La programmation autorise à déclarer des tableaux de dimensions multiples.

Par exemple, l'instruction suivante déclare un tableau bidimensionnel de 10
sur 10 à l'intérieur d'une procédure :

Tableau MatrixA (9, 9) : Réels

Vous pouvez déclarer l'une et/ou l'autre de ces deux dimensions avec des
limites inférieures explicites :

Tableau MatrixB (1 à 10, 1 à 10) : Réels

Vous pouvez étendre cela à plus de deux dimensions. Par exemple :

Déclarer MultiD (3, 1 à 10, 1 à 15)

Cette déclaration crée un tableau en trois dimensions de 4 sur 10 sur 15. Le

nombre total d'éléments est le produit de ces trois dimensions, soit 600.

1. Manipulation de tableaux à l'aide de boucles

Vous pouvez traiter efficacement un tableau multidimensionnel à l'aide de

boucles imbriquées. Les instructions suivantes, par exemple, initialisent
chaque élément de MatrixA à l'aide d'une valeur basée sur sa position dans le
tableau :

Déclarer I, J: Entiers
MatrixA (1 à 10, 1 à 10) : Réels

69
Pour I = 1 à 10
Pour J = 1 à 10
MatrixA (I, J) = I * 10 + J
Next J
FinPour I

2. Tableaux à deux dimensions

Un tableau A à deux dimensions m x n est un ensemble de m.n éléments

d’informations tels que chacun d’entre eux est spécifié par une paire d’entiers
(tels que J,K), appelés indices et possédant la propriété 1 J m et 1 K n.
L’élément de A dont le premier indice est j et le second, k sera noté Aj,k ou
A[J,K].
Les tableaux à deux dimensions sont appelés matrices et sont faciles à
représenter comme une grille ayant un certain nombre de lignes (première
dimension) et un certain nombre de colonnes (seconde dimension).
Considérons une matrice (tableau) M avec 6 colonnes et 4 lignes dont :

56 54 1 - 56 20 22

72 8 54 34 43 2

70 5 16 78 90

56 23 - 47 0 12

Pour accéder à un élément du tableau, il suffit de préciser entre parenthèses

l’indice de la case contenant cet élément, et ce pour chacune des dimensions.
Par exemple, pour accéder à l'élément 23 du tableau d'entiers ci-dessus, on
écrit : M (4,2). L'instruction suivante affecte à la variable x la valeur du premier
élément du tableau, c'est à dire 56.
x ← M (1,1)
L'élément désigné du tableau peut alors être utilisé comme n'importe quelle
variable :

M (2,1) ← - 56
Cette instruction modifie le contenu de la case (2,1) du tableau M. (72 en – 56)

Exemple
L’algorithme qui calcule la somme des éléments dans ce tableau
70
 Début
Var Somme : réel
Var Tableau m() : réels
Var li, co : entiers
Afficher "Combien y a-t-il de lignes à saisir ?" Lire
li
Afficher "Combien y a-t-il de colonnes à saisir ?"
Lire co
Redim m (li, co)
Pour i de 1 à li : Pour j de 1 à co : Lire m (i, j) : Fin pour j : Fin pour i
Somme ← 0
Pour i de 1 à li : Pour j de 1 à co : Somme ← Somme + m(i,j) : Fin pour j
Fin pour i
Afficher Somme
Fin

IV.2. Autres structures de données

Dans cette section, on se contentera de donner une liste (non exhaustive)

d’autres structures de données à part les tableaux. On a :

A Les listes

Une liste est un ensemble d’objets de même type constituant les

éléments de la liste. Les éléments sont chaînés entre eux et on peut
facilement ajouter ou extraire un ou plusieurs éléments. Une liste simple
est une structure de données telle que chaque élément contient :

• des informations caractéristiques de l’application (les caractéristiques

d’une personne par exemple),

• un pointeur vers un autre élément ou une marque de fin s’il n’y a pas

d’élément successeur.

B Les arbres

Un arbre est une structure de données composée d’un ensemble de

nœuds. Chaque nœud contient l’information spécifique de l’application
et des pointeurs vers d’autres nœuds (d’autres sous-arbres).

Il existe un nœud au niveau 1 qui n’est pointé par aucun autre nœud :
c’est la racine de l’arbre

71
 C Les graphes

Un graphe est une structure de données composée d’un ensemble de

sommets , et d’un ensemble de relations entre ces sommets

Si la relation n’est pas orientée, la relation est supposée exister dans

les deux sens. Le graphe est dit non orienté ou symétrique. Dans le cas
contraire, si les relations sont orientées, le graphe est dit orienté.
Une relation est appelée un arc (quelquefois une arête pour les
graphes non orientés). Les sommets sont aussi appelés nœuds ou
points.

A noter que toutes les structures de données citées dans cette section feront
l’objet d’un deuxième cours d’algorithmique dans la suite de votre parcours.
Elles seront traitées en détails dans ce cadre.

72
 REFERENCES

[ ] B. AMADE, Introduction à la programmation, Micro Application, MA

éditions, Paris, 2019.

[ ] M. DIVAY, Algorithmes et Structures de données génériques, Dunod,

Paris, 2004.

[ ] G. KOMAWILA, Logique de programmation, notes de cours, Ecole

supérieure de formation des cadres (ESFORCA), Kinshasa, 2003.

[ ] G. KOMAWILA, Algorithmique I, notes de cours, Université Franco

Américaine (UFA), Kinshasa, 2013.

[ ] G. KOMAWILA, Algorithmique et Langage C, Université Libre de

Kinshasa (ULK), 2017.

[ ] D. MANIEZ, Apprendre à programmer en 10 semaines chrono, Dunod,

Paris, 2019.

73
 TABLE DES MATIERES

CHAPITRE I. ALGORITHMES ET PROGRAMMATION .......................................................................................... 1

1.1. ALGORITHMES ........................................................................................................................................................ 1
1.2. PROGRAMMATION .................................................................................................................................................. 2
CHAPITRE II. STRUCTURES DE CONTROLE ET ORDINOGRAMMES ............................................................ 23
II.1. STRUCTURES DE CONTROLE ................................................................................................................................... 23
II.2. ORDINOGRAMMES ET LEURS LANGAGES ................................................................................................................. 37
CHAPITRE III. SOUS-PROGRAMMES ................................................................................................................... 41
III.1 PROCEDURES ET FONCTIONS ................................................................................................................................. 41
III.2 VARIABLES LOCALES ET GLOBALES ........................................................................................................................ 44
III.3 MODE DE PASSAGE DE PARAMETRES ..................................................................................................................... 46
CHAPITRE IV STRUCTURES DE DONNEES ....................................................................................................... 54
IV.1. TABLEAUX ............................................................................................................................................................... 54
IV.2. AUTRES STRUCTURES DE DONNEES ...................................................................................................................... 71
REFERENCES ............................................................................................................................................................ 73
TABLE DES MATIERES ............................................................................................................................................ 74

74