INITIATION_ALGO_NAB_2006

SOMMAIRE
AVERTISEMENT..................................................................................................................................4
AVANT PROPOS .................................................................................................................................4
I. GÉNÉRALITÉS...................................................................................................................................5
I.1. algorithmique.................................................................................................................................5
I.2. algorithme .....................................................................................................................................5
I.3. Notion d’analyse descendante.......................................................................................................5
I.4. Rôle et intérêt de l’algorithme......................................................................................................6
I.5. La programmatique........................................................................................................................6
I.6. programmation...............................................................................................................................6
I.7. Architecture d’un algorithme........................................................................................................7
II. NOTION D’OBJET..........................................................................................................................10
II.1. Caractéristiques..........................................................................................................................10
II.2. constante.....................................................................................................................................10
II.3. Variable .....................................................................................................................................11
II.4. Les types.....................................................................................................................................11
III. ACTIONS .......................................................................................................................................13
III.1. Instructions................................................................................................................................13
III.2. Opérateurs.................................................................................................................................14
III.3. Exercice d’application .............................................................................................................15
IV. STRUCTURES DE CONTRÔLE...................................................................................................17
IV.1. les structure de choix................................................................................................................17
IV.2. Les structures répétitives ou boucles........................................................................................20
V. LES SOUS-PROGRAMMES...........................................................................................................22
V.1. Les procédures...........................................................................................................................22
V.2. Fonctions....................................................................................................................................24
V.3. différences entre fonctions et procédures...................................................................................25
V.4. Imbrication de sous programmes...............................................................................................25
25
VI. NOTION DE RÉCURSIVITÉ.........................................................................................................26
VI.1. Définition..................................................................................................................................26
VI.2. Types de récursivité..................................................................................................................26
VI.3. Construction..............................................................................................................................26
VII. LES STRUCTURES DE DONNEES STATIQUES.....................................................................28
VII.1. Les chaînes de caractères.........................................................................................................28
VII.2. Le type énuméré......................................................................................................................30
VII.3. Le type intervalle.....................................................................................................................31
VII.4. type ENSEMBLE....................................................................................................................33
VII.5. Type TABLEAU.....................................................................................................................35
VII.6. type ENREGISTREMENT.....................................................................................................38
VIII. LES FICHIERS.............................................................................................................................43
VIII.1. Définition...............................................................................................................................43
VIII.2. Caractéristiques d’un fichier..................................................................................................44
VIII.3. mode d'accès..........................................................................................................................44
VIII.4. Déclaration.............................................................................................................................44
VIII.5. Instructions sur les fichiers.....................................................................................................45
IX. LES STRUCTURES DE DONNEES DYNAMIQUES..................................................................47
Introduction.......................................................................................................................................47
IX.1. Notion d’adresse en mémoire...................................................................................................47
IX.2. Définition d’un pointeur ..........................................................................................................47
IX.3. utilité.........................................................................................................................................48
Algorithmique --- Cours réalisé par Nabeledi Ingénieur Informaticien Développeur Web ---- 1ère
Edition - 2 -

IX.4. Les différents types de pointeurs..............................................................................................48
IX.5. L’affectation à un pointeur.......................................................................................................48
IX.6. Les différentes opérations sur un pointeur................................................................................50
IX.7. Les procédures de construction de structures de données dynamiques ...................................50
IX.8. Exercice d’application..............................................................................................................54
IX.9. remarques..................................................................................................................................55
IX.10. Domaines d’application des pointeurs....................................................................................55
X. LES LISTES CHAINEES.................................................................................................................56
X.1. Définition...................................................................................................................................56
X.2. création d’une liste chaînée .......................................................................................................56
X.3. Les différentes opérations sur les listes chaînées.......................................................................57
X.4. Les piles.....................................................................................................................................58
X.5. Les files......................................................................................................................................59
X.6. Les listes doublement chaînées..................................................................................................59
XI. INTRODUCTION AUX ARBRES.................................................................................................61
XI.1. Introduction...............................................................................................................................61
XI.2. Définitions................................................................................................................................61
XI.3. Arbre localement complet, dégénéré, complet.........................................................................66
XI.4. Implémentation.........................................................................................................................67
XI.5. signature....................................................................................................................................68
XI.6. Les fonctions de base sur la manipulation des arbres...............................................................68
XI.7. Algorithmes de base sur les arbres binaires..............................................................................69
XI.8. Parcours d'un arbre...................................................................................................................71
XI.9. Opérations élémentaires sur un arbre........................................................................................76
Edition - 3 -

AVERTISEMENT
Cet ouvrage s’adresse aux étudiants des filières technologiques et à tous ceux qui sont
passionnés de la programmation informatique.
Pour toutes vos remarques et suggestion contactez
nabeledi@yahoo.fr
AVANT PROPOS
Ceux qui auront des notions poussées en programmation et donc en algorithmique
gouverneront le monde des TICs. C’est pour nous y aider que cette première édition a vu le
jour.
Une simple lecture ne pourra pas suffire.
Votre détermination et assiduité feront de vous un chevronné.
En attendant la future édition complète intégrant des exercices, bon apprentissage à tous.
INTRODUCTION
Avez-vous déjà ouvert un livre de recettes de cuisine ? Avez-vous déjà déchiffré un mode
d’emploi traduit directement du coréen pour faire fonctionner un magnétoscope ou un
répondeur téléphonique réticent ? Si oui, sans le savoir, vous avez déjà exécuté des
algorithmes.
Plus fort : avez-vous déjà indiqué un chemin à un touriste égaré ? Avez-vous fait chercher
un objet à quelqu’un par téléphone ? Ecrit une lettre anonyme stipulant comment procéder à
une remise de rançon ? Si oui, vous avez déjà fabriqué – et fait exécuter – des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique réservé à quelques rares initiés
touchés par la grâce divine, mais une aptitude partagée par la totalité de l’humanité. Donc,
pas d’excuses…
Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement, conduit à
un résultat donné. Si l’algorithme est juste, le résultat est le résultat voulu, et le touriste se
retrouve là où il voulait aller. Si l’algorithme est faux, le résultat est, disons, aléatoire, et
décidément, cette saloperie de répondeur ne veut rien savoir.
Complétons toutefois cette définition. Après tout, en effet, si l’algorithme, comme on vient de
le dire, n’est qu’une suite d’instructions menant celui qui l’exécute à résoudre un problème,
pourquoi ne pas donner comme instruction unique : « résous le problème », et laisser
l’interlocuteur se débrouiller avec ça ? A ce tarif, n’importe qui serait champion
d’algorithmique sans faire aucun effort. Pas de ça, ce serait trop facile.
Le malheur (ou le bonheur, tout dépend du point de vue) est que justement, si le touriste
vous demande son chemin, c’est qu’il ne le connaît pas. Donc, si on n’est pas un goujat
intégral, il ne sert à rien de lui dire de le trouver tout seul. De même les modes d’emploi
contiennent généralement (mais pas toujours) un peu plus d’informations que « débrouillez
vous pour que ça marche ».
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions
compréhensibles par celui qui devra l’exécuter. C’est d’ailleurs l’un des points délicats pour
les rédacteurs de modes d’emploi : les références culturelles, ou lexicales, des utilisateurs,
étant variables, un même mode d’emploi peut être très clair pour certains et parfaitement
abscons (obscurs) pour d’autres.
En informatique, heureusement, il n’y a pas ce problème : les choses auxquelles on doit
donner des instructions sont les ordinateurs, et ceux-ci ont le bon goût d’être tous
strictement aussi idiots les uns que les autres.
Edition - 4 -

I. GÉNÉRALITÉS
I.1. algorithmique
On appelle algorithmique la science de l’informatique qui s’appesantit sur les méthodes qui
permettent de construire des algorithmes. C’est la discipline qui permet d’édicter les règles,
d’élaborer les méthodes à observer pour concevoir un algorithme.
De ce fait l’algorithmique se penche sur :
 la clarté
 la lisibilité
 le caractère non ambigu de l’algorithme.
I.2. algorithme
Le terme ALGORITHME vient du mathématicien arabe MUHAMMAD IBN MUSA AL
KHAREZMI (fin VIIIè siècle, début IX siècle) qui rédigea un traité exhaustif sur le système de
chiffres et de numérotation hindou.
Par la suite l’utilisation des chiffres et des modes de calcul hindou fut connue sous le nom
d’ALGORISMI.
Selon Le Petit Robert, Nouvelle édition revue de 1986, c’est l’ensemble des règles
opératoires propres à un calcul ; c’est aussi l’enchaînement des actions nécessaires à
l’accomplissement d’une tâche.
On dirait encore qu’un algorithme est la description précise et rigoureuse d’une suite
d’opérations permettant d’obtenir la solution d’un problème en un nombre fini d’étapes.
I.3. Notion d’analyse descendante
Soit T un travail décrit par un énoncé non primitif. On peut analyser et découper T en
plusieurs sous travaux, ti (avec 1 ≤ i ≤ n).
Puis, chaque t i peut être aussi analysé et découpé en sous travaux : ti k où
tik [1,2 ;… ;m ] et m est le nombre de sous travaux issus de ti
Une telle analyse qui consiste à décomposer les problèmes en sous problèmes pouvant se
résoudre est appelée : analyse descendante
En amont de toute programmation se trouve nécessairement un problème. En fait, c’est
l’idée de résoudre le problème en utilisant l’ordinateur qui amène la programmation. Pour
mieux appréhender un problème à résoudre, il y a des étapes à franchir.
L’analyse d’un problème consiste donc à :
- énoncer le problème,
- le poser,
- en décrire le cheminement pour sa résolution.
I.3.1. Enonciation du problème
Elle consiste à répertorier :
− toutes les données
− les situations initiales et aussi
− les résultats.
C’est donc comprendre clairement le problème à résoudre. Il faut donc pouvoir répondre aux
trois questions suivantes :
− De quoi est-il question dans le problème ?
Edition - 5 -

− Quels sont les éléments contenus dans le problème qui le prouvent et à utiliser pour
sa résolution ?
− Quelle est la finalité du problème ?
I.3.2. Poser le problème
C’est décrire les grandes lignes de la résolution du problème posé, c'est-à-dire passer des
données aux résultats tout en respectant les hypothèses de travail.
En d’autres termes dégager les grandes lignes de la résolution du problème.
I.3.3. Le cheminement
Il s’agit de décrire de façon détaillée et non ambigue, les différentes étapes pour passer des
données aux résultats tout en respectant les hypothèses de travail.
C’est le lieu de résolution du problème posé.
Ces différentes étapes doivent être exprimées dans un langage naturel (anglais, français,
arabe…) mais non intelligible à l’ordinateur. On l’appelle : ALGORITHME.
I.4. Rôle et intérêt de l’algorithme
o Dans le domaine de la programmation, l’algorithme a un rôle fondamental. En réalité,
il n’y pas de programme sans algorithme.
(Le programme étant la traduction de l’algorithme dans un langage compréhensible par
l’ordinateur : langage de programmation).
o L’algorithme est indépendant à la fois de l’ordinateur qui l’exécute (à travers les
programmes) et des langages de programmation dans lesquels il est énoncé et traduit. Cela
signifie que lorsque vous écrivez votre algorithme, vous ne deviez pas vous soucier du
langage dans lequel celui-ci sera traduit et de l’ordinateur sur lequel ce dernier sera traduit
et exécuté .En d’autres termes nous dirons que :
il n’y a pas d’algorithme spécialement écrit pour tel ou tel langage et
il n’y a pas d’algorithme spécialement écrit pour tel ou tel ordinateur.
I.5. La programmatique
C’est l’art de programmer et de permettre la réalisation de bons programmes c’est-à-dire
des programmes qui tournent, qui s’exécutent sans problème et qui respectent les critères
suivants :
1. L’absence d’erreur
2. Conformité aux spécifications données
3. Efficacité de fonctionnement du programme
4. La robustesse (aptitude à bien réagir lorsqu’on s’écarte des conditions normales
d’utilisation c’est-à-dire lors de l’acquisition des données, veuillez à ce que les données
saisies soient conformes aux spécifications du problème, (Ex : lors de la saisie de l’âge des
personnes, il faut s’assurer que la valeur saisie par l’utilisateur ne soit pas négative).
5. L’efficience : Minimiser le temps d’exécution du programme et aussi l’espace occupé en
mémoire centrale.
I.6. programmation
Un programme est un assemblage et un enchaînement d’instructions élémentaires écrit
dans un langage de programmation, et exécuté par un ordinateur afin de traiter les données
d’un problème et renvoyer un ou plusieurs résultats.
Il y a trois (trois) types de langages qui ont été connus dans l’histoire des langages.
Edition - 6 -

- Le langage machine ;
- Le langage assembleur
- Les langages évolués.
I.6.1. Le langage machine
C’est le seul langage directement intelligible à l’ordinateur. On l’appelle encore langage
binaire.
En effet toutes les tâches à réaliser sont communiquées à l’ordinateur sous forme de
combinaisons de bits : (une suite de 0 et de 1).
I.6.2. Le langage assembleur
Langage plus évolué que le langage machine, il reste toujours difficile pour l’homme (en
décimal ou hexadécimal)
I.6.3. Le langage évolué
Langage de programmation ou de développement plus au moins proche du langage
humain.
Exemple : Pascal…
Un langage de programmation est défini par des règles d'écriture des règles de construction
que doivent respecter les programmes. La difficulté, pour le programmeur, consiste à
respecter ses règles imposées.
I.7. Architecture d’un algorithme
Historiquement, plusieurs types de notations ont représenté les algorithmes.
I.7.1. Organigramme
Représentation de l’algorithme sous forme graphique avec des carrés, des losanges, des
rectangles etc.
Edition - 7 -
Début ou Fin de l’Organigramme
ENTREE ou SORTIE
Instructions : traitement d’une ou plusieurs opérations sur des
données
Branchement conditionnel

Aujourd’hui, cette représentation est quasiment abandonnée, parce que dès que l’algorithme
commence à grossir un peu, elle n’est plus pratique du tout.
I.7.2. Pseudo code ou langage de description algorithmique
Une série de conventions, qui ressemble à un langage de programmation authentique dont
on aurait évacué la plupart des problèmes de syntaxe. Ce pseudo-code est susceptible de
varier légèrement d’un livre (ou d’un enseignant) à un autre. C’est bien normal : le pseudo-
code, encore une fois, est purement conventionnel ; aucune machine n’est censée le
reconnaître. Donc, chaque cuisinier peut faire sa sauce à sa guise, avec ses petites épices
bien à lui, sans que cela prête à conséquence.
Comme je n’ai pas moins de petites manies que la majorité de mes semblables, les pseudo-
codes que vous découvrirez dans les pages qui suivent possède quelques spécificités
mineures dues à mes névroses personnelles.
Rassurez-vous cependant, celles-ci restent dans les limites tout à fait acceptables.
En tout cas, personnellement, je les accepte très bien.
La construction de la structure syntaxique d’un algorithme est gouvernée par un certain
nombre de règles qu’il faut connaître
Ainsi un algorithme est structurellement subdivisé en trois parties dont l’ordre immuable est
suivant :
− l’en-tête, ensuite
− la partie déclarative et enfin
− le corps de l’algorithme.
1. L’en-tête
On l’appelle encore nom de l’algorithme car c’est le nom que l’on donne à l’algorithme. Il est
obligatoire c’est-à-dire que tout algorithme doit nécessairement avoir un nom.
Ce nom est au choix mais doit être soumis à un certain nombre de principes (comme les
noms de variables).
2. La partie déclarative
C’est dans cette partie que l’on déclare :
− les constantes
− les variables
− les structures de données
− les fonctions
− les procédures.
Cette partie dépend de la nature du problème et des besoins de l’utilisateur. Elle est donc
facultative.
Edition - 8 -
Impression

Ainsi, si la résolution d’un problème donné nécessite l’utilisation d’une variable alors, l’on
déclarera une variable. Autrement une variable ne sera pas déclarée. Il en va de même pour
les autres (constantes, structures de données…).
3. Le corps de l’algorithme
Il est obligatoire. Il débute par le mot clé DEBUT et se termine par le mot clé FIN.
(instructions d’encadrement)
C’est dans cette partie que l’on effectue les différentes actions nécessaires pour la
résolution du problème, bien sûr en utilisant les éléments déclarés éventuellement dans la
partie déclarative.
4. Schéma de la structure syntaxique d’un algorithme
ALGORITHME nom algorithme } En-tête
-------------------------------
------------------------------- Partie déclarative
-------------------------------
__________________________________________
DEBUT Instruction d’encadrement
__________________________________________
Instruction1
Corps de l’algorithme
Instruction n
__________________________________________
FIN. Instruction d’encadrement
__________________________________________
NB : Une instruction est une action élémentaire que l’on effectue en vue de la résolution
d’un problème, dans le cadre de la construction d’un algorithme.
I.7.3. trace d'un algorithme
La trace d'un algorithme représente la valeur des différentes informations d'un programme
durant son exécution. Il est vivement conseillé d'effectuer la trace d'un algorithme afin de
vérifier qu'il fonctionne.
La première chose à faire est de choisir des données sur lesquelles ont va effectuer le test
de l'algorithme. Pour ces données, on calcule à la main le résultat attendu. Puis on effectue
la trace et on compare le résultat attendu avec le résultat de la trace qui doivent être les
mêmes (sinon, il y a une erreur quelque part…)
Edition - 9 -

II. NOTION D’OBJET
II.1. Caractéristiques
Un objet est une donnée qui intervient dans l’environnement d’un problème (l’environnement
d’un problème est l’ensemble des éléments nécessaires à la résolution du problème).
Un objet est parfaitement défini si nous connaissons ces trois caractéristiques suivantes :
II.1.1. Son identificateur ou son nom
C’est le nom donné à l’objet par le programmeur. Il est représenté par une suite de
caractères alphanumériques (des nombres et des lettres alphabétiques sans espacement)
commençant obligatoirement par une lettre de préférence.
Il est choisi par rapport au contenu de l’objet.
Exemples
Note, age, CodeEtudiant, San_pedro
Remarque
Un identificateur ne doit pas contenir d’espace et de caractères accentués
Eviter les mots réservés
Faux Vrai Sortir Autre
Boucle Tant que Caractère Booléen
Entier Réel Lire Etre
Type Vaut Sinon Non
Début Retourner Enregistrement Ou
Fin Cas Pour Quitter
Répéter Jusqu'à Tableau Programme
Fonction Alors Ecrire Procédure
Si Nil Vide Dag
Ensemble De Constant Chaîne
Div Mod Dad Xou
II.1.2. Sa valeur
C’est ce que vaut l’objet à un instant donné. On parle aussi de son contenu.
II.1.3. Son type
C’est l’intervalle des différentes valeurs que l’objet peut prendre. Ainsi suivant le type qu’on
va lui attribuer, l’objet pourra prendre telles valeurs ou non.
Le type d’une variable détermine les valeurs qu’elle peut prendre, les opérations dont elle
peut faire l’objet et son encombrement mémoire.
II.2. constante
II.2.1. Définition d’une constante
C’est un objet dont la valeur ou contenu ne change pas au cours du traitement, durant
l’exécution du programme, d’où le terme de « constante »
II.2.2. Sa déclaration
Elle est précédée par le mot-clé CONST.
Edition - 10 -

CONST
Nom-de-la-constante = valeur
NB
Une constante a 2 attributs :
Son identificateur ou nom
Sa valeur (son contenu)
Exemple
L’objet masse atomique de l’oxygène est une constante à laquelle on associe l’identificateur
MO2 de valeur 16.
II.3. Variable
II.3.1. Définition d’une variable
Une variable est un objet dont la valeur ou contenu est susceptible de varier durant
l’exécution du programme d’où le terme de variable
II.3.2. Sa déclaration
Elle est précédée par le mot-clé VAR
VAR
Nom_de_la_variable : type- de- la- variable
Exemple
VAR
Val : ENTIER
a : REEL
NB. Une déclaration de variables consiste en une liste d’identificateurs désignant les variables et le
type auquel chacune d’elles est associée
II.4. Les types
On distingue deux principaux types de variables : les types scalaires ou types simples et les
types structurés.
II.4.1. Types scalaires
Ce sont les types dits simples car à un instant donné une variable de ce type contient une et
une seule valeur
a. Le type entier
Ce sont les entiers relatifs
Au niveau du langage pascal un type entier a une plage de -32768 à +32767
2. Le type réel
Ce sont les nombres réels
Ici c’est en informatique c’est un intervalle borné
Edition - 11 -

Dans la plus part des langages on a :
Réel simple -3,40x1038 à -1,40x1045 pour les valeurs négatives 1,40x10-45 à 3,40x1038
pour les valeurs positives
Réel double -1,79x10308 à -4,94x10-324 pour les valeurs négatives 4,94x10-324 à
1,79x10308 pour les valeurs positives
3. Le type caractère
Ce sont les 256 symboles du code ASCII et chaque symbole est représenté entre cotes
Exemple
‘’A’’ , ‘’p’’ ,’’1’’
4. Le type chaîne de caractères
Ce type de variable est construit à partir de plusieurs caractères
Exemple
chaine= ‘’une chaîne qui contient plusieurs caractères ’’
5. Le Type booléen
Le dernier type est le type booléen : on y stocke uniquement les valeurs logiques VRAI et
FAUX.
On peut représenter ces notions abstraites de VRAI et de FAUX par tout ce qu'on veut : de
l'anglais (TRUE et FALSE) ou des nombres (0 et 1). Peu importe. Ce qui compte, c'est de
comprendre que le type booléen est très économique en termes de place mémoire occupée,
puisque pour stocker une telle information binaire, un seul bit suffit.
Remarque
Tous ces types scalaires cités sont des types prédéfinis dans la plupart des langages (le
programmeur ne fait qu’en servir)
II.4.2. Types structurés
Ce sont des types bâtis par le programmeur à partir des types simples. Ils correspondent à
des variables qui à un instant donné contiennent plusieurs valeurs.
− Type tableau
− Type chaîne de caractères
− Type enregistrement
− Type ensemble
− Type intervalle
− Type énuméré
− Type fichier
− Type pointeur
− liste chainée
− arbre
Edition - 12 -

III. ACTIONS
III.1. Instructions
III.1.1.Définition
Une action est une directive ou un événement qui modifie l’environnement de résolution d’un
problème.
On peut exécuter une action plusieurs fois.
Une instruction est une action élémentaire.
III.1.2.L’instruction d’affectation : 
C’est l’opération qui consiste à attribuer une valeur à un objet donné.
Syntaxe
Nom _objet  valeur
Nom _objet  expression
Nom _objet1 nom_ objet2
III.1.3.Les instructions d’entrée et de sortie
a. L’instruction d’entrée
Elle permet de ranger, de mémoriser la valeur que l’on vient de saisir, en vue d’un usage
ultérieur. Elle permet de communiquer des données à la mémoire de l’ordinateur : Les
vocables utilisés sont SAISIR, LIRE, ENTRER.
Syntaxe
SAISIR (nom _variable)
LIRE (nom_variable) ou
ENTRER (nom_variable)
2. L’instruction de sortie
Elle permet (à l’algorithme ou programme) d’afficher des informations à l’écran de
l’ordinateur afin que l’utilisateur puisse en prendre connaissance. Les vocables utilisés sont
AFFICHER, ECRIRE ; SORTIR.
Syntaxes
On a trois syntaxes possibles :
Syntaxe 1
AFFICHER (‘information à afficher’)
// pour afficher une simple information à l’écran
Syntaxe 2
AFFICHER (nom_variable) // pour afficher la valeur d’une variable.
Syntaxe 3
AFFICHER (‘Information à afficher’, nom_variable)
// pour afficher une information et la valeur d’une variable.
NB.
-Tout message à afficher est entre quotes ‘ ‘
Edition - 13 -

- Les variables dont on désire afficher les valeurs ne sont pas entre ‘ ‘, des
apostrophes.
- Il faut séparer les contenus des apostrophes des autres, par une virgule.
III.2. Opérateurs
III.2.1.Opérateurs arithmétiques
Ces opérateurs sont utilisés dans les expressions de calculs arithmétiques avec des
opérandes de types numériques
opérateurs significations
+ Addition
- Soustraction
* Multiplication
/ Division décimale
Div Division entière
Mod Reste de la division entière
III.2.2.Opérateurs relationnels
Ces opérateurs sont utilisés dans les structures de choix ou conditionnelles
= égalité
> supériorité
< infériorité
>= Supériorité large
<= Infériorité large
<> Différence
III.2.3.Opérateurs logique
les opérateurs logiques ne font intervenir que des opérandes logiques ou booléens ou des
expressions dont le résultat est booléen
ET intersection
OU union
XOU Ou exclusif
NON complément
Exercice
Compléter les tables de vérité suivantes :
III.2.4.Opérateur de concaténation
Cet opérateur permet de concaténer deux (2) chaines de caractères
Edition - 14 -
Table1
L1(a>b)
a b L1
3 4
47 11
‘sanp’ ‘sans’
Table 2
L1 L2 L1 et L2 L1 ou L2 Non L1
V V
V F
F V
F F

Il est désigné par le caractère ‘&’ ou ‘+’.
Exemple
A  ‘san’
B ‘Pedro’
C  A & B
// La variable C a pour valeur ‘ sanPedro’
III.3. Exercice d’application
On donne deux nombres entiers quelconques. Ecrivez un algorithme qui permet de saisir
les deux nombres, de calculer leur somme et de l’afficher à l’écran.
CORRECTION
Notre rédaction comportera trois grandes phases :
− la description des ressources
− la description des actions
− l’écriture de l’algorithme.
III.3.1.La phase de la description des ressources
Ici, il s’agira de faire :
Un inventaire nominatif des données (objets) qui seront manipulées par le processeur que
ce soit : en entrée, en interne ou en sortie.
Puis d’indiquer le type et la nature de ces données ; enfin d’en faire un commentaire
succinct.
Application de l’exercice
Rôle de la
variable
Identificateur
ou nom
Type nature Commentaires
Entrée X, Y entier variable Les deux valeurs numériques
à entrer au clavier
Sortie SOM entier variable Résultat de la somme des
deux nombres à afficher à
l’écran
III.3.2.La phase de la description des actions
Il s’agit ici d’agencer dans l’ordre de leur exécution, les actions élémentaires qui seront
déroulées.
Application
Entrer les valeurs numériques de X et de Yet qui se traduit par l’instruction ENTRER (X, Y) ;
Faire la somme de X et Y et l’affecter dans la variable SOM ; cela se traduit par l’instruction
SOM  (X + Y) ;
Communiquer le résultat sur le périphérique approprié ; cela se traduit par l’instruction :
AFFICHER (SOM) ;
Edition - 15 -

III.3.3.La phase de la rédaction de l’algorithme
ALGORITHME Addition1
VAR
X : ENTIER
Y : ENTIER
SOM: ENTIER
DEBUT
ENTRER (X)
ENTRER (Y)
SOM  (X + Y)
SORTIR (SOM)
FIN.
Edition - 16 -

IV. STRUCTURES DE CONTRÔLE
Introduction
En programmation procédurale comme en algorithmique, l'ordre des instructions est
primordial.
Le processeur exécute les instructions dans l'ordre dans lequel elles apparaissent dans le
programme. On dit que l'exécution est séquentielle.
Une fois que le programme a fini une instruction, il passe à la suivante. Tant qu'une
instruction n'est pas terminée, il attend avant de continuer. Par exemple, une instruction de
saisie va attendre que l'utilisateur rentre une valeur au clavier avant de continuer.
Parfois, il est nécessaire que le processeur n'exécute pas toutes les instructions, ou encore
qu'il recommence plusieurs fois les mêmes instructions. Pour cela, il faudra casser la
séquence. C'est le rôle des structures de contrôle.
Il existe deux grands types de structures de contrôle:
- les structures conditionnelles vont permettre de n'exécuter certaines instructions que sous
certaines conditions
- les structures répétitives, encore appelées boucles, vont permettre de répéter des
instructions un certain nombre de fois, sous certaines conditions.
IV.1. les structure de choix
Les structures conditionnelles permettent d’exécuter des instructions différentes en fonction
de certaines conditions.
IV.1.1.L’instruction conditionnelle réduite : « SI…ALORS »
Cette instruction permet à la machine d’opérer un choix lorsqu’une condition est vérifiée.
Elle présente la particularité de ne pas avoir de traitements à effectuer lorsque l’évaluation
de la condition produit la valeur FAUX.
Sa syntaxe
Si <condition > alors
<bloc d’instructions>
Finsi
Remarque :
Si la condition est vérifiée alors le bloc d’instructions est exécuté ; dans le cas contraire, il est ignoré.
IV.1.2.Structure conditionnelle alternée ou complète
Sa syntaxe
Si <condition > ALORS
<bloc d’instructions 1>
Sinon
FINSI
Remarque
si la condition est vérifiée seul le premier traitement est exécuté ;
si la condition n’est pas vérifiée seul est effectué le second traitement..
IV.1.3.Imbrication des si
Il est possible d’imbriquer les si autant que nécessaire
Edition - 17 -

SI <condition 1> ALORS
Si <condition11> alors
Sinon
Finsi
Sinon
FINSI
Exercice
SI a > b ALORS
SI B < 0 ALORS
SI C = 5 ALORS
I 3
D 0
FSI
SINON
SI C > 5 ALORS
K b
C  1
SINON
A - 2
FSI
K P * J;
FSI
P M – D ;
FSI
Indiquez les conditions pour lesquelles ces instructions sont exécutées :
I  3 ; et D 0 ; réponse : -------------------------------------------
K B ; et C  1 ; réponse : ----------------------------------------------
A  -2 ; réponse : ----------------------------------------------------------
K  P *J ; réponse : -------------------------------------------------------
P  M – D ; réponse : ------------------------------------------------------
IV.1.4.Structure d’aiguillage
Cette structure de choix permet, en fonction de plusieurs conditions de type booléen,
d’effectuer des actions différentes suivant les valeurs que peut prendre une même variable.
Elle permet de choisir le traitement à effectuer en fonction de la valeur ou de l'intervalle de
valeur d'une variable ou d'une expression.
Cette structure permet de remplacer avantageusement une succession de structures Si…
Alors.
Syntaxe
SUIVANT <nom_variable_choix> FAIRE
Valeur1 : Action1
Valeur 2 : Action2
.
.
Edition - 18 -

.
Valeur n : Action n
SINON Action par défaut
FSUIVANT
Ou
SELON <variable> FAIRE
valeur 1 de variable : traitement 1
valeur 2 de variable: traitement 2
valeur 3 de variable: traitement 3
.
.
.
[Sinon traitement par défaut]
FINSELON
Exercice d’application
Ecrivez un algorithme qui permet d’effectuer la somme ou le produit ou la moyenne de
quatre entiers selon l’opération choisie.
CORRECTION
La description des ressources
Rôle Identificateur Nature Type Commentaires
Entrée Choix VARIABLE ENTIER Choix effectué
Entrée Nb1 VARIABLE ENTIER 1er nombre
Entrée Nb2 VARIABLE ENTIER Deuxième nombre
Entrée Nb3 VARIABLE ENTIER Troisième nombre
Entrée Nb4 VARIABLE ENTIER Quatrième nombre
Description des Actions
Au nombre de quatre nous avons :
 La saisie des quatre nombres qui se traduit par l’instruction suivante : LIRE (Nb1, Nb2,
Nb3, Nb4) ;
 La lecture d’une valeur correspondant au choix effectué traduite par l’instruction LIRE
(choix) ;
 La comparaison de la valeur du choix aux différentes valeurs définies. Ici on dispose de
trois choix présentés de la sorte :
1- Somme
2- Produit
3- Moyenne
 Il faudrait au préalable afficher les trois choix et un message qui invite à saisir le choix
désiré.
 Après la lecture de la valeur du choix, on la compare successivement à 1 ou 2 ou 3.
Si choix vaut 1 alors on exécute l’action correspondant à la somme
Si choix vaut 2 alors on exécute l’action correspondant au produit
Si choix vaut 3 alors on exécute l’action correspondant à la moyenne
Sinon on affiche un message informant que le choix est incorrect.
Edition - 19 -

Rédaction de l’algorithme
ALGORITHME Menu1
VAR choix, Nb1, Nb2, Nb3, Nb 4 : ENTIER
DEBUT
(*Afficher un message de lecture des nombres*)
ECRIRE (‘Saisir quatre nombres’)
(*Lecture des nombres*)
LIRE (Nb1, Nb2, Nb3, Nb4)
(*Afficher le menu*)
ECRIRE (‘Tapez 1 pour la Somme’)
ECRIRE (Tapez 2 pour faire le Produit’)
ECRIRE (‘Tapez 3 pour faire la Moyenne’)
ECRIRE (‘Tapez la valeur de votre choix’)
(*lecture du choix*)
LIRE (choix)
(*Comparaison et exécution de l’action correspondant*)
SUVANT CHOIX FAIRE
1 : ECRIRE (‘la somme est:’ Nb1 + Nb2 +Nb3 + Nb4)
2 : ECRIRE (‘le produit est:’ Nb1 * Nb2 * Nb3 * Nb4)
3 : ECRIRE (‘la moyenne est :’ (Nb1 +Nb2 + Nb3 + Nb4)/4)
SINON ECRIRE (‘votre choix est incorrect’)
FINSUVANT
FIN.
IV.2. Les structures répétitives ou boucles
Les structures répétitives aussi appelées boucles, permettent de répéter un traitement (c’est
à dire une action simple ou composée) autant de fois qu'il est nécessaire: soit un nombre
déterminé de fois, soit tant qu'une condition est vraie.
Il existe trois grands types principaux de structures répétitives:
- la structure Tant que…Faire, qui permet d'effectuer une instruction tant qu'une condition
est satisfaite ;
- la structure Pour qui permet de répéter une instruction un certain nombre de fois ;
- la structure Répéter…Jusqu'à, qui comme son nom l'indique, permet de répéter une
instruction jusqu'à ce qu'une condition soit satisfaite.
IV.2.1.La boucle tant que … faire
La boucle Tant que … Faire permet de répéter un traitement tant qu'une expression
conditionnelle est vraie. Si d'emblée, la condition n'est pas vraie, le traitement ne sera pas
exécuté. On voit donc que la boucle Tant que a un point commun avec la structure
conditionnelle où si la condition n'est pas vraie, le traitement n'est pas exécuté.
Syntaxe
TANT QUE <condition d’exécution> FAIRE
instruction1
.
. Bloc d’instructions
.
Instruction n
FINTANTQUE
Edition - 20 -

IV.2.2.La boucle Pour
La boucle Pour permet de répéter une instruction un nombre connu de fois
Syntaxe
POUR compteur  valeurInitiale à valeurFinale [pas de incrément] FAIRE
Instruction 1
.
.
Instruction n
FINPOUR
Elle permet de faire la même chose que la boucle Tant que mais de façon plus rapide, du
moins lorsque le nombre de répétition est connu.
La variable compteur est de type entier. Elle est initialisée à la valeur initiale. Le compteur
augmente (implicitement) de l'incrément à chaque répétition du traitement. Lorsque la
variable compteur vaut la valeur finale, le traitement est exécuté une dernière fois puis le
programme sort de la boucle.
Par défaut, l’incrément est de 1
La boucle Pour est en fait une simplification de la boucle TantQue.
IV.2.3.La boucle Répéter…Jusqu'à
Cette boucle sert à répéter une instruction jusqu'à ce qu'une condition (expression
booléenne) soit vraie.
Syntaxe
REPETER
Instruction 1
.
.
Instruction n
JUSQU'A <condition d’arrêt>
Le traitement est exécuté, puis la condition est vérifiée. Si elle n'est pas vraie, on retourne
au début de la boucle et le traitement est répété. Si la condition est vraie, on sort de la
boucle et le programme continue séquentiellement. A chaque fois que le traitement est
exécuté, la condition d'arrêt est de nouveau vérifiée à la fin.
La boucle Répéter n'est pas indispensable. Elle peut toujours être remplacée par une boucle
Tantque. C'est pourquoi certains langages n'ont pas d'équivalent pour la boucle
Répéter.
Exercice
Donner la différence entre les structures répétitives ou boucles ?
Edition - 21 -

V. LES SOUS-PROGRAMMES
Introduction
Lorsqu'un programme est long, il est irréaliste d'écrire son code d'un seul tenant. En fait, on
décompose le programme en plusieurs parties plus petites, on donne un nom à chacune de
ces parties, et on les assemble pour former le programme final. C'est le principe de la
programmation modulaire, qui repose sur l'écriture de sous-programmes.
Un sous-programme est, comme son nom l'indique, un petit programme réalisant un
traitement particulier qui s'exécute à l'intérieur d'un autre programme.
Mais contrairement à un programme, un sous-programme ne peut pas s'exécuter
indépendamment d'un autre programme.
Les sous-programmes sont utilisés pour deux raisons essentielles :
- quand un même traitement doit être réalisé plusieurs fois dans un programme (ou qu'il est
utilisé dans plusieurs programmes): on écrit un sous-programme pour ce traitement et on
l'appelle à chaque endroit où l'on en a besoin. On évite ainsi de réécrire plusieurs fois le
code du traitement.
- pour organiser le code, améliorer la conception et la lisibilité des gros programmes. En
effet, le découpage en sous-programmes permet de traiter séparément les difficultés.
Certains sous-programmes ont déjà été écrits et peuvent être utilisés directement dans
n'importe quel programme. Ce sont des sous-programmes standards ou prédéfinis. C'est le
cas par exemple des sous-programmes permettant de faire des calculs mathématiques
(racine carrée, exposant, …). La nature et le nombre de programmes standards dépendent
des langages.
Mais les sous-programmes prédéfinis ne suffisent pas pour découper un gros programme :
le programmeur est amené à écrire le code de ses propres sous-programmes.
Il existe deux sortes de sous-programmes : les procédures et les fonctions.
V.1. Les procédures
V.1.1. Définition
a. Procédure
Une procédure est un ensemble d'instructions regroupées sous un nom, qui réalise un
traitement particulier dans un programme lorsqu'on l'appelle.
Comme un programme, une procédure possède un nom, des variables, des instructions, un
début et une fin.
2. Un paramètre
Un paramètre ou un argument est une variable particulière qui sert à la communication entre
programme appelant et sous-programme.
Les paramètres formels.
Les paramètres placés dans la définition d'une procédure sont les paramètres formels. Ils
servent à décrire le traitement à réaliser par la procédure indépendamment des valeurs
traitées. Les paramètres formels sont des variables locales à la procédure, et à ce titre ils
sont déclarés dans l'entête de la procédure.il existe trois statuts de paramètres : donnée,
résultats, donnée-résultat
Les paramètres réels ou effectifs
Edition - 22 -

Les paramètres placés dans l'appel d'une procédure sont les paramètres réels ou effectifs.
Lorsqu'ils sont de type donnée, ils contiennent effectivement les valeurs sur lesquelles sera
effectué le traitement de la procédure. Lors de l'appel, leur valeur est recopiée dans les
paramètres formels correspondants. Un paramètre effectif en donnée peut être soit une
variable du programme appelant, soit une valeur littérale, soit le résultat d'une expression.
Schéma de communication
Tableau récapitulatifs
Paramètre Début de la procédure Fin de la procédure
Donnée Valeur connue Valeur non modifiée
Résultat Valeur ignorée Valeur modifiée
Donnée-résultat Valeur connue Valeur modifiée
V.1.2. syntaxe de déclaration d’une procédure
PROCEDURE <nom_ procédure> (arg1 : type, arg2 : type, …arg n : type)
//Partie déclarative
DEBUT
.
.
.
FINPROCEDUE
V.1.3. Appel d'une procédure
Pour déclencher l'exécution d'une procédure dans un programme, il suffit de l'appeler, c'est-
à-dire d'indiquer son nom suivi de parenthèses avec les éventuels paramètres effectifs.
V.1.4. Passage de paramètre
a. Le passage de paramètres par valeur
L’algorithme appelant fait un passage de paramètres par valeur à l’algorithme appelé ou
sous-programme lorsqu’il transmet à ce dernier les valeurs des paramètres d’entrée.
L’intégrité de ces valeurs est assurées et le sous programme ne peut les modifier.
2. Le passage de paramètres par adresse ou référence
Edition - 23 -

On dit que des variables sont passées en paramètres par adresse, lorsque celles-ci sont
modifiées au sein du sous- algorithme, elles le sont même lorsque l’on retourne au
programme appelant.
passage par valeur passage par référence
utilisation en entrée oui oui
utilisation en sortie non oui
Remarque
Pour différencier les paramètres passés par valeurs de ceux passer par adresse, on place le
mot var ou le caractère @ avant les paramètres passant par adresse en commençant la liste
par les paramètres passés par valeur.
V.1.5. Visibilité des variables
a. Variables locales
Ce sont les variables qui sont déclarées à l’intérieur d’un programme ou d’un sous-
programme et non visibles ou inaccessibles par les autres (programmes et sous-
programmes)
2. Variables globales
Par opposition au variables locales, ce sont des variables définies dans la partie déclarative
d’un programme et utilisables par les sous programmes et l’ensemble du programme
principal
V.2. Fonctions
V.2.1. Définitions
Les fonctions sont des sous-programmes qui retournent un et un seul résultat au
programme appelant. De ce fait, les fonctions sont appelées pour récupérer une valeur,
alors que les procédures ne renvoient aucune valeur au programme appelant.
FONCTION nom_ fonction (Arg1 : type, arg2 : type,…arg n : type) : type
renvoyé par la fonction
// Partie déclarative
DEBUT
Instruction1
.
. Corps de la fonction
.
Instruction n
Retourne <valeur à retourner>
FINFONCTION
Remarque
Les paramètres d'une fonction sont toujours de statut donnée. La valeur des paramètres
effectifs à l'appel est recopiée dans les paramètres formels qui servent à réaliser le
traitement de la fonction.
Edition - 24 -

V.2.2. Appel d’une fonction
L'appel des fonctions est différent de l'appel des procédures :
L'appel d'une fonction doit obligatoirement se trouver à l'intérieur d'une instruction (affichage,
affectation,…) qui utilise sa valeur.
V.3. différences entre fonctions et procédures.
Fonction Procédure
1 Les fonctions ne peuvent avoir que
des paramètres de statut
données.
Les procédures peuvent avoir des paramètres
résultats, données ou données-résultats.
2 Les fonctions ne peuvent
communiquer qu'un seul résultat
au programme appelant à travers
une valeur de retour (et non à
travers un paramètre)
Les procédures peuvent communiquer de 0 à
plusieurs résultats au programme appelant à
travers des paramètres résultats ou données-
résultats. La valeur de ces résultats est affectée
aux paramètres effectifs correspondant (qui
doivent obligatoirement être des variables du
programme appelant).
3 Une fonction s'appelle à l'intérieur
d'une instruction.
L'instruction utilise la valeur
retournée par la fonction.
L'appel d'une procédure représente une
instruction en elle-même. On ne peut pas
appeler une procédure au milieu d'une
instruction
Remarque
Une sous programme peut ne pas posséder de paramètres.
V.4. Imbrication de sous programmes
Une procédure ou une fonction peut être appelée soit par un programme, soit par un autre
sous-programme (qui lui même a été appelé). Les appels de sous-programmes peuvent
s'imbriquer autant qu'on le désire.
Edition - 25 -

VI. NOTION DE RÉCURSIVITÉ
VI.1. Définition
La récursivité est la possibilité de faire figurer dans la définition d'un objet une référence à
l'objet lui-même.
VI.2. Types de récursivité
Deux types de récursivités:
− Directe (l'algorithme s'appelle lui-même)
− Indirecte ou croisée (un algorithme appelle un autre qui appelle le premier)
VI.3. Construction
Pour construire un algorithme récursif, on doit d'abord s'intéresser à son organisation
générale. Un tel algorithme comprend au moins deux parties principales qui sont
accessibles par une structure de choix (SI condition alors …sinon …….)
 Une condition d'arrêt qui donne la solution d'un cas trivial du problème à résoudre.
 Une partie traitement dans laquelle s'opère(nt) le(s) appel(s) récursif(s) et où sont
altérés les paramètres de l'algorithme. Cette altération doit réduire le problème
général au cas particulier (le cas dit trivial) dont l'algorithme donne la solution.
Trois grandes étapes:
− Paramétrage de l'algorithme (détermination des paramètres à faire évoluer car ce
sont eux qui conditionnent la résolution du cas trivial)
− Étude de la condition d'arrêt (cas trivial)
− Étude du cas général jusqu’à sa réduction au cas simple (cas trivial).
La structure adaptée à un algorithme récursif est la primitive de choix :
SI <condition> ALORS
Traitement1 (résolution du cas trivial)
SINON
Traitement2 (résolution du cas général)
FINSI
Exercice
On se propose une d'écrire une fonction récursive nommée fact_rec qui prend en
paramètre un entier naturel n et retourne n! (factoriel n).
n! = n*(n-1)*(n-2)*…………*3*2*1
Correction
Fonction FACT_REC (n : entier):entier
VAR
Facto : entier
DÉBUT
Si n = 0 alors
Facto  1
Sinon
Facto  n*FACT_REC(n-1)
Finsi
Retourner (facto)
Edition - 26 -

FIN.
La version itérative de cette fonction est:
Fonction fact_it (n : entier):entier
Var
x, produit : entier
Début
x  n
produit  1
Tant que x >0 faire
Produit  produit * x
X  x - 1
Fintantque
Retourner (produit)
Fin.
Edition - 27 -

VII. LES STRUCTURES DE DONNEES STATIQUES
Introduction
Les structures de données statiques sont des variables évoluées qui sont susceptibles de
recevoir plusieurs valeurs à la fois. Par ailleurs, une fois leur taille fixée, il n’est plus possible
de la modifier au cours de l’exécution du programme. C’est pour cette raison qu’on les
appelle structures de données statiques en comparaison avec les structures de données
dynamiques.
Les structures de données statiques regroupent six grands groupes. Ce sont :
 Les chaînes de caractères
 Les intervalles
 Les ensembles
 Les énumérés
 Les tableaux
 Les enregistrements. On les appelle encore les types structurés
VII.1. Les chaînes de caractères
VII.1.1. Définition du type CHAINE
Une chaîne de caractères est une suite de caractères juxtaposés. En d’autres termes une
suite de caractères différents collés les uns aux autres.
Une chaîne de caractères est définie par :
Son nom et Sa longueur maximale (c’est le nombre maximal de caractères que cette
chaîne peut contenir).
VII.1.2. syntaxe
La syntaxe de déclaration d’une chaîne de caractères se fait par :
VAR
Nom_chaîne : CHAINE [longueur maximale] // avec long max є [1 ; 255]
Exemple
VAR
Nom : CHAINE [30] ;
Nous déclarons une chaîne de caractères nommée Nom et pouvant contenir au maximum
trente (30) caractères.
Remarque :
L’on peut parcourir ou atteindre les différents éléments d’une chaîne de caractères grâce à
un indice (entier > 0) qui débute par 1 comme suit : Nom_chaîne [indice].
En fait l’indice ici est la position de cet élément (le caractère) dans la chaîne de caractères.
VII.1.3. Les différentes fonctions applicables sur une chaîne de caractères
On peut réaliser sur une chaîne de caractères, plusieurs différentes opérations usuelles de
fonctions.
On peut citer les fonctions suivantes :
 LONGUEUR ( )
 COPIER ( )
 CONCATENER ( )
Edition - 28 -

 INSERER ( )
 EFFACER ( )
a. La fonction LONGUEUR (M)
Elle permet de déterminer le nombre de caractères contenus dans une chaîne de caractères
M.
syntaxe
LONGUEUR (M) où M est le nom de la variable chaîne_de_caractères.
Exemple
VAR
Nom : CHAINE [30]
Début
Nom  San Perdo.
LONGUEUR (Nom) affichera 9
//Ici on compte tous les caractères y compris les espaces.
b. La fonction COPIER (n, i, j) ;
Elle permet de copier j caractères de la chaîne de caractères M, à partir de son caractère n°i
inclus, dans une autre chaîne de caractères.
syntaxe
COPIER (M, i, j)
Exemple
VAR phrase : CHAINE [20]
P : CHAINE [10]
DÉBUT
Phrase ‘’Heureux sont ceux qui sont pieux’’
P COPIER (Phrase, 3, 8)
(*Cette instruction stipule de copier 8 caractères de la chaîne de caractères Phrase mais à
partir de son caractère n° 3 inclus*)
De sorte que la chaîne de caractères : P contiendra les caractères suivants : ‘’ureux so’’.
3. La fonction CONCATENER (L, M) ;
Elle permet de concaténer (souder) les chaînes de caractères L et M. Ici, c’est la deuxième
chaîne M qui est collée à la première L.
Exemple
VAR
Nom : CHAINE [20]
Prenom : CHAINE [25]
Nom_P : CHAINE [50]
Debut
Nom  ‘’KANGAH’’
Prenom  ‘’EKOUMANO’’
Nom_P  CONCATENER (Nom, Prenom)
Nom_P contiendra ‘’KANGAHEKOUMANO’’
Ici les deux termes sont collés (KANGAHEKOUMANO)
Si nous voulons les séparer alors nous prévoyons un espace qui sera matérialisé par
Donc nous reprenons la syntaxe de la façon suivante :
Nom_P  CONCATERER (Nom,’’ ‘’Prénom) ;
Edition - 29 -

Alors nous aurons :
Nom_P qui contiendra : ‘’KANGAH Ekoumano’’.
4. La fonction INSERER (L, M, K) ;
Elle permet d’insérer la chaîne de caractères L dans la chaîne M mais à partir du caractère
n° K (i. e juste après le caractère n° k -1) de la chaîne M.
Exemple
VAR
Nom : CHAINE [20]
Prenom : CHAINE [25]
DEBUT
Nom  KANGAH
Prenom  Ekoumano
INSERER (Nom, Prénom, 4)
(*Cette instruction ordonne de prendre la contenu de la chaîne Nom et de l’insérer dans le
contenu de la chaîne Prénom, mais à partir du caractère n° 4 (juste après le caractère n° 3)
de la chaîne Prénom*).
On aura comme résultat :‘’EkKANGAHoumano’’.
5. La fonction EFFACER (M, i, j) ;
Elle permet d’effacer j caractères de la chaîne M mais à partir de son caractère n° i inclus.
Exemple :
VAR
Nom : CHAINE [20]
DEBUT
Nom ‘’KINDO’’
EFFACER (Nom, 2, 3)
(*Cette instruction ordonne de se positionner sur le 2ème
caractère de la chaîne Nom et à
partir de ce 2ème
caractère inclus, d’effacer 3 caractères, vers la droite*).
De sorte que la chaîne Nom contiendra finalement ‘’KO’’.
VII.1.4. Les opérateurs applicables sur une chaîne de caractères
Nous avons les opérateurs suivants :
+ : joue même rôle que CONCATENER :
Nom_P  Nom + Prenom ;
= : permet de comparer deux chaînes.
SI Nom = Prenom ALORS….
< > : Permet de différencier 2 chaînes.
Si Nom < > Prenom ALORS…
<, >, < =, > = : permettent de savoir si une chaîne précède ou succède une autre,
alphabétiquement.
SI Nom < prenom ALORS…
VII.2. Le type énuméré
VII.2.1. Définition
C’est un ensemble ordonné d’éléments énumérés tous.
L’ordre d’énumération des éléments est très important : ce n’est véritablement pas une
structure de donnée.
VII.2.2. Sa syntaxe de déclaration
Edition - 30 -

Un type énuméré est défini dans la partie TYPE de l’algorithme. Sa syntaxe est :
TYPE
Nom_type_énuméré = (valeur1, valeur2, ..., valeurn).
Remarque
Tout type déclaré dans la partie TYPE, ne peut être utilisé comme tel, il faudra nécessairement
déclarer dans la partie VAR, une variable de type, le type déclaré dans la partie TYPE ; et c’est cette
variable qui sera utilisé par la suite dans le programme.
Exemple :
TYPE
Jours = (Dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi)
Etat_civil = (célibataire, marie, veuf, separe) ;
Corps = (C, O, H, CO2, H2O) ;
VAR
P : Jours
(*Déclaration de la variable P de type Jours. Et donc P, ne pourra
recevoir que les valeurs citées entre parenthèses dans Jours (Dimanche,
lundi, ---) mais une seule à la fois*)
F : Etat_civil
(*déclaration de la variable F de type Etat_civil. F ne pourra recevoir
que les valeurs citées dans Etat_civil, et une seule à la fois*).
MT : Corps
(*déclaration de la variable Mt de type Corps.
Mt ne recevra donc que les valeurs entre parenthèses dans Corps une seule
à la fois*)
Ainsi, ce sont les variables P, F, Mt qui seront utilisées par la suite dans le programme (mais
non pas Jours, Etat _civil, et corps).
VII.2.3. Les fonctions applicables du type énuméré
Les fonctions suivantes sont utilisables :
ORD, PRED, SUCC
SUCC (mardi) vaut mercredi
PRED (SAMEDI) vaut vendredi
Mais PRED (lundi) et SUCC (dimanche) ne sont pas définis. (Ils n’existent pas).
La première valeur du type énuméré possède le rang 0 (zéro).
Ainsi ORD (lundi) vaut 0
ORD (jeudi) vaut 3.
Remarque
Il est impossible d’utiliser les instructions AFFICHER et SAISIR avec les variables de type énuméré.
Il est aussi impossible de les utiliser comme indice à un tableau.
VII.3. Le type intervalle
Il permet de définir un ensemble de valeurs par la simple connaissance de la valeur initiale
et de la valeur finale à la différence du type énuméré où obligation est faite de définir tous
ses éléments.
Edition - 31 -

VII.3.2. Sa déclaration et syntaxe
Un type intervalle est défini dans la partie TYPE de l’algorithme.
La syntaxe de déclaration est la suivante :
TYPE
Nom_intervalle = valeur_initiale.. valeur_finale
Avec valeur_initiale et valeur_finale, des constantes (entier, caractère) telles que
valeur_initiale < valeur_finale.
Exemple
TYPE
Age = 1.. 150
VAR
age_pere : age
En effet, age_pere ne pourra recevoir seulement que les valeurs comprises entre 1 et 150 y compris.
Mais une seule valeur à la fois.
Remarque
Un intervalle est forcément ordonné et continu.
Il est possible d’utiliser des constantes d’un type énuméré pour constituer un type intervalle.
Exemple
TYPE
Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche)
Jours_travail = lundi..vendredi
Week_end = samedi..dimanche
Mais les deux dernières déclarations ont été possibles parce que l’on a auparavant déclaré
un type énuméré ayant ces constantes (lundi…)
VII.3.3. Les propriétés de type intervalle
Les variables d’un type intervalle jouissent exactement des mêmes propriétés que le type
hôte. Elles peuvent intervenir dans les mêmes expressions.
TYPE ENTIER : , +, *, /, =, -, < ; <=, >, >=, < >.
TYPE CARACTERE: , =, -, <, <=, >, >=, < >, ORD, SUCC, PREC.
TYPE ENUMERE : ,ORD, SUCC, PRED, incrémentation, décrémentation.
Exemple :
TYPE
Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche)
Jours_travail = lundi..vendredi
VAR
Courant, aujourd’hui : jours_travail
ct : Jours
Aujourd-hui  mardi
Courant  SUCC (Aujourd-hui) (*courant contiendra mercredi*)
Aujourd-hui Aujourd-hui + 2 (*Aujourd-hui contiendra jeudi*)
Remarque :
Il est possible d’utiliser des valeurs de type énuméré comme compteur dans la boucle
POUR….FAIRE.
En s’appuyant sur l’exemple ci-dessus, nous pouvons avoir :
Edition - 32 -

POUR Ct  lundi à dimanche FAIRE
(*Ici il faut que ct soit une variable de type énuméré*)
Instructions
FPOUR
VII.4. type ENSEMBLE
Le terme ensemble évoque ici, une collection non ordonnée d’éléments de même type, où le
rang des éléments n’a pas d’importance.
VII.4.2. Déclaration du type ensemble
Elle se fait majoritairement dans la partie TYPE bien qu’on puisse le faire aussi dans la
partie VAR)
La syntaxe de déclaration est la suivante :
TYPE
Nom_ensemble = ENSEMBLE de type_de_base
Avec type_de_base, un type ordinal (ENTIER, REEL, CARACTERE, ENUMERE) ou
INTERVALLE d’un type ordinal dont les valeurs ordinales sont comprises entre zéro(0) et
255 et contenant au plus 256 éléments.
Exemple
TYPE
Lettres = ENSEMBLE de CARACTERE
Premier = ENSEMBLE de 1..20
VAR
F : Lettre
P : Premier
Ainsi F pourra contenir zéro (0), un (1) ou plusieurs caractères à la fois ;
P pourra contenir zéro (0), un (1) ou plusieurs valeurs entières à la fois comprises entre 1 et
250 y compris.
VII.4.3. Construction d’une variable de type ensemble
Construire un ensemble, c’est constituer ses éléments.
Un ensemble se construit grâce à la parie de crochet [ ]
La syntaxe de construction d’un ensemble est la suivante :
[Objets]
Où objets peut être une liste d’éléments séparés par des virgules ou bien un ou plusieurs
intervalles séparés par des virgules ou bien la combinaison de deux (liste d’éléments et
intervalle). Mais tous les éléments constituant un même ensemble doivent nécessairement
être du même type.
Exemples
Voici 3 exemples d’ensembles
[‘a’, ‘j’, ‘m’] est l’ensemble constitué des 3 caractères a, j, m.
[9, 7, 6, 25] est l’ensemble constitué des nombres 9 ; 7 ; 6 ; 25
[1..5, 8, 15..20] ensemble de nombres 1, 2, 3, 4, 5, 8, 15, 16, 17, 18, 19 et 20.
Remarques
L’ordre dans lequel sont mentionnées les expressions n’a aucune importance.
Edition - 33 -

De sorte que [5, 7] et [7, 5] définissent le même ensemble. ([5, 7] = [7, 5]).
Il est possible de déclarer des constantes de type ensemble
Exemple :
CONST
Voyelle = [‘a’, ‘e’, ‘i’, ‘u’, ‘o’, ‘y’]
P = 10
Valeurs = [P, 2*P, 3*P]
C = ‘e’
Lettres = [C, PRED (C), SUCC (C)]
VII.4.4. Les opérations portant sur les ensembles
Nous ferons cas de six principales opérations :
L’affectation
La réunion
L’intersection
La différence
Les opérations de comparaison
L’instruction d’appartenance : DANS.
a. L’affectation ( )
TYPE
Voy = ENSEMBLE de CARACTERE
VAR
T : Voy
DEBUT
T [‘a’, ‘f’]
Remarque
On peut faire l’affectation entre deux ensembles constitués d’éléments de même type exclusivement.
2. La réunion : (+)
Elle permet de fusionner les éléments de plusieurs ensembles mais sans redondance.
Exemples
A et B sont des ensembles
A B A + B
[1, 3] [2, 6] [1, 2, 3, 6]
[1, 3] [4, 3] [1, 3, 4]
[1, 5] [1, 5, 6] [1, 5, 6]
3. L’intersection (*)
L’intersection de deux ensembles ou plus, c’est l’ensemble formé d’éléments appartenant à
la fois aux deux ensembles ou plus.
Exemples :
Soient A et B des ensembles
A B A * B
[1, 3, 8] [1, 5, 8, 11] [1, 8]
[1, 5] [1, 3, 5, 8] [1, 5]
[3, 7] [2, 9, 11] [ ]
Edition - 34 -

4. La différence : (-)
Soient A et B deux ensembles A – B est l’ensemble formé d’éléments appartenant à A et
n’appartenant pas à B (on retire de A, tout ce qui appartient à B ;
Il s’en suit que A – B ≠ B – A
Exemples
A B A - B
[‘a’, ‘c’, ‘f’, ‘k’] [‘c’, ‘f’] [‘a’, ‘k’]
[‘a, ‘b’, ‘c’] [‘d’, ‘e’] [‘a’, ‘b’, ‘c’]
[‘f’, ‘g’] [‘a’, ‘f’, ‘g’, ‘k’] [ ]
5. Les opérations de comparaison
Ici deux opérations sont à prendre en compte :
L’Egalité (=) A = B si A et B sont formés des mêmes éléments
L’Inclusion ( ≤ ) A ≤ B si A est inclus dans B.
6. L’instruction d’appartenance : (DANS)
Syntaxe
Nom_variable DANS nom_variable_ensemble
Exemple
TYPE
Lettres = ENSEMBLE de CARACTERE
VAR
Voy : Lettres
C : CARACTERE
DEBUT
Voy  [‘a’, ‘A’, ‘e’, ‘E’, ‘y’, ‘Y’, ‘i’, ‘I’, ‘u’, ‘U’, ‘o’, ‘O’]
AFFICHER (‘Entrez une lettre SVP’’)
SAISIR ( C)
SI C DANS Voy ALORS
AFFICHER (‘Vous avez saisi une voyelle’)
FSI
VII.5. Type TABLEAU
Un tableau est une structure de données contenant des éléments de même type
Ces éléments peuvent être des :
 entiers
 réels
 booléens
 chaînes de caractères
 caractères
 tableaux
 enregistrements
Le tableau est constitué de cases représentant chacune une variable.
Edition - 35 -

Chaque valeur du tableau (valeur de chaque case) sera accessible à travers un nom du
tableau commun à toutes les valeurs et repérée par un sélecteur appelé indice du tableau
ou la position de la donnée dans le tableau).
Un tableau est caractérisé par :
son nom
sa taille (nombre maximal d’éléments qu’il va contenir)
et le type de ses éléments.
On distingue deux grands groupes de tableaux sur la base de leurs dimensions.
Ainsi on a les tableaux :
− Unidimensionnels ou vecteurs et
− Multidimensionnels.
Mais pour ce cours nous nous intéresserons aux tableaux à une dimension et à deux
dimensions.
VII.5.2. Les tableaux à une dimension ou unidimensionnels
Appelé encore vecteur un tableau unidimensionnel est constitué d’une (1) seule ligne et n
colonnes (1 seule ligne et plusieurs colonnes).
a. Exemple
Mes moyennes de 10 étudiants d’une classe IG sont stockées dans un tableau linéaire
suivant.
5 12 14 7,5 10 9,5 13 3 6 10
1 2 3 4 5 6 7 8 9 10
2. Syntaxe et description
Un tableau à une (1) dimension peut être déclaré soit dans la partie TYPE ; mais
majoritairement dans la partie VAR.
Si d’aventure, un tableau à une (1) dimension est déclaré dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable ayant pour type, le type déclaré dans la
partie TYPE.
La syntaxe de déclaration d’un tel tableau se fera par :
VAR
Nom_tableau : TABLEAU [taile] de type_éléments
// taille, un entier>0
Ou bien :
TYPE
Nom_tableau = TABLEAU [taille] de type_éméments.
Pour atteindre chaque élément d’un tableau à une dimension l’on procède comme suit :
Nom_tableau [indice]
//avec indice є [1, taille]
Exemple
T [5] ; cette instruction permet d’atteindre le 5è élément du tableau T et d’y faire ce que l’on
désire (soit envoyer une valeur. (Écriture) ou prendre possession de la valeur déjà là
(lecture).
Edition - 36 -

VII.5.3. Les tableaux à plusieurs dimensions
On peut avoir un tableau à 2, 3,…, n dimensions.
Mais dans la pratique, c’est le tableau à deux dimensions qui est le plus utilisé.
a. Définition
Un tableau à deux dimensions (de dimension 2) est constitué de :k lignes (plusieurs lignes)
et de p colonnes(plusieurs colonnes).
2. Syntaxe de déclaration
Il peut être déclaré soit dans la partie VAR soit dans la partie TYPE ; mais majoritairement
dans la partie VAR.
Si d’aventure, un tableau de dimension 2 est déclaré dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable ayant pour type, le type déclaré dans la
partie TYPE.
La déclaration d’un tableau P à deux dimensions se fait par :
VAR
T : TABLEAU [Nombredelignes] [Nombredecolonnes] de type_éléments
//Avec Nombre de lignes et Nombre de colonnes, des entiers > 0
Ou bien
TYPE
P = TABLEAU [Nombre de lignes] [Nombre de colonnes] de type_éléments
Exemples
P : TABLEAU [7] [5] de CARACTERE ; définit un tableau de 7 lignes et 5 colonnes, soit 35 e
t chaque case recevra un seul caractère.
C1 C2 C3 C4 C5
L1
L2
L3
L4
L5
L6
L7
Pour atteindre un élément d’un tableau de dimension 2, on procède de la façon suivante :
Nom_tableau [n° ligne] [n°colonne]
Ainsi P [2] [5] ; permet d’atteindre l’élément du tableau P se trouvant à l’intersection de la 2è
ligne et la 5è colonne.
VII.5.4. Imbrication des tableaux
Un tableau peut en imbriquer un autre c’est-à-dire qu’un tableau peut se retrouver à
l’intérieur d’un autre tableau.
Remarque
Dans ce cas les tableaux à imbriquer doivent nécessairement être déclarer dans, la partie
TYPE.
Exemple
TYPE
P : TABLEAU [5] de CHAINE
T : TABLEAU [10] de P
VAR
Edition - 37 -

M : T
VII.5.5. Définition de constante de type Tableau
Il est souvent nécessaire, dans la résolution de certains problèmes, de définir des
constantes de type tableau ; Ici, on déclare le tableau et on l’initialise en même temps (c’est-
à-dire qu’on lui attribue déjà ses valeurs). Mais une fois les valeurs du tableau attribuées,
l’on ne pourra plus les modifier car l’on à défini le tableau dans la partie CONST (donc ses
éléments sont des constantes).
Remarque :
Une telle déclaration permet de pallier les insuffisances des structures de données qui ne
permettent pas de définir des ensembles de chaînes de caractères.
Cas de la structure de données Ensemble.
Syntaxe de déclaration
CONST
Nom_CSte : TABLEAU [taille_tableau] de type_élément = (élément1,
élément2,....,élémentn)
Exemple 1
CONST
Tab : TABLEAU[5]de ENTIER = (1, 45, 78, -156, 0)
de sorte que le tableau de dimension Tab sera représenté ainsi :
1 45 78 -156 0
Exemple 2
CONST
T : TABLEAU[3][5] de CARACTERE = ((‘b’, ‘5’, ‘p’, ‘-‘, ‘b’), (‘1’, ‘c’,
‘T’, ‘y’, ‘m’), (‘>’, ‘&’, ‘@’, ‘w’, ‘Q’))
ou
CONST
T : TABLEAU[3][5] de CARACTERE = (‘b’, ‘5’, ‘p’, ‘-‘, ‘B’, ‘1’, ‘r’, ‘T’,
‘y’, ‘m’, ‘>’, ‘&’, ‘@’, ‘w’, ‘Q’)
VII.6. type ENREGISTREMENT
Contrairement aux tableaux qui sont des structures de données dont tous les éléments sont
de même type, les enregistrements sont des structures de données dont les éléments
peuvent être de type différent et qui se rapportent à la même entité (au sens de Merise)
Les éléments qui composent un enregistrement sont appelés champs.
VII.6.2. Syntaxe de déclaration
La déclaration d’un type ENREGISTREMENT se fait dans la partie TYPE.
TYPE
Nom_type_enregistrement = ENREGISTREMENT
Non_champ1 : type_champ1
Nom_champ2 : type_champ2
.
.
.
Edition - 38 -

Nom_champn : type_champn
FINENREGISTREMENT
Remarque
Mais après la déclaration d’un type Enregistrement dans la partie TYPE, il faudra
nécessairement par la suite, déclarer une variable de type Enregistrement dans la partie
VAR car c’est elle qui sera utilisée par la suite dans la suite dans le programme.
VII.6.3. L’intérêt du type Enregistrement
Il sert à identifier dans les détails, un objet donné
Exemple1
Type
eleve= ENREGISTREMENT
Mat : chaine[10]
Nom : chaine[20]
Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
Var
Etudiant : eleve
Exemple2
Nous voulons identifier l’objet PRODUIT.
Nous avons besoin de :
nom du produit ou son libellé (CHAINE DE CARACTERE),
sa référence (CHAINE)
et son prix de vente (REEL).
Ainsi pour définir le type Enregistrement Produit, nous procéderons de la façon suivante :
TYPE
Produit = ENREGISTREMENT
Nom : CAHINE
Référence : CHAINE
Prix_vente : REEL
FIN
VAR
Article : Produit
VII.6.4. exploitation
1. Les différents champs d’une variable de type Enregistrement sont exploités l’un après
l’autre mais séparément.
2. On accède à chaque de la variable, en précisant le nom de la variable suivie d’un point (.)
et du nom du champ concerné.
NB.
Les termes suivants sont synonymes : Champ, propriété, rubrique
Exemple.
Nous voulons accéder au champ référence de la variable Article. Alors nous écrivons
Article. Référence.
Edition - 39 -

Instruction ‘’AVEC…FAIRE’’
L’instruction ‘’AVEC…FAIRE’’ permet de simplifier l’exploitation des variables de type
Enregistrement.
Elle permet d’éviter la répétition du préfixe dans l’exploitation des champs.
AVEC nom_variable_type_enregistrement FAIRE
//instruction
FIN AVEC
exemple
ALGORITHME saisietu
TYPE
Elève = ENREGISTREMENT
Mt : CHAINE [10]
Nom : CHAINE [20]
Prénoms : CHAINE [50]
Contact : REEL
Sexe : CARACTERE
Poids, taille, Age : REEL
Classe : CHAINE [10]
Moyenne : REEL
FIN
VAR
Etudiant : Elève
DEBUT
AFFICHER (‘Veuillez affecter une valeur à chaque champ’)
SAISIR (Etudiant. Mat)
SAISIR (Etudiant. Nom)
SAISIR (Etudiant. Prénoms)
SAISIR (Etudiant. Contact)
SAISIR (Etudiant. Sexe)
SAISIR (Etudiant. Taille, Poids, Age)
SAISIR (Etudiant. Classe)
SAISIR (Etudiant. Moyenne)
FIN
Avec l’instruction avec on obtient
ALGORITHME saisietu
TYPE
Eleve = ENREGISTREMENT
Mat : CHAINE [10]
Nom : CHAINE [20]
Prenoms : CHAINE [50]
Contact : REEL
Sexe : CARACTERE
Poids, taille, Age : REEL
Classe : CHAINE [10]
Moyenne : REEL
FIN
VAR
Etudiant : Eleve
DEBUT
Edition - 40 -

AFFICHER (‘Veuillez affecter une valeur à chaque champ’)
AVEC Etudiant FAIRE
SAISIR (Mat)
SAISIR (Nom)
SAISIR (Prénoms)
SAISIR (Contact)
SAISIR (Sexe)
SAISIR (Taille, Poids, Age)
SAISIR (Classe)
SAISIR ( Moyenne)
FINAVEC
FIN
VII.6.5. Imbrication d’enregistrements
Définition
Une variable de type Enregistrement peut laisser figurer en son sein un autre
enregistrement. On dit alors qu’elle imbrique un autre enregistrement
Exemple
TYPE
Contact = ENREGISTREMENT
Telephone : CHAINE[10]
Boite_postale : CHAINE[15]
Lieu_habitation : CHAINE[25]
FIN
Personne = ENREGISTREMENT
Nom :chaine[20]
Prenom : chaine[50]
Taille :reel
Ct : Contact (*imbrication*)
VAR
P : Personne
Ainsi dans l’exploitation des champs nous avons par exemple :
P. Nom ‘’YAPI’’
P. Prénom  ‘’ASSI Fernand’’
P. Taille  1,80
P. Ct. Téléphone  ‘’08 20 13 79’’
P. Ct. Boîte-postale  ‘’14 BP 235 Abidjan 14’’
P. Ct. Habitation  ‘’Abidjan, Cocody Danga’’
VII.6.6. Tableau d’enregistrement
Il est possible d’avoir un tableau de type enregistrement
Exemple
Type
Mat : chaine[10]
Nom : chaine[20]
Edition - 41 -

Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
tab=TABLEAU[13] de eleve
Var
Etudiant : eleve
t :tab
i:entier
DEBUT
POUR i1 à 13 faire
AVEC t[i] FAIRE
SAISIR (Mat Nom, Pren, Age, poids,Sexe)
FINAVEC
FINPOUR
FIN
Remarque
Un enregistrement peut contenir un champ de type tableau
Edition - 42 -

VIII. LES FICHIERS
Introduction
Toutes les informations que nous avons jusqu'à présent traitées étaient saisies à partir du
clavier et stockées en mémoire (la RAM).
Or la mémoire centrale est volatile : les informations qui y sont stockées sont détruites à la
fin de l'exécution du programme et ne peuvent donc pas être réutilisées ultérieurement. A la
fin de l'exécution du programme, il ne reste aucune trace de cette exécution et des résultats
générés.
Par ailleurs, la mémoire centrale a l'inconvénient d'être bien plus chère que la mémoire non
volatile des disques durs, disquettes ou bandes magnétiques. La taille de la mémoire
centrale est par conséquent très inférieure à la taille de la mémoire non volatile. Pour
mémoriser de gros volumes d'information, la mémoire centrale ne suffit pas.
Ainsi, dans la plupart des applications d'entreprises pour lesquelles un gros volume
d'informations doit être mémorisé plus longtemps que la durée de vie du programme, les
informations sont récupérées et mémorisées sur un support non volatile (disques,
disquettes, bandes magnétiques…). Les informations y sont enregistrées de manière
permanente dans des fichiers.
Les informations ne sont plus seulement communiquées via le clavier et l'écran, mais aussi
via des fichiers de support non volatiles. Il est alors possible qu'un programme ne
communique avec son environnement qu'au travers des fichiers et n'utilise ni la saisie, ni
l'affichage.
VIII.1. Définition
VIII.1.1. fichier
Un fichier est un regroupement d'informations sur un support non volatile tel que le disque.
Il existe de nombreux types de fichiers, qui différent en outre selon les langages. Nous
distinguerons les fichiers de type « texte » et les fichiers structurés.
a. Les fichiers structurés
Les fichiers structurés permettent d’enregistrer des données de même nature. Ils sont
composés d’enregistrements (ou articles) contenant les mêmes champs (ou rubrique).
Généralement, chaque enregistrement correspond à une ligne, et les rubriques sont
séparées par un séparateur qui peut être par exemple un point-virgule (format csv).
2. Les fichiers non structurés
Les fichiers non structurés permettent quant à eux d’entasser des informations de natures
diverses. Ils ne sont pas obligatoirement structurés en enregistrements, mais ils ne peuvent
être lus que de manière séquentielle. Ex : un fichier word.
VIII.1.2. supports pour les fichiers:
Il existe deux grandes familles de supports pour les fichiers:
- les supports adressables, sont capables de fournir l'adresse d'un emplacement de
stockage. C'est le cas des disques et les disquettes. Ils permettent un accès direct (non
séquentiel) à leur contenu.
- les supports non adressables qui ne peuvent être accédés que de manière séquentielle.
C'est le cas des bandes magnétiques, qui sont encore utilisées pour stocker les données
très volumineuses (les archives)
Edition - 43 -

VIII.2. Caractéristiques d’un fichier
Un fichier sera caractérisé par son nom, son emplacement ( sur le support) , son
organisation, sa taille ou son volume et par son type
Nom
Le nom par lequel le fichier est enregiqtrer sur l’unité de disque
Emplacement
Le chemin d’accès du fichier sur l’unité
Organisation
L’orde avec lequel les information sont rangés ou placées en memoire
Volume
Le nombre d’octets total que le fichier occupe sur le support
Le type
Il est fonction de ladurée de vie du fichier sur l’unité et de son tauxde mise à jour
− Fichier permaments
− Fichiers mouvement
− Fichiers historiaue ou archives
− Fichiers tempiraires
VIII.3. mode d'accès
On appelle mode d'accès à un fichier la façon de retrouver une donnée dans ce fichier. Il
existe deux modes d'accès principaux:
VIII.3.1. Les fichiers à accès séquentiel
L’accès séquentiel: possible sur tous les types de support et avec tous les types de fichiers
Pour accéder à un article particulier, on doit avoir parcouru tous les articles précédents sur
le support.
VIII.3.2. Les fichiers à accès direct
l'accès direct: possible seulement sur support adressable avec des fichiers structurés
On peut se positionner directement sur l'enregistrement voulu à partir de son emplacement
sur le support (ou à partir d’une clé) sans avoir à parcourir les précédents. Un fichier à accès
direct peut être vu en quelque sorte comme un énorme tableau stocké sur support non
volatile.
VIII.4. Déclaration
Dans un programme, un fichier est désigné par une variable, qu'on déclare dans la section
des variable.
Pour déclarer un fichier séquentiel structuré, il faut indiquer le type des articles ou
enregistrements (déclaré au préalable) qui composent ce fichier.
syntaxe
Var:
<nom_fichier> : fichier de <enregistrement>
VIII.4.1. Assignation
Avant l’utilisation d’un fichier dans un programme, il faut d’abord l’assigner (c'est-à-dire
[créer et ] établir un lien entre le non physique te le nom logique
Edition - 44 -

ASSIGNER (<nom logique fichier>, <chemin d’accès au fichier physique>)
Exemple
Type
Mat : chaine[10]
Nom : chaine[20]
Pren : chaine[30]
Age, poids : entier
Sexe : caractère
FIN
Var
Fich :Fichier de eleve
Etudiant : eleve
DEBUT
ASSIGNER (Fich,’C:cupsan_pedroalgo.txt’)
VIII.5. Instructions sur les fichiers
VIII.5.1. ouverture et fermeture
La première instruction après l’assignation d’un fichier dans un programme est son
ouverture.
Comme un fichier ne se trouve pas en mémoire centrale (mais en périphérique), il n'est pas
accessible directement par le programme (seule la mémoire centrale est accessible
directement). Il est nécessaire de l'ouvrir avant de pouvoir l'utiliser. L'ouverture permet la
réservation d'une mémoire tampon en mémoire centrale pour les échanges entre le disque
et la mémoire centrale.
Pendant l’ouverture il faut préciser le traitement ou les traitements qui seront faits sur le
fichier.
Lecture (L) ; Ecriture(E), et Lecture / Ecriture (L/E)
exemple
OUVRIR(Fich,E)
La dernière instruction est la fermeture du fichier
syntaxe
FERMER(<onm fichier>)
VIII.5.2. Instruction sous jacentes
Ces instructions ne concernent pas globalement le fichier mais un enregistrement de ce
dernier.
A. LIRE
L'instruction LIRE permet de transférer des articles d'un fichier existant dans une (ou
plusieurs) variable du programme. La variable lue doit obligatoirement être de même
structure (c'est-à-dire du même type) que les articles du fichier. Le fichier lu doit
obligatoirement exister.
syntaxe
LIRE (nom_fichier, nom_variable_de type enregsitrement )
Ou bien
Edition - 45 -

LIRE (nom_variable_de type enregsitrement )
Exemple
LIRE (Fich, etudiant)
Cette instruction récupère une occurrence d’un élève du fichier et l’affecte dans la variable
etudiant.
Remarque
La lecture nécessite un test de fin de fichier
Un indicateur booléen du système de fichier nous permet de savoir si nous sommes à la fin
du fichier. Nous le nommons FinDeFichier (FDF) ou en anglais (EOF)
2. ECRIRE
L'instruction Ecrire permet de recopier le contenu d'une variable (contenue en mémoire
centrale) à la fin du fichier (au premier article vide). Ecrire permet donc soit de créer un
nouveau fichier, soit d'agrandir un fichier en lui ajoutant un article à la fin . elle permet de
sauvegarder les enregistrement sur un support physique
syntaxe
ECRIRE (nom_fichier, nom_variable_de type enregsitrement )
Exemple
ECRIRE (Fich, etudiant)
Remarque
Toute nouvelle information écrite dans un fichier séquentiel se met systématiquement à la
fin du fichier.
3. REECRIRE
L'instruction Reecrire permet de modifier le contenu d’un enregistrement d’un fichier
Toute modification est en général précédée d’une recherche.
Syntaxe
REECRIRE (nom_fichier, nom_variable_de type enregsitrement )
Exemple
REECRIRE (Fich, etudiant)
4. SUPPRIMER
L'instruction Supprimer permet de suppriment le un enregistrement d’un fichier
Syntaxe
SUPPRIMER (nom_fichier, nom_variable_de type enregsitrement )
Exemple
SUPPRIMER (Fich, etudiant)
Remarque
Les deux dernières instructions ne peuvent être exécutées qu’âpres lecture d’un
enregistrement. C’est le dernier enregistrement le plus récemment lu qui est concerné.
Edition - 46 -

IX. LES STRUCTURES DE DONNEES DYNAMIQUES
Introduction
Ce sont des structures de données encore plus évoluées que celles vues précédemment : le
structures de données ‘’statiques’’. En effet, avec celles-ci, d’abord la réservation d’espace
mémoire, une fois faite, demeure jusqu’à terme de l’exécution du programme. Ensuite,
parfois pour gérer une certaine quantité d’informations, nous sommes obligés de faire une
importante réservation d’espace mémoire, de peur de débordement quoiqu’en réalité, seule
une partie est réellement utilisée : quel gâchis d’espace mémoire. Enfin, ces structures sont
utilisées isolément.
En fait, pour résoudre certains problèmes de façon optimale, nous avons besoin de :
juste utiliser l’espace mémoire qu’il faut,
libérer l’espace mémoire dont on a plus besoin après utilisation et,
enfin chaîner des structures (les lier entre elles) pour construire des structures plus
complexes et plus souples : c’est la notion de structure de données dites dynamiques dont
le leitmotiv est le pointeur.
Le terme ‘’dynamiques’’ signifie que la taille de ces structures de données n’est pas fixité,
figée : elle est susceptible de variation : s’agrandir ou rétrécir au besoin. Ainsi la gestion de
l’espace mémoire peut se faire de manière optimale.
IX.1. Notion d’adresse en mémoire
A la déclaration d’une variable, le compilateur réserve la place nécessaire (correspondant
au type de données déclaré) en mémoire.
En effet, pour accéder à un endroit donné de la mémoire, la machine utilise un système
d’adressage. A chaque emplacement mémoire correspond une adresse. Ainsi, lorsque le
système réserve un emplacement mémoire pour une variable il réserve une adresse
mémoire pour cette variable. Chaque variable a donc une adresse en mémoire.
IX.2. Définition d’un pointeur
Un pointeur est une variable qui au lieu de contenir l’information proprement dite va contenir
l’adresse mémoire de cette information (l’emplacement de cet objet).
Ainsi connaissant son pointeur (i. e la variable qui contient son emplacement), on peut
facilement atteindre l’objet en question.
L’objet peut être un type simple (entier, caractère, chaîne de caractères…) ou structuré
(enregistrement, tableaux…).
Syntaxe
TYPE
Nom_pointeur = ↑type_pointé // Avec type_pointé ; un type simple, Structuré, une cellule
exemple
TYPE
P = ↑ ENTIER
VAR
d : P
Edition - 47 -

Cette déclaration signifie que la variable d est de type P (c’est-à-dire un pointeur sur un
entier), et va contenir l’adresse d’un entier.
Remarque
L'adresse contenue dans un pointeur est celle d'une variable qu'on appelle variable pointée.
On dit que le pointeur pointe sur la variable dont il contient l'adresse.
Un pointeur est associé à un type de variable sur lequel il peut pointer. Par exemple, un
pointeur sur entier ne peut pointer que sur des variables entières.
NB:
Quand la variable pointeur ne pointe sur rien, elle doit contenir une valeur spéciale qui ne
doit pas pouvoir être confondue avec une adresse. On utilise le mot réservé "NIL" pour
indiquer cela.
IX.3. utilité
On utilise un pointeur pour mémoriser l'emplacement d'une autre variable.
Il est très rare d'affecter directement une adresse à un pointeur. On affecte en général
l'adresse d'une variable existante.
IX.4. Les différents types de pointeurs
Nous avons différents types de pointeurs, en fonction du type de l’objet. Ainsi nous avons
des pointeurs qui pointent sur :
des entiers,
des caractères,
des réels
des enregistrements,
des chaînes de caractères
des tableaux
des enregistrements…
IX.5. L’affectation à un pointeur
L’opération d’attribution directe d’une valeur (ou affectation) à un pointeur (sauf pour des
utilisations bien précises) est pratiquement interdite. Car la valeur attribuable à un pointeur
est une adresse mémoire. Or, sans ce rapport, c’est la système d’exploitation qui se charge
de l’allocation de la mémoire centrale et donc de l’attribution des adresses mémoire. Pour le
faire, il faudra avoir une parfaite connaissance de l’occupation de la mémoire centrale.
Lors de la déclaration d’un pointeur, on lui réserve une zone mémoire qui va servir à
contenir l’adresse de l’objet. Mais l’espace mémoire pour l’objet, n’est cependant pas encore
réservé. Ainsi, pour attribuer une valeur à un objet pointé, il faudrait :
− D’abord réserver l’espace mémoire de cet objet. Cette réservation d’espace mémoire
se fait par le mot clé :NOUVEAU dont la syntaxe est
NOUVEAU (nom_variable_pointeur)
− Ensuite, attribuer une valeur à l’objet pointé et qui se fait par :
Nom_variable_pointeur ↑  valeur
NB :
Nom_variable_pointeur ↑ : désigne l’objet pointé par Nom_variable_pointeur.
Edition - 48 -

Exemples
TYPE
P = ↑ ENTIER
VAR
d :P
DEBUT
NOUVEAU (d)
(* Réservation de l’espace mémoire pour contenir l’entier pointé par d*)
d↑  5
(*Affectation de la valeur 5 à l’entier pointé par d*)
--------
Explication schématique
d : P d
Réservation de l’espace mémoire pour le pointeur d.
Le contenu de d est encore non défini pour l’instant.
NOUVEAU (d)
1) Désormais, d contient l’adresse de l’espace créé pour contenir, l’entier.
d ↑  5
Edition - 49 -
d
Espace réservé (créé) et pointé par d (d ↑).
@ 1
d
Espace réservé (créé) et pointé par d (d ↑).
@ 1
5

IX.6. Les différentes opérations sur un pointeur.
Nous avons généralement les deux opérateurs suivants :
(-) et (+).
Ceux-ci s’appuient sur l’espace mémoire occupé par les différents types en question.
Rappel :
1 caractère occupe 1 octet
1 entier occupe 2 octets
1 réel occupe 4 octets
Soit P, un pointeur sur un objet de k octets, (P + 1) fait pointer le pointeur P sur la case
mémoire en sautant de k octets depuis la case pointée initialement par P.
Exemple :
TYPE
P = ↑ ENTIER
VAR
d : P
d d+1 d+2
Etat initial
Ici on saute de 2 octets car c’est un entier
Exercice
Soit :
TYPE
P ↑ ENTIER
G = ↑ CARACTERE
T = ↑ REEL
VAR
d : P
e : G
f : T
A partir d’un état, représentez les cas suivants :
e ; e – 1, e + 2, e + 5 ;
f ; f + 1, f – 2, f + 3
IX.7. Les procédures de construction de structures de données dynamiques
IX.7.1.cellule
Une cellule est une variable content deux champs :
− Un champ contenant de l’information qui peut être un type simple ou structuré.
Ce champ peut être constitué de un (1) ou plusieurs informations de type identique ou
différent.
− Un champ contenant l’adresse
Edition - 50 -

Cette adresse peut être : nulle c’est-à-dire ne contenant pas l’adresse d’une autre cellule.
Ce champ peut être constitué d’une (1) ou plusieurs adresses également.
Une cellule est atteinte par son adresse donc grâce à son pointeur.
IX.7.2.Déclaration de syntaxe d’une cellule
Elle se fait également dans la partie TYPE, comme suit :
Exemple
IX.7.3.accès aux différents champs d’une cellule
L’accès aux différents champs d’une cellule se fait selon la syntaxe suivante :
Edition - 51 -
TYPE
Nom_cellule = ENREGISTREMENT
Champ1 : type_champ1
--------------------- champ information
---------------------
Champ n : type_champ n
Pointeur1 : type_pointeur1
-------------------- champ adresse
--------------------
Pointeur n : type_pointeur n
Pointeur
La flèche signifie ‘’Pointe sur…’’ c’est-à-dire contient l’adresse de…
L’adresse de la
Cellule est à champ Information champ Adresse
l’intérieur
Cellule
Info 1 …… Info n Adresse1 …… Adresse n
TYPE
R = ↑ Cel ;
Cel = ENREGISTREMENT
a : CARACTERE champs Information
b : CHAINE [15]
e : R champ Adresse
FIN
VAR
m : R

Exemple
m ↑ . b ; cette instruction permet d’accéder au champ b de la variable m.
Avec m = pointeur contenant l’adresse d’une cellule.
m↑ = cellule pointée et,
m↑ . b = le champ b de la cellule pointeur par m.
IX.7.4.L’opération d’affectation avec les pointeurs
Elle se fait selon deux syntaxes :
Syntaxe 1
Nom_variable_pointeur ↑ . Nom_champ  valeur ;
ou
Syntaxe 2
Nom_variable_pointeur 1  Nom_variable_pointeur 2 ;
Exemples
m ↑ . b ‘’IG2’’
Pour dire d’affecter la valeur ‘’IG2’’ au champ b de la cellule pointée par le pointeur m.
m ↑ . e  NULL
Pour dire que le champ 2 (qui est aussi un pointeur) de la cellule pointée par m, ne pointe
sur rien.
IX.7.5.Les différentes opérations portant sur une cellule
Il existe deux opérations essentielles portant sur les pointeurs :
− la création d’une cellule
− la destruction d’une cellule.
Création d’une cellule
Cette opération permet de réserver un espace mémoire pour une cellule et d’ »attribuer
l’adresse de cet espace dans une variable de type pointeur.
La syntaxe est :
NOUVEAU (nom_variable_pointeur)
Cette instruction stipule la création d’une cellule qui sera pointée par
nom_variable_pointeur ;
Exemple
TYPE
R = ↑ Cel
Cel = ENREGISTREMENT
a : CARACTERE
b : CHAINE [15]
e : R
FIN
VAR
m : R
------------------------------------------------
Nouveau (m)
Edition - 52 -
Nom_pointeur ↑. nom_champ
@
@

IX.7.6.Destruction d’une cellule
Elle consiste à libérer l’espace mémoire occupé par cette cellule (donc à effacer cette
cellule de la mémoire centrale).
Le mot clé utilisé est DETRUIRE et la syntaxe est :
DETRUIRE (nom_variable_pointeur)
Exemple
TYPE
R =↑ Cel
Cel = EBREGISTREMENT
a : CARACTERE
b: CHAINE [15]
e : R
FIN
VAR
m : R
------------------------------------------
DETRUIRE (m)
Edition - 53 -

IX.8. Exercice d’application
Ecrivez un algorithme qui crée une variable dynamique de type ELEVE et qui permette de
saisir les champs de cette variable.
CORRECTION
Description des ressources
Rôle Identificateur Type Nature Commentaires
Entrée Pt Pt ELEVE Variable Pointeur
d’élève
Description des actions
Création de la variable dynamique via le pointeur Pt
Saisir les champs.
Rédaction de l’algorithme
Algorithme Saisi_dynami
TYPE
ELEVE = ENREGITREMENT
Mat : CHAINE [10]
Nom : CHAINE [20]
Pren : CHAINE [45]
Age, Poids, Taille : REEL
Sex : CARACTERE
Note : TABLEAU[15][3] DE REEL
Datnais = ENREGISTREMENT
JJ, MM, AN : ENTIER
FIN
FIN
PtELEVE = ↑ELEVE
VAR
Pt : PtELEVE
I, J : ENTIER
DEBUT
NOUVEAU (Pt)
ENTRER (Pt↑. Mat, Pt.Nom, Pt↑.Pren, Pt↑.Age)
ENTRER (Pt↑. Poids, Pt↑. Taille, Pt↑. Sex)
ENTRER (Pt↑. Datnais, JJ, Pt↑. Datnais.MM)
ENTRER (Pt↑. Datnais.AN)
POUR I  1 A 15 FAIRE
POUR J  1 A 3 FAIRE
ENTRER (Pt↑.Note [I][J] )
FPOUR
FPOUR
FIN.
Edition - 54 -

IX.9. remarques
Remarque1 :
Lorsqu’une variable de type pointeur est créée, un emplacement mémoire associé est
également créé comme pour tout autre variable. Par contre, la variable pointée n’est pas
créée.
Tant qu’un pointeur n’est pas initialisé, nous considérons qu’il pointe à vide c’est-à-dire nul
part. (valeur NULL).
Autrement dit, toute tentative d’affectation de valeur au contenu d’une adresse pointée par
un pointeur non initialisé provoquera une erreur.
Remarque 2 :
Il faut initialiser le pointeur valeur, en le faisant pointer vers :
Une variable existante
Une variable que l’on va créer tout spécialement
Le contenu d’un autre pointeur de même type
Une adresse spécifiée directement (très risqué) car possibilité d’écraser les données de type
différent
Remarque3 :
Si l’on fait pointer un pointeur vers nul part : NULL (pointeur vide), on perd la valeur pointée.
IX.10. Domaines d’application des pointeurs
Les différents domaines d’application des pointeurs sont :
− Les listes linéaires chaînées (piles et files)
− Les structures de données non linéaires : les arborescences (arbres et graphes)
Edition - 55 -

X. LES LISTES CHAINEES
X.1. Définition
Une liste ou liste linéaire chaînée, est constituée d’un ensemble de cellules linéairement
chaînées entre elles. C’est l’adresse de la 1ère cellule qui détermine la liste, c’est-à-dire que
connaissant l’adresse de la 1ère cellule (son emplacement), l’on peut retrouver toutes les
autres cellules de la liste. (Toutes les cellules de la liste étant toutes liées les unes aux
autres).
Dans une liste chaînée, les éléments sont reliés grâce à un pointeur. Le pointeur indique
l’adresse de l’élément suivant. Les éléments ne sont pas forcément contigus en mémoire,
contrairement aux éléments des tableaux.
X.2. création d’une liste chaînée
 Déclaration d’un type pointeur qui va pointer sur un enregistrement.
 Déclaration d’un type enregistrement contenant un ou des champs de type pointeur
précédemment déclaré.
 Déclaration des autres variables manipulées
 Utiliser un pointeur qui va pointer sur la première cellule créée.
 Une fois le champ information de la 1ère
cellule, rempli, pointer la zone adresse de
cette 1ère
cellule sur une nouvelle cellule créée (la 2ème
cellule) et ainsi de suite…
 A la fin de la liste, le champ adresse de la dernière cellule pointe sur NULL.
TYPE
<Identificateur_de_type_pointeur> = ↑Identificateur de_type_enregistrement
<Identificateur_de_type_enregistrement> = ENREGISTREMENT
<Liste_de_champs>
FIN
Exemple
Ecrivez un algorithme qui permet de créer une liste d’élèves d’une classe de IG1 où les
étudiants composent dans 15 matières et ont 3 notes par matières.
CORRECTION
Description des ressources
Rôle Identificateur Type Nature Commentaires
Entrée Pt PtELEVE Variable
Contient l’adresse des
variables dynamiques :
successivement créées
E/S Rep
CARACTERE Variable
Réponse à la suite de la
saisie
Interne TETE (début de PtELEVE Variable Identifie le début de la
Edition - 56 -

la chaîne) liste : TETE
Description des actions
Initialisation de TETE à NULL.
Répéter les actions jusqu’à Rep = ‘N’.
Créer dynamiquement une cellule ‘eleve’ et la rattacher à ‘TETE’ (début de la liste).
Demander la confirmation pour la suite de la saisie.
Rédaction de l’algorithme.
ALGORITHMME CRELIST1
TYPE
PtELEVE = ↑ELEVE
ELEVE = ENREGISTREMENT
Mat : CHAINE[10]
Nom : CAHINE[20]
Pren : CHAINE[45]
Age, Poids, Taille : REEL
Sex : CARACTERE ;
Note : TABLEAU [15][3] de REEL
Datnais = ENREGISTREMENT
JJ, MM, AN : ENTIER
FIN
PtELESVT: PtELEVE
FIN
VAR
Rep : CAHINE[3]
I, J : ENTIER
TETE,Pt,: PtELEVE
DEBUT
TETE  NULL ;
REPETER
NOUVEAU (Pt)
AVEC Pt↑ FAIRE
ENTRER (Mat, Nom, Pren, Poids, Taille, Sex);
POUR I  1 à 15 FAIRE
POUR J  1 à 3 FAIRE
ENTRER (Note[I[J])
FPOUR
FPOUR
AVEC Datnais FAIRE
ENTRER (JJ, MM, AN) ;
FINAVEC
PtELESVT  TETE
TETE  Pt
FINAVEC
AFFICHER (‘Y-a-t-il un autre étudiant à saisir, (OUI /NON) ?)
ENTRER (Rep)
JUSQU'A Rep = ‘NON’
FIN.
X.3. Les différentes opérations sur les listes chaînées
Parmi elles, on peut citer les opérations suivantes :
 la consultation d’une liste déjà créée
 la suppression d’un élément d’une liste
Edition - 57 -

 l’insertion d’une cellule dans une liste
 la suppression d’une liste.
Remarque :
Toutes les opérations sur les listes sont subordonnées à l’opération de création de la liste.
Voyons parmi elles, l’exemple de la consultation.
La consultation
Je souhaite consulter la liste initialement créée. Ecrivez un algorithme qui permet de le faire.
ALGORITHME CONLIST //consultation d’une liste (déjà créée)
TYPE
// voir précédent exemple
VAR
TETE, Pt : PtELEVE
I, J : ENTIER
DEBUT
Pt  TETE
TANTQUE (Pt <>NULL) FAIRE
AVEC Pt↑ FAIRE
AFFICHER (Mat, Nom, Pren, Age, Poids, Taille, Sex)
POUR I  1 à 15 FAIRE
POUR J  1 A 3 FAIRE
AFFICHER (Note [I, j]
FPOUR
FPOUR
AVEC Datnais FAIRE
AFFICHER (JJ, MM, AN)
FINAVEC
Pt  PtELESVT
FINAVEC
FTQ
FIN
X.4. Les piles
X.4.1. Définition
Une pile est une structure restrictive de liste chaînée qui ne permet les ajouts et les
suppressions qu’à une de ses extrémités appelée ‘’sommet’’. C’est ce qu’on appelle la
structure de liste LIFO( Last In First Out) qui est gérée comme une pile d’assiettes, ajout au
dessus, suppression au dessus. Tout cela à la différence de la liste chaînée où l’insertion et
la suppression de cellules se font à n’importe quel endroit de la liste.
Edition - 58 -

X.4.2. Applications des piles
Les piles sont couramment utilisées par le système d’exploitation, en particulier par l’unité
arithmétique et logique lors de ces calculs.
Elles servent à créer les menus et les sous-menus, à gérer les appels de sous-programmes
au niveau des ordinateurs et téléphones portables.
X.4.3. Les différentes opérations sur une pile
Nous avons deux opérations différentes sur une pile :
L’empilement ou l’insertion d’élément par le sommet de la pile.
Le dépilement ou la suppression d’élément ou l’enlèvement de l’élément se trouvant au
sommet de la pile.
X.5. Les files
X.5.1. Définition
Une file est une structure restrictive d’une liste linéaire chaînée qui ne permet les ajouts qu’à
une de es extrémités appelée ‘‘tête’’, et les suppressions à l’autre extrémité appelée ‘’
queue’’. C’est la structure de liste F.I.F.O (First In First Out), gérée comme une file d’attente
à un taxi, ajout à la fin de la file, suppression au début.
X.5.2. Application des files
Elles sont utilisées couramment par le système d’exploitation, par exemple lors de la gestion
des programmes en attente du processeur central ou en attente de la disponibilité de
l’imprimante
X.6. Les listes doublement chaînées
Les listes doublement chaînées sont des listes où chaque élément pointe sur son suivant et
sur son précédent. Le parcours d'une telle liste peut se faire dans les deux sens. Ce type de
liste facilite en outre l'ajout d'un élément au milieu de la liste de sorte que celle-ci reste triée.
Le premier élément possède un pointeur qui pointe sur la tête. Le dernier élément possède
un pointeur qui pointe sur la queue.
Edition - 59 -

Type
Ptelem =↑elem
Telem = enregsitrement
info : type de l'info
psuiv : Ptelem
pprec : Ptelem
Fin enregistrement
Edition - 60 -

XI. INTRODUCTION AUX ARBRES.
XI.1. Introduction
Cet article présente la structure de données arborescente appelé aussi arbre. Ce type de
structure de données est très utilisé quelle que soit le type d'application. En effet, ce type de
structure de données si elle est bien utilisée donne de très bonnes performances. On la
retrouvera donc dans les systèmes de bases de données ou bien encore dans l'organisation
d'un système de fichiers d'un système d'exploitation.
XI.2. Définitions
Un arbre est une structure qui peut se définir de manière récursive : un arbre est un arbre
qui possède des liens ou des pointeurs vers d'autres arbres. Cette définition plutôt étrange
au premier abord résume bien la démarche qui sera utilisé pour réaliser cette structure de
données.
Toutefois, cette définition est un peu vague, et nous allons introduire de nouvelles définitions
pour mieux caractériser et identifier les arbres.
XI.2.1.Arbres enracinés
On distingue deux grands types d'arbres : les arbres enracinés et les arbres non enracinés.
Le premier type d'arbre est celui qui nous intéressera le plus. Un arbre enraciné est un arbre
hiérarchique dans lequel on peut établir des niveaux. Il ressemblera plus à un arbre
généalogique tel qu'on le conçoit couramment. Voici un exemple d'arbre enraciné :
Exemple d'arbre enraciné.
XI.2.2.Arbres non enracinés
Le deuxième grand type d'arbre est un arbre non enraciné. Il n'y a pas de relation d'ordre ou
de hiérarchie entre les éléments qui composent l'arbre. On peut passer d'un arbre non
enraciné à un arbre enraciné. Il suffit de choisir un élément comme sommet de l'arbre et de
l'organiser de façon à obtenir un arbre enraciné. Voici un exemple d'arbre non enraciné :
Edition - 61 -

Exemple d'arbre non enraciné
Vous remarquerez qu'il y a équivalence entre les deux arbres précédents. En effet, en
réorganisant l'arbre non enraciné, on peut obtenir strictement le même arbre que le premier.
En revanche, ce n'est qu'un exemple d'arbre enraciné que l'on peut effectuer avec cet arbre
non enraciné, il en existera d'autres.
Dans la suite, nous nous intéresserons uniquement aux arbres enracinés.
XI.2.3.Terminologie
Précisons maintenant un peu plus les termes désignant les différents composant d'un arbre.
Tout d'abord, chaque élément d'un arbre se nomme un noeud. Les noeuds sont reliés les
uns aux autres par des relations d'ordre ou de hiérarchie. Ainsi on dira qu'un noeud possède
un père, c'est à dire un noeud qui lui est supérieur dans cette hiérarchie. Il possède
éventuellement un ou plusieurs fils.
Il existe un noeud qui n'a pas de père, c'est donc la racine de l'arbre. Un noeud qui n'a pas
de fils est appelé un feuille. Parfois on appelle une feuille un noeud externe tout autre noeud
de l'arbre sera alors appelé un noeud interne.
Voici donc un schéma qui résume les différents composant d'un arbre :
Edition - 62 -

Description des différents composants d'un arbre
XI.2.4.Arité d'un arbre
On a aussi envie de qualifier un arbre sur le nombre de fils qu'il possède. Ceci s'appelle
l'arité de l'arbre. Un arbre dont les noeuds ne comporteront qu'au maximum n fils sera
d'arrité n. On parlera alors d'arbre n-aire. Il existe un cas particulièrement utilisé : c'est
l'arbre binaire. Dans un tel arbre, les noeuds ont au maximum 2 fils. On parlera alors de fils
gauche et de fils droit pour les noeuds constituant ce type d'arbre.
L'arité n'impose pas le nombre minimum de fils, il s'agit d'un maximum, ainsi un arbre d'arité
3 pourra avoir des noeuds qui ont 0,1,2 ou 3 fils, mais en tout cas pas plus.
On appelle degré d'un noeud, le nombre de fils que possède ce noeud.
La suite de cet article portera uniquement sur les arbres binaires puisque c'est le type
d'arbre le plus basique à étudier mais aussi parce que tout ce que vous verrez sur un arbre
binaire est valable pour un arbre n-aire.
De plus il est possible de passer d'un arbre n-aire à un arbre binaire. Voici un exemple de
passage d'un arbre généalogique (qui par définition n'est pas forcément binaire) à un arbre
binaire.
Voici donc l'arbre généalogique de base :
Arbre généalogique des Valois directs
Edition - 63 -

En remarquant qu'on peut mettre sur les fils gauche les enfants et sur les fils droit les frères
et soeurs on en déduit donc que l'on peut construire un arbre binaire à partir de l'arbre n-
aire. Voici donc l'arbre que nous obtenons :
Arbre généalogique mis sous forme d'arbre binaire
Comme vous pouvez le constater, il est assez difficile de lire ce genre d'arbre et
généralement on remonte au même niveau les noeuds de la même génération. Ainsi un
noeud n'a pas de fils gauche et de fils droit mais un fils et un frère. Voici à quoi peut
ressembler l'arbre précédent dans ce cas:
Edition - 64 -

Arbre généalogique mis sous forme d'arbre binaire
On distingue alors mieux les générations : sur la même ligne nous avons les frères et
soeurs.
XI.2.5.Taille et hauteur d'un arbre.
On appelle la taille d'un arbre, le nombre de noeud interne qui le compose. C'est à dire le
nombre noeud total moins le nombre de feuille de l'arbre.
On appele également la profondeur d'un noeud la distance en terme de noeud par rapport à
l'origine. Par convention, la racine est de profondeur 0. Dans l'exemple suivante le noeud F
est de profondeur 2 et le noeud H est de profondeur 3.
La hauteur de l'arbre est alors la profondeur maximale de ses noeud. C'est à dire la
profondeur à laquelle il faut descendre dans l'arbre pour trouver le noeud le plus loin de la
racine.On peut aussi définir la hauteur de manière récursive : la hauteur d'un arbre est le
maximum des hauteur ses fils. C'est à partir de cette définition que nous pourrons exprimer
un algorithme de calcul de la hauteur de l'arbre.
Edition - 65 -

La hauteur d'un arbre est très importante. En effet, c'est un repère de performance. La
plupart des algorithmes que nous verrons dans la suite ont une complexité qui dépend de la
hauteur de l'arbre. Ainsi plus l'arbre aura une hauteur élevée, plus l'algorithme mettra de
temps à s'exécuter.
XI.3. Arbre localement complet, dégénéré, complet.
Un arbre binaire localement complet est un arbre binaire dont chacun des noeuds
possèdent soit 0 soit 2 fils. Ceci veut donc dire que les noeuds internes auront tous deux fils.
Dans ce type d'arbre, on peut établir une relation entre la taille de l'arbre et le nombre de
feuille. En effet, un arbre binaire localement complet de taille n aura n+1 feuille. L'arbre
suivant est localement complet :
Exemple d'arbre localement complet
Un arbre dégénéré (appelé aussi filiforme) est un arbre dont les noeuds ne possède qu'un et
un seul fils. Cet arbre est donc tout simplement une liste chaînée. Ce type d'arbre est donc à
éviter, puisqu'il n'apportera aucun avantage par rapport à une liste chaînée simple. On a
alors une relation entre la hauteur et la taille : un arbre dégénéré de taille n a une hauteur
égale à n+1. L'arbre suivant est un arbre dégénéré.
Exemple d'arbre dégénéré
Edition - 66 -

On appellera arbre binaire complet tout arbre qui est localement complet et dont toutes les
feuilles ont la même profondeur. Dans ce type d'arbre, on peut exprimer le nombre de
noeuds n de l'arbre en fonction de la hauteur h : n = 2^(h+1) -1.
Exemple d'arbre complet
XI.4. Implémentation
Nous allons maintenant discuter de l'implémentation des arbres. Tout d'abord,définissons le
noeud. Un noeud est une structure (ou un enregistrement) qui contient au minimum trois
champs : un champ contenant l'élément du noeud, c'est l'information qui est importante.
Cette information peut être un entier, une chaîne de caractère ou tout autre chose que l'on
désire stocker. Les deux autres champs sont le fils gauche et le fils droit du noeud. Ces des
fils sont en fait des arbres, on les appelle généralement les sous arbres gauches et les sous
arbres droit du noeud. De part cette définition, un arbre ne pourra donc être qu'un pointeur
sur un noeud.
XI.4.1.Utilisation de pointeurs:
A chaque nœud sont associés deux pointeurs, un pour chaque sous arbre, plus, le cas
échéant, une étiquette (valeur de l'élément). L'arbre est déterminé par l'adresse de sa
racine.
TYPE ARBRE = ^Nœud
TYPE Nœud = ENREGISTREMENT
val: Elément
g,d: ARBRE
Fin
De par cette définition, on peut donc aisément constater que l'arbre vide sera représenté par
la constante NULL.
XI.4.2.Utilisation de tableaux
Un arbre contenant moins de N nœuds peut etre représenté dans un tableau de taille N.
Le type abstrait correspondant est le suivant:
TYPE
MTAB = TABLEAU[N] de ENREGISTREMENT
val: Elément
G, D: 0..N
Fin
Edition - 67 -

ARBTAB = ENREGISTREMENT
racine: 0..N
TAB: MTAB
Fin
Ainsi dans ce cas, les fils ne seront pas identifiés par leur position (droite ou gauche) mais par un
numéro.
XI.5. signature
La signature du type abstrait arbre binaire est la suivante:
Sorte Arbre
Utilise Nœud, Elément
Opérations
Arbre-vide :  arbre
(-,-,-) : nœud x arbre x arbre  arbre
racine : arbre  nœud
g : arbre  arbre
d : arbre - arbre
contenu : nœud  élément
pré conditions
racine(B) est défini ssi B1 <> arbre-vide
g(B1) est défini ssi B1 <> arbre-vide
d(B1) est défini ssi B1 <> arbre-vide
Axiomes
racine((r,B1,B2)) = r
g((r,B1,B2)) =B1
d((r,B1,B2)) =B2
Expressions dans lesquelles B1 et B2 sont de sorte Arbre et r
une variable de sorte Nœud.
XI.6. Les fonctions de base sur la manipulation des arbres.
Afin de faciliter notre manipulation des arbres, nous allons créer quelques fonctions. La
première détermine si un arbre est vide. Le pseudo code associé est simple :
fonction EstVide( T : arbre ) renvoie un booléen
si T == Null alors
renvoyer vrai
sinon
renvoyer faux
fin si
La constante Null est différente suivant le langage que vous utiliserez, elle peut être null,
nul, nil ou encore NULL. C'est à vous à adapter le code en fonction du langage dans lequel
vous volez implémenter un module de manipulation d'arbres binaires. Nous partons
simplement du principe que le langage que vous utilisez dispose du type pointeur (ou d'un
équivalent).
Voici ce que peut donner cette fonction en langage C :
bool EstVide( tree T)
{
return T == NULL
}
Edition - 68 -

Maintenant, prenons deux fonctions qui vont nous permettre de récupérer le fils gauche
ainsi que le fils droit d'un arbre. Il faut faire attention à un problème : le cas où l'arbre est
vide. En effet, dans ce cas, il n'existe pas de sous arbre gauche ni de sous arbre droit. Pour
régler ce problème nous décidons arbitrairement de renvoyer l'arbre vide comme fils d'un
arbre vide. Voici ce que celà peut donner en pseudo code :
fonction FilsGauche( T : arbre ) renvoie un arbre
si EstVide(T) alors
renvoyer arbre_vide
sinon
renvoyer sous arbre gauche
fin si
La fonction qui retourne le fils droit sera codé de la même manière mais tout simplement au
lieu de renvoyer le fils gauche, nous renvoyons le fils droit.
Passons à une autre fonction qui peut nous être utile : savoir si nous sommes sur une
feuille. Voici tout d'abord le pseudo code :
fonction EstUneFeuille(T : arbre) renvoie un booléen.
{
si EstVide(T) alors
renvoyer faux
sinon si EstVide(FilsGauche(T)) et EstVide(FilsDroit(T)) alors
renvoyer vrai
sinon
renvoyer faux
fin si
}
Enfin, nous pouvons créer une dernière fonction bien que très peu utile : déterminer si un
noeud est un noeud interne. Pour ce faire, deux méthodes : soit on effectue le test classique
en regardant si un des fils n'est pas vide, soit on utilise la fonction précédente.
Voici le pseudo code utilisant la fonction précédente :
fonction EstNoeudInterne( T : arbre ) renvoie un booléen
si EstUneFeuille(T) alors
renvoyer faux
sinon
renvoyer vrai
fin si
XI.7. Algorithmes de base sur les arbres binaires
Nous présentons les algorithmes de base sur les arbres. Sachez qu'ici c'est le domaine de
la récursivité. Si vous êtes réticent à ce genre de fonction, il faut savoir qu'il n'y a pas
d'autres alternatives. Mais rassurez vous, nous allons procéder en douceur, les fonctions
que nous allons voir ne sont pas compliquée. De plus, le schéma est quasiment le même,
une fois que vous aurez vu deux ou trois fois ce schéma, tout ira bien.
a. Calcul de la hauteur d'un arbre
Pour calculer la hauteur d'un arbre, nous allons nous baser sur la définition récursive :
Edition - 69 -

- un arbre vide est de hauteur 0
- un arbre non vide a pour hauteur 1 + la hauteur maximale entre ses fils.
De part cette définition, nous pouvons en déduire un algorithme en pseudo code :
fonction hauteur ( T : arbre ) renvoie un entier
si T est vide
renvoyer 0
sinon
renvoyer 1 + max (hauteur ( FilsGauche(T)) , hauteur(FilsDroit(T) )
fin si
La fonction max n'est pas définie c'est ce que nous faisons maintenant :
Le lecteur pourra s’amuser à créer cette fonction max()
2. Calcul du nombre de noeud
Le calcul du nombre de noeud est très simple. On définit le calcul en utilisant la définition
récursive :
- Si l'arbre est vide : renvoyer 0
- Sinon renvoyer 1 plus la somme du nombre de noeuds des sous arbres.
On aura donc le pseudo code suivant :
fonction NombreNoeud( T : arbre ) renvoie un entier
si ( EstVide( T ) )
renvoyer 0
sinon
renvoyer 1 + NombreNoeud(FilsGauche(T)) + NombreNoeud(FilsDroit(T))
fin si
3. Calcul du nombre de feuilles
Le calcul du nombre de feuille repose sur la défintion récursive :
- un arbre vide n'a pas de feuille.
- un arbre non vide a son nombre de feuille défini de la façon suivante :
- si le noeud est une feuille alors on renvoie 1
- si c'est un noeud interne alors le nombre de feuille est la somme du
nombre de feuille de chacun de ses fils.
Voici le pseudo code que nous pouvons en tirer :
fonction nombreFeuille ( T : arbre ) renvoie un entier
si T est vide alors
renvoyer 0;
sinon si T est une feuille alors
renvoyer 1
sinon
renvoyer nombrefeuille( FilsGauche(T) ) +
nombrefeuille( FilsDroit(T) )
fin si
4. Nombre de noeud internes
Maintenant, pour finir avec les algorithmes de base, nous allons calculer le nombre de
noeud interne, Cela repose sur le même principe que le calcul du nombre de feuille. La
définition récursive est la suivante :
- un arbre vide n'a pas de noeud interne.
Edition - 70 -

- si le noeud en cours n'a pas de fils alors renvoyer 0
- si le noeud a au moins un fils, renvoyer 1 plus la somme des noeuds interne des sous
arbres.
On en déduit donc aisément le pseudo code correspondant :
fonction NombreNoeudInterne(T : arbre ) renvoie un entier
si EstVide(T) alors
renvoyer 0
sinon si EstUneFeuille(T) alors
renvoyer 0
sinon
renvoyer 1 + NombreNoeudInterne(FilsGauche(T)) +
NombreNoeudInterne(FilsDroit(T))
XI.8. Parcours d'un arbre
Nous allons découvrir des algorithmes de parcours d'un arbre. Cela permet de visiter tous
les noeuds de l'arbre et éventuellement appliquer une fonction sur ces noeud. Nous
distinguerons deux types de parcours : le parcours en profondeur et le parcours en largeur.
Le parcours en profondeur permet d'explorer l'arbre en explorant jusqu'au bout une branche
pour passer à la suivante. Le parcours en largeur permet d'explorer l'arbre niveau par
niveau. C'est à dire que l'on va parcourir tous les noeuds du niveau 1 puis ceux du niveau
deux et ainsi de suite jusqu'à l'exploration de tous les noeuds.
XI.8.1.Parcours en profondeur
Ce parcours consiste, en partant de la racine, à considérer de proche en proche les nœuds
les plus à gauche de l'arbre y compris les feuilles vides. Ainsi chaque nœud est rencontré
trois fois comme le montrent les figures suivantes:
Premier passage second passage troisième
passage
Le parcours en profondeur de l'arbre suivant donne : 1,2,3,4,5,6,7,8,9,10 :
Edition - 71 -

Parcours préfixe de l'arbre : 1-2-3-4-5-6-7-8-9-10
Ceci n'est en fait qu'un seul parcours en profondeur de l'arbre. Il s'agit d'un parcours d'arbre
en profondeur à gauche d'abord et préfixe. Précisons. tout de suite ces termes.
Un parcours en profondeur à gauche est simple à comprendre, cela signifie que l'on
parcours les branches de gauche avant les branches de droite. On aura dons deux types de
parcours : un parcours à gauche et un parcours à droite. Dans la plupart des cas, nous
utiliserons un parcours à gauche.
La deuxième caractéristique de notre arbre est le parcours dit préfixe. Celà signifie que l'on
affiche la racine de l'arbre, on parcourt tout le sous arbre de gauche, une fois qu'il n'y a plus
de sous arbre gauche on parcourt les éléments du sous arbre droit. Ce type de parcours
peut être résumé en trois lettres : R G D (pour Racine Gauche Droit). On a aussi deux
autres types de parcours : le parcours infixe et le parcours suffixe (appelé aussi postfixe). Le
parcours infixe affiche la racine après avoir traité le sous arbre gauche, après traitement de
la racine, ontraite le sous arbre droit (c'est donc un parcours G R D). Le parcours postfixe
effectue donc le dernier type de schéma : sous arbre gauche, sous arbre droit puis la racine,
c'est donc un parcours G D R. Bien sur, nous avons fait l'hypothèse d'un parcours à gauche
d'abord mais on aurait pû aussi faire un parcours à droite d'abord.
Commençons par le parcours préfixe, celui ci traite la racine d'abord.
procedure parcours_prof_prefixe( T : arbre )
si non EstVide(T) alors
traiter_racine(T);
parcours_prof_prefixe(FilsGauche(T))
parcours_prof_prefixe(FilsDroit(T))
fin si
La fonction (ou procédure) traiter_racine, est une fonction que vous définissez vous même, il
s'agit par exemple d'une fonction d'affichage de l'élément qui est à la racine.
Maintenant le parcours infixe :
Edition - 72 -

procedure parcours_prof_infixe( T : arbre )
parcours_prof_infixe(FilsGauche(T))
traiter_racine(T)
parcours_prof_infixe(FilsDroit(T))
fin si
Et enfin le parcours suffixe :
proceure parcours_prof_suffixe(T : arbre )
parcours_prof_suffixe(FilsGauche(T))
parcours_prof_suffixe(FilsDroit(T))
traiter_racine(T);
fin si
Voilà pour les trois fonctions de parcours. Vous remarquerez que seul le placement de la
fonction (ou procédure) traiter_racine diffère d'une fonction à l'autre.
XI.8.2. Parcours en largeur (ou par niveau)
Nous allons aborder un type de parcours un peu plus compliqué, c'est le parcours en
largeur. Il s'agit d'un parcours dans lequel, on traite les noeuds un par un sur un même
niveau. On passe ensuite sur le niveau suivant, et ainsi de suite. Le parcours en largeur de
l'arbre suivant est : 1 2 3 4 5 6 7 8 9 10.
Parcours en largeur de l'arbre
Une méthode pour réaliser un parcours en largeur consiste à utiliser une structure de
données de type file d'attente. Pour ceux qui ne connaissent pas encore ce type de structure
de données, il s'agit tout simplement d'une structure de données qui est obéit à la règle
suivante : premier entrée, premier sorti.
Edition - 73 -

Pour en revenir à notre parcours, le principe est le suivant, lorsque nous somme sur un
noeud nous traitons ce noeud (par exemple nous l'affichons) puis nous mettons les fils
gauche et droit non vides de ce noeud dans la file d'attente, puis nous traitons le prochain
noeud de la file d'attente.
Au début, la file d'attente ne contient rien, nous y plaçons donc la racine de l'arbre que nous
voulons traiter. L'algorithme s'arrête lorsque la file d'attente est vide. En effet, lorsque la file
d'attente est vide, cela veut dire qu'aucun des noeuds parcourus précédemment n'avait de
sous arbre gauche ni de sous arbre droit. Par conséquent, on a donc bien parcouru tous les
noeuds de l'arbre.
On en déduit donc le pseudo code suivant :
procedure parcours_largeur(T : arbre)
Creer_File_D'attente F
ajouter(F,T);
tant que F n'est pas vide faire
X  extraire(F);
Traiter_racine(X);
si non EstVide(FilsGauche(X)) alors
ajouter(F,FilsGauche(X));
fin si
si non EstVide(FilsDroit(X)) alors
ajouter(F,FilsDroit(X));
fin si
fin faire
Appliquons ce pseudo code à l'arbre suivant :
Au tout début de l'algorithme, la file ne contient rien, on y ajoute donc l'arbre, la file d'attente
devient donc :
Edition - 74 -

Etat de la file d'attente
On traite la racine puis on y ajoute les fils droits et gauche, la file vaut donc :
Etat de la file après la première itération
On traite ensuite le prochain élément de la file d'attente. Ce noeud n'a pas de sous arbre, on
ajoute donc rien à la file. Celle ci vaut donc :
Etat de la file après la deuxième itération
On traite le prochain noeud dans la file d'attente. Celui ci a un fils droit, nous l'ajoutons donc
à la file d'attente. Cette dernière ne contient donc maintenant plus qu'un noeud :
Etat de la file après la troisième itération
On traite ce noeud. Celui ci n'ayant pas de fils, nous n'ajoutons donc rien à la file. La file est
désormais vide, l'algorithme se termine.
Edition - 75 -

XI.9. Opérations élémentaires sur un arbre
Maintenant que nous savons parcourir un arbre, que nous savons obtenir des informations
sur un arbre, il serait peut être temps de créer un arbre, de l'alimenter et enfin de supprimer
des éléments.
XI.9.1.Création d'un arbre
On peut distinguer deux types de création d'un arbre : création d'un arbre vide, et création
d'un arbre à partir d'un élément et de deux sous arbres. La première méthode est très
simple, étant donné que nous avons crée un arbre comme étant un pointeur, un arbre vide
est donc un pointeur Null. La fonction de création d'un arbre vide est donc une fonction qui
nous renvoie la constante Null.
La deuxième fonction est un peu plus compliquée mais rien de très impressionnant. Il faut
tout d'abord créer un nœud, ensuite, on place dans les fils gauche et droit les sous arbres
que l'on a passés en paramètre ainsi que la valeur associée au nœud. Enfin, il suffit de
renvoyer ce nœud. En fait, ce n'est pas tout à fait exact, puisque ce n'est pas un nœud mais
un pointeur sur un nœud qu'il faut renvoyer. Mais nous utilisons le terme nœud pour
spécifier qu'il faut allouer un nœud en mémoire.
Voici le pseudo code de la deuxième fonction :
fonction CreerArbre(val : TElement, fg : arbre , fd : arbre ) renvoie un
arbre
X  Allouer un nœud en mémoire
X.valeur  val
X.fils_gauche  fg
X.fils_droit  fd
renvoyer X;
Notre fonction renvoie NULL s'il a été impossible d'allouer le nœud. Ceci est un choix
arbitraire, vous pouvez très bien effectuer d'autres opérations à la place.
XI.9.2.Ajout d'un élément
- si l'arbre dans lequel on veut insérer notre élément est vide,
alors il s'agit d'une création d'arbre.
- sinon, si le nœud en cours a un fils vide, alors on insère dans le fils vide.
-sinon, on insère dans le fils gauche.
Vous remarquerez que l'on insère du coté gauche, ceci aura pour effet de produire un
peigne gauche, et si on insérait du coté droit, nous aurions un peigne droit.
Nous pouvons donc écrire le pseudo code correspondant :
procédure AjouteNoeud( src : arbre, elt : TElement )
si EstVide(src) alors
src  CreerArbre(elt,Null,Null)
sinon
si EstVide(FilsGauche(src)) alors
srcgauche  CreerArbre(elt,Null,Null)
sinon
si EstVide(FilsDroit(src)) alors
Edition - 76 -

srcdroit CreerArbre(elt,Null,Null)
sinon
AjouteNoeud(FilsGauche(src),elt)
fin si
fin si
fin si
XI.9.3.Recherche dans un arbre
Après avoir alimenté notre arbre, il serait peut être temps d'effectuer des recherches sur
notre arbre. Il ya principalement deux méthodes de recherche. Elles sont directement liées
au type de l'arbre : si l'arbre est quelconque et si l'arbre est un arbre de recherche.
Nos recherches se contenteront seulement de déterminer si la valeur existe dans l'arbre.
Commençons par chercher l’élément dans un arbre quelconque. Cette méthode est la plus
intuitive : on cherche dans tous les noeuds de l'arbre l'élément. Si celui ci est trouvé, on
renvoie vrai, si ce n'est pas le cas, on renvoie faux.
Voici le pseudo code associé.
fonction Existe(src : arbre, elt : TElement) renvoie un booléen
si EstVide(src)
renvoyer faux
sinon
si srcvalue = elt alors
renvoyer vrai
sinon
renvoyer Existe(FilsGauche(src),elt ) ou
Existe(FilsDroit(src), elt)
fin si
sin si
Nous renvoyons un ou logique entre le sous arbre gauche et le sous arbre droit, pour
pouvoir renvoyer vrai si l'élement existe dans l'un des sous arbres et faux sinon.
Ce genre de recherche est correcte mais n'est pas très performante. En effet, il faut
parcourir quasiment tous les nœuds de l'arbre pour déterminer si l'élément existe.
C'est pour cela que sont apparus les arbres binaires de recherche. En effet, on les nomme
ainsi parce qu'ils optimisent les recherches dans un arbre. Pour savoir si un élément existe,
il faut parcourir seulement une branche de l'arbre. Ce qui fait que le temps de recherche est
directement proportionnel à la hauteur de l'arbre.
L'algorithme se base directement sur les propriétés de l'arbre, si l'élement que l'on cherche
est plus petit que la valeur du nœud alors on cherche dans le sous arbre de gauche, sinon,
on cherche dans le sous arbre de droite.
Voici le pseudo code correspondant :
fonction ExisteR( src : arbre, elt : TElement )
si EstVide(src) alors
renvoyer faux
sinon
si src>valeur = elt alors
renvoyer vrai;
sinon
Edition - 77 -

si srcvaleur > elt alors
renvoyer ExisteR(FilsGauche(src) , elt )
sinon
renvoyer ExisteR(FilsDroit(src) , elt )
fin si
fin si
fin si
XI.9.4.Suppression d'un arbre
Nous allons terminé cet article par la suppression d'éléments d'un arbre, ou plutôt la
destruction complète d'un arbre.
Par suppression de nœud, nous entendrons suppression d'une feuille. En effet, un nœud qui
possède des fils s'il est supprimé, entraîne une réorganisation de l'arbre.
L'algorithme de suppression de l'arbre est simple : on supprime les feuilles une par unes. On
répète l'opération autant de fois qu'il y a de feuilles. Cette opération est donc très
dépendante du nombre de nœud.
En fait cet algorithme est un simple parcours d'arbre. En effet, lorsque nous devrons traiter
la racine, nous appelerons une fonction de suppression de la racine. Comme nous avons dis
plutôt que nous ne supprimerons que des feuilles, avant de supprimer la racine, il faut
supprimer les sous arbres gauche et droit. On en déduit donc que l'algorithme de
suppression est un parcours d'arbre postfixe.
Voici le pseudo code associé :
procédure supprime( src : arbre )
si non EstVide(src) alors
supprime(FilsGauche(src))
supprime(FilsDroit(src))
supprimeNoeud(src)
fin si
Edition - 78 -

INITIATION_ALGO_NAB_2006

Contenu connexe

Tendances

En vedette

Similaire à INITIATION_ALGO_NAB_2006

INITIATION_ALGO_NAB_2006