Cours Première Année

Équipe Pédagogique

Dr MESSI NGUELE Thomas

Dr NKONJOH Armel

M. KEUDEM ZONING Steve

M. MOGO WAFO Régis Audran

M. NITCHEU TSACHOUA Hermann Junior

M. WABO TATCHUM Ghislain

Année académique 2023-2024

Contents

1 Introduction à l’architecture des Ordinateurs 3

1.1 Machine de Von Neumann et machine de Harvard . . . . . . . . . . . . . 3
1.1.1 Machine de Von Neumann . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 La Machine de Harvard . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.3 Différence entre les architectures de Von Neumann et Harvard . . 5
1.2 Composants d’un ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2 Structure en couches des machines modernes . . . . . . . . . . . . 7
1.2.3 Configuration d’ un ordinateur ou d’ un système informatique . . 8
1.2.4 es principaux organes d’ un ordinateur . . . . . . . . . . . . . . . 10
1.3 INTRODUCTION A LA PROGRAMMATION ASSEMBLEUR . . . . . 15
1.3.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.2 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.3.3 Les Directives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.4 Exemple complet d’un code assembleur . . . . . . . . . . . . . . . 18
1.3.5 Exercices en Assembleur . . . . . . . . . . . . . . . . . . . . . . . 19

2 Introduction à l’algorithmique 21
2.1 Rôle des Algorithmes en Informatique . . . . . . . . . . . . . . . . . . . . 21
2.1.1 Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.1.2 Exemple de problèmes susceptibles d’être résolus par les algorithmes 22
2.1.3 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.4 Problèmes difficiles . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.5 Influence des algorithmes sur la technologie . . . . . . . . . . . . . 22
2.2 Langage Algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.1 Structure d’un algorithme . . . . . . . . . . . . . . . . . . . . . . 22
2.2.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3
4 CONTENTS

2.2.3 Instructions de lecture et Écriture . . . . . . . . . . . . . . . . . . 27

2.2.4 Structure Alternatives . . . . . . . . . . . . . . . . . . . . . . . . 28
2.2.5 Structure itératives . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3 Structures de données de base . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.1 Pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.2 Listes Chainées: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.3.3 Listes Doublement Chainées: . . . . . . . . . . . . . . . . . . . . . 32
2.3.4 Exercices: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.3.5 Piles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.3.6 Opérations sur une pile. . . . . . . . . . . . . . . . . . . . . . . . 34
2.3.7 Files: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3.8 Opération sur une file . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.9 Exercices d’application: . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.10 Éléments de correction: . . . . . . . . . . . . . . . . . . . . . . . . 36
2.4 Procédures et Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.4.1 Syntaxe d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . 42
2.4.2 Syntaxe d’une procédure . . . . . . . . . . . . . . . . . . . . . . . 42
2.4.3 Transmission des paramètres . . . . . . . . . . . . . . . . . . . . . 43
2.4.4 Fonctions recursives . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.5 Analyse des algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.5.1 Généralités. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.5.2 Ordre de Grandeur – Notation de Landau. . . . . . . . . . . . . . 45
2.5.3 Résolution des équations . . . . . . . . . . . . . . . . . . . . . . . 48

3 Logiciels Applicatifs 51
3.1 Excel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.2 Word . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.3 Powerpoint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.4 Latex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.5 Latex Beamer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

4 Introduction à la Programmation en C 53
4.1 Syntaxe Générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2 Instructions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3 Fonction et Procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
CONTENTS 1

4.4 Structures de Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

4.5 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.6 Projet en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

5 Introduction au réseau informatique 55

5.1 Généralité sur les réseaux . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.2 Modèle OSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.3 Modèle TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.4 Reséaux Filaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.5 Réseaux Wifi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6 Introduction aux Sytèmes d’Exploitation 57

6.1 Introduction au Système Windows . . . . . . . . . . . . . . . . . . . . . . 57
6.2 Introduction au Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.3 Indroduction à l’administration Système . . . . . . . . . . . . . . . . . . 57

7 Introduction à la sécuité informatique 59

7.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.2 Cybersécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.3 Sécurité logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2 CONTENTS
Chapter 1

Introduction à l’architecture des

Ordinateurs

1.1 Machine de Von Neumann et machine de Harvard

Il existe deux types d’ architectures informatiques numériques qui décrivent la fonction-
nalité et la mise en œuvre des systèmes informatiques. L’un est l’architecture Von
Neumann qui a été conçue par le physicien et mathématicien renommé John Von Neu-
mann à la fin des années 1940, l’autre est l’architecture de Harvard qui est basée sur
le premier ordinateur basé sur un relais de Harvard Mark I qui utilisait des systèmes de
mémoire séparés. stocker des données et des instructions.

1.1.1 Machine de Von Neumann

a) La Machine de Von Neumann

Ce modèle est généralement utilisé dans les architectures ou la même structure est
utilisé pour stocker à la fois les données et les programmes. Dans ce cas, le même bus est
utilisé pour le transport de ces informations (instructions et données).
On peut dire que l’architecture de von Neumann décompose l’ordinateur en 4 parties
distinctes :

• l’unité arithmétique et logique (UAL ou ALU en anglais) ou unité de

traitement : son rôle est d’effectuer les opérations de base ;

• l’unité de contrôle, chargée du « séquençage » des opérations ;

3
4 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

Figure 1.1: Modèle de Von Neumann

• La Mémoire qui contient à la fois les données et le programme qui indi-

quera à l’unité de contrôle quels sont les calculs à faire sur ces données.
La mémoire se divise entre mémoire volatile (programmes et données en
cours de fonctionnement) et mémoire permanente (programmes et don-
nées de base de la machine) ;

• Les dispositifs d’entrée-sortie, qui permettent de communiquer avec le

monde extérieur.

1.1.2 La Machine de Harvard

Le Modèle de HARVARD sépare physiquement la mémoire des données et celle des pro-
grammes. L’ accès à chacune de ces mémoires se fait à travers deux bus, un bus de
données et un bus d’ adresse. Ce qui permet par exemple de transférer simultanément
les instructions et les données.
Cette architecture est utilisée dans des ordinateurs disposant des mémoires différentes
pour le stockage des données et des programmes. Le transfert simultané des instructions
et des données donne un avantage de performances à cette architecture comparée à l’
architecture précédente. Le problème avec cette architecture est la complexité de mise
en œuvre.
1.1. MACHINE DE VON NEUMANN ET MACHINE DE HARVARD 5

Figure 1.2: Modèle de HARVARD

1.1.3 Différence entre les architectures de Von Neumann et Har-

vard

Structure

Dans l’architecture Von-Neumann, il n’ y a pas de mémoire de données et

de programmes séparés. Au lieu de cela, une seule connexion mémoire est
donnée au CPU.

Dans l’ architecture Harvard, le CPU est connecté à la fois à la mémoire de

données et à la mémoire de programme.

Configuration matérielle

Dans l’architecture de Von Neumann, contrairement à l’ architecture Harvard,

cela nécessite moins de matériel car seule une mémoire commune doit être
atteinte.

L’ architecture de Harvard nécessite plus de matériel car il nécessitera des

données et un bus d’ adresses distinctes pour chaque mémoire.
6 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

Espace requis

L’ architecture Von-Neumann nécessite moins d’espace que celle d’Harvard.

Rapidité d’ exécution:

La vitesse d’ exécution est plus rapide dans l’architecture d’Harvard car le

processeur récupère simultanément les données et les instructions; contraire-
ment à l’architecture de Von Neumann où la vitesse d’ exécution est plus lente
car elle ne peut pas récupérer les données et les instructions en même temps.

Utilisation de l’ espace:

L’ espace n’ est pas gaspillé dans l’architecture de Von Neumann car l’ espace
de la mémoire de données peut être utilisé par la mémoire d’ instructions et
vice-versa.

Dans l’architecture de Harvard, Il est possible d’avoir un gaspillage d’ espace

car s’ il reste de l’ espace dans la mémoire de données, la mémoire d’ instruc-
tions ne peut pas utiliser l’ espace de la mémoire de données et vice-versa.

1.2 Composants d’un ordinateur

1.2.1 Définitions
Hardware (mot anglais qui signifie quincaillerie): Le hardware représente tout ce qui est
matériel dans un ordinateur.
Technologie : la technologie des ordinateurs est l’ étude des composants matériels :
diode, transistors, circuits intégrés et des techniques de leur réalisation.
Logique : elle désigne l’ étude des techniques d’ assemblage des composants élémen-
taires pour en faire des circuits et/ou des éléments fonctionnels
Architecture : consiste à :

• l’ étude descriptive des éléments fonctionnels d’ un ordinateur

• l’ étude de l’ interconnexion des divers éléments fonctionnels entre eux

• l’ étude du fonctionnement de chaque organe fonctionnel

1.2. COMPOSANTS D’UN ORDINATEUR 7

Système informatique : cette expression désigne l’ ensemble des moyens matériels et

logiciels nécessaires pour satisfaire les besoins informatiques d’ un ensemble d’ utilisateurs.
Logiciel : ce terme est une généralisation de programme qui désigne un ensemble d’
instructions exécutables. Le logiciel et le hardware sont indissociables : l’ un est inutile
sans l’ autre.

1.2.2 Structure en couches des machines modernes

Langages et machines virtuelles Toute machine a son langage machine formé de l’
ensemble des instructions directement exécutable par le matériel. On peut donc dire qu’
une machine définit un langage et réciproquement. La machine définie par un langage
peut être très complexe et d’ un coût complètement prohibitif, mais on peut néanmoins
l’ imaginer. Une telle machine qui n’ existe que dans notre imagination est une machine
virtuelle.
On peut voir un ordinateur comme un ensemble de couches chacune définissant une
machine virtuelle ayant son propre langage machine. Un programme écrit pour une ma-
chine d’ une couche donnée, est traduit ou interprété par un traducteur ou un interpréteur
tournant sur une couche inférieure avant toute exécution. Cette vision d’ un ordinateur
en couches aide à la compréhension de son fonctionnement.

Les différentes couches d’ une machine moderne. La plupart des ordinateurs

actuels ont au moins deux couches. On trouve même des machines ayant six couches:

• Couche 0 ou niveau physique: Les objets manipulés à ce niveau sont les portes
logiques. Chaque porte dispose d’ une ou plusieurs entrées logiques et rend en
sortie une fonction simple de ses entrées comme résultat. Une porte se construit
à l’ aide des transistors. Les circuits électroniques de cette couche exécutent les
microprogrammes du niveau 1.

• Couche 1 ou niveau microprogrammé: On a à ce niveau un microprogramme qui

interprète les instructions du niveau 2 et produit des micro-instructions directement
exécutables par le matériel.

• Couche 2 ou niveau machine traditionnelle: Le langage machine d’ un ordinateur tel

que proposé par le constructeur se rapporte au niveau 2. Le jeu d’ instructions qui
y est décrit est l’ ensemble des instructions interprétés par les microprogrammes
du niveau 1 et non pas l’ ensemble des instructions directement exécutables par
le matériel. Sur les machines les plus anciennes, il n’ y a pas de niveau 2. Les
8 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

instructions du langage machine sont directement exécutées par le matériel. En

conséquence, leurs circuits électroniques sont très complexes et peu fiables.

• Couche 3 ou niveau système d’ exploitation: Les services offerts par le niveau 3

sont pris en charge par un interpréteur qui s’ exécute au niveau 2, et qui est appelé
Système d’ exploitation.

• Couche 4 ou niveau du langage d’ assemblage: Le langage de cette couche est fait

de symbole assez proche des langages compréhensibles par l’ utilisateur et est d’
une utilisation plus commode que le langage machine. Avant toute exécution un
programme de ce niveau est assemblé en langage machine par un traducteur appelé
assembleur.

• Couche 5 ou niveau langage d’ application: On trouve ici des langages conçus

pour être utilisés par des programmeurs d’ applications. Ces langages sont souvent
appelés langages de haut niveau. Les plus connus sont : Algol, Pascal, C, Fortran,
Basic, Cobol, Lisp, Ada, ...etc.

• Couche 6 ou niveau des langages orientés applications: Ce sont des ensembles de

programmes conçus pour créer des machines destinées à traiter des applications
déterminées. Elles contiennent beaucoup des données relatives à ces applications
qui peuvent être du domaine de la gestion, de l’ éducation, de l’ informatique, ...etc.
Ces niveaux sont encore du domaine de la recherche.

1.2.3 Configuration d’ un ordinateur ou d’ un système informa-

tique
La configuration correspond à l’ organisation adoptée pour mettre ensemble et faire fonc-
tionner les divers éléments matériels : mémoire principale, unité de traitement, terminaux,
imprimantes, mémoires de masse,...etc.
La configuration est fonction de l’ importance du système mis en œuvre. La configu-
ration la plus simple est celle des ordinateurs personnels, appelés aussi micro-ordinateurs.
Une telle configuration comprend en général les éléments suivants (voir figure 1): une mé-
moire centrale, un microprocesseur, des unités d’ entrées/sorties, des unités
périphériques.
Un ordinateur est tout simplement un assemblage de composants électroniques conçu
pour traiter l’ information suivant les désirs de l’ utilisateur. Un système informatique
1.2. COMPOSANTS D’UN ORDINATEUR 9

Figure 1.3: Configuration d’un micro-ordinateur

peut être composé de plusieurs ordinateurs reliés entre eux par des moyens de communi-
cation : on parle dans ce cas de réseau d’ ordinateurs.
Un système informatique assure trois grandes fonctions :

• - une fonction de communication : elle consiste à acquérir l’ information à traiter,

acquérir les traitements à effectuer et à restituer les résultats des traitements à l’
utilisateur

• une fonction de traitement : elle consiste à la réalisation des traitements nécessaires

pour produire les résultats attendus à partir des données acquises.

• une fonction de mémorisation : elle consiste à stocker :

• les informations à traiter

• les traitements à effectuer sur ces informations

• les résultats intermédiaires ou finaux des divers traitements

10 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

1.2.4 es principaux organes d’ un ordinateur

La mémoire.

Généralités. La mémoire est le composant de la machine où est stocké données et

instructions relatives aux divers processus. Les performances du calculateur dépendent
aussi de la rapidité d’ accès à la mémoire ; car pour réaliser une opération, il faut aller
chercher le code de cette opération et les données nécessaires en mémoire.
Donc l’ amélioration des performances d’ un calculateur passe nécessairement par l’
amélioration du temps d’ accès à la mémoire. Très souvent, pour améliorer le temps d’
accès, on essaie d’ améliorer la bande passante, c’ est-à-dire le nombre d’ octets accessibles
par seconde.

• Débit = nombre d’ accès par seconde

• Latence = temps d’ un accès

• Temps de cycle = temps minimal entre deux accès successifs

L’ amélioration de la bande passante peut être obtenue en :

• Réduisant le cycle mémoire de base, en utilisant une technologie adéquate

• Augmentant la taille des mots

Par ailleurs, le cycle mémoire est une fonction de la taille mémoire. Plus la mémoire
est grande, plus l’ accès à un emplacement est lent. La réduction du temps de cycle
mémoire peut se faire de façon technologique ou de façon algorithmique.
Sur le plan technologique, la réduction du temps de cycle est fonction des matériaux
utilisés pour fabriquer la mémoire :

• Les mémoires statiques SRAM. Une cellule mémoire est une simple bascule qui
conserve sa valeur tant qu’ il y a alimentation en énergie.

• les mémoires dynamiques DRAM. Une cellule mémoire est un condensateur qui
chargé représente le 1 logique et déchargé représente 0 logique. Un condensateur
a tendance à se décharger. Il faut le rafraîchir périodiquement pour qu’ il reste
chargé.

Les SRAM sont plus rapides que les DRAM. Par contre les DRAM ont un coût par
bit plus faible et permettent de forte densité d’ intégration. Les mémoires cache sont des
SRAM alors que les mémoires centrales sont des DRAM.
1.2. COMPOSANTS D’UN ORDINATEUR 11

Sur le plan algorithmique, deux techniques sont utilisées pour améliorer les perfor-
mances de la mémoire: l’organisation verticale et l’organisation horizontale.

Hiérarchie. On distingue en général cinq niveaux: les registres, Les caches, la mémoire
centrale, la mémoire virtuelle, la Bande magnétique. La technologie utilisée pour con-
struire un niveau de mémoire est caractérisée par cinq paramètres: Temps d’ accès (ti ),
Taille (si ), Coût par octet (ci ), Bande passante (bi ), Unité de transfert (xi ). En général
dans une hiérarchie de mémoire (M0 , M1 , ..., Mn−1 ) On a:

• ti−1 ≤ ti

• si−1 ≤ si

• ci−1 ≥ ci

• bi−1 ≥ bi

• xi−1 ≥ xi

Mémoire centrale. Elle est la source et la destination des informations échangées par
d’ autres organes de l’ ordinateur. Elle peut être vue comme une collection d’ emplace-
ments (mot) pouvant contenir chacun une information de base. A chaque emplacement
est associée une adresse (numéro) par laquelle il peut être référencé. La capacité d’ un
emplacement est mesurée en bits (16bits, 32bits . . . etc.). Dans la plupart des ordinateurs
personnels un mot est égal à un octet (8 bits). Le rôle de la mémoire est de stocker:
les programmes en cours d’ exécution, les données nécessaires à l’ exécution d’ un pro-
gramme, les résultats intermédiaires ou finaux. A la mémoire sont associés un registre de
sélection (ou registre d’ adresse) et un registre de données (tampon).
12 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

Figure 1.4: Schéma d’un plan mémoire.

Fonctionnement de la mémoire: une adresse étant rangée dans le registre adresse,

un décodeur sélectionne le mot désiré. Si le fil de mot lecture est activé alors le contenu
du mot sélectionné est transféré vers le registre de données : c’ est l’ opération de lecture.
Si par contre c’ est le fil de mot écriture qui est activé, le contenu du registre de données
sera aiguillé vers le mot sélectionné : c’ est l’ opération d’ écriture.

L’ unité de traitement

L’ unité de traitement est composée d’ un certain nombre de registre et de l’ UAL (unité

arithmétique et logique). L’ UAL est composée de circuits capables d’ exécuter des
opérations simples sur les informations issues de la mémoire. Dans la plupart des machines
modernes, elle réalise au moins : l’ addition, la soustraction, la multiplication, la division,
et les fonctions logiques.

Figure 1.5: Schéma d’une unité de traitement

Elle effectue les traitements qui lui sont indiqués par l’ unité de commande. Les
1.2. COMPOSANTS D’UN ORDINATEUR 13

commandes qui lui sont envoyées par l’ unité de commande précisent : - la nature de l’
opération à effectuer, - où rechercher les éventuelles données nécessaires et - ce qu’ il faut
faire des résultats.

L’ unité de commandes (ou de contrôle)

Elle coordonne le fonctionnement des autres unités de l’ ordinateur, c’ est-à-dire que : -

elle envoie au moment adéquat un ordre à une unité lui indiquant avec précision ce qu’
elle doit faire pour contribuer à l’ exécution de l’ instruction courante; - elle prend en
compte les comptes rendus du fonctionnement des divers organes.
Elle est composée de : - une horloge qui permet de régler la succession des actions
dans le temps; - un registre nommé Compteur Ordinal qui à la fin de l’ exécution d’ une
instruction contient l’ adresse de l’ instruction suivante; - un registre instruction dans
lequel est stockée l’ instruction en cours d’ exécution; - un registre d’ état qui mémorise à
chaque instant l’ état des divers organes contrôlés; - un décodeur qui assure le décodage du
code binaire d’ une instruction; - un séquenceur qui distribue les commandes nécessaires
au déroulement de l’ instruction, en fonction du code binaire stocké dans le registre
instruction.

Les unités d’ échange

Les unités d’ échanges ou unités d’ entrées/sorties sont des éléments qui permettent
de transférer des informations entre l’ unité centrale et les unités périphériques. En
effet le processeur est extrêmement rapide par rapport aux organes périphériques. En
laissant la gestion des E/S au processeur, celui-ci passera la grande partie du temps à
attendre. Les unités d’ échanges ont été introduites pour aider le processeur central dans
l’ accomplissement des opérations d’ entrées/sorties. Pour effectuer une opération d’
entrée/sortie, il faut exécuter une instruction d’ entrée/sortie dans le CPU. C’ est donc
le processeur central qui prend l’ initiative des E/S. Il initialise le transfère et passe la
main à l’ unité d’ échange pour la suite des opérations. Les unités d’ échanges sont : le
DMA (direct memory accesc) ou le canal.

• Le DMA. Il est utilisé dans les ordinateurs de petites tailles pour permettre aux
périphériques d’ accéder directement à la mémoire centrale sans passer par le CPU.
Il est doté d’ un registre d’ adresse, d’ un compteur, d’ un registre de données et
d’ un dispositif de commande capable d’ assurer le transfert. Lorsque le compteur
passe à zéro, le DMA signale au CPU que le transfert est terminé. Le DMA est
prioritaire par rapport au CPU pour l’ accès à la mémoire.
14 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

• Les CANAUX. Les canaux sont des processeurs spécialisés dans les opérations d’
E/S. On en distingue deux types

– le canal sélecteur: il est totalement réservé au périphérique concerné. Il fonc-

tionne avec des périphériques rapides tels que les disques magnétiques.
– le canal multiplexé : Il peut piloter plusieurs périphériques simultanément et
fonctionne en temps partagé. Un canal peut être multiplexé par byte (c’ est-à-
dire qu’ il transfère un seul byte quand il est alloué à un périphérique donné)
ou multiplexé par bloc (c’ est-à-dire qu’ il transfère un bloc de plus d’ un octet
à chaque allocation).

• Entre le périphérique et l’ unité d’ échange il y a un contrôleur de périphériques(ou

coupleur, ou unité de liaison). C’ est le dispositif qui gère le fonctionnement du
périphérique (un ou plusieurs) d’ un type précis. Son objectif est d’ adapter la
diversité des périphériques (débit, temps de réponse, formats de données,...etc.) à
une interface commune obéissant aux règles adoptées par le constructeur. Il a deux
faces, l’ une spécifique à l’ unité périphérique connectée et l’ autre aux prescriptions
et spécifications des unités d’ échanges utilisées.

NB:

• Une interface est un ensemble de règles et de conventions à respecter pour que deux
systèmes donnés puissent échanger des informations. Une interface peut également
désigner la gestion câblée ou programmée du lien entre deux systèmes.

• Une interruption est un signal électronique généré par une unité fonctionnelle et
qui est envoyée au CPU pour provoquer une rupture de séquence afin d’ exécuter
un programme prioritaire traitant la cause de l’ interruption.

Les unités périphériques

Elles sont composées des unités de communication avec l’ extérieur et des mémoires
auxiliaires. La nature de ces unités est très variée. Elles sont caractérisées par le sens des
transferts (entrées ou sorties), le support physique utilisé et le type d’ information traité.
Exemple:
1.3. INTRODUCTION A LA PROGRAMMATION ASSEMBLEUR 15

Sens des
() transferts Type d’ informations et support
Nom de l’ unité
()
Clavier entrée caractères sur touches d’ un dispositif
électronique
Moniteur sortie caractères ou images (tube cathodique)
Imprimante sortie caractères ou images sur papier
Table Traçante sortie diagrammes sur papier
Disque entrée sortie données numériques ou alphanumériques
sur support magnétique.
Scanners entrée documents imprimés sur papier
()

1.3 INTRODUCTION A LA PROGRAMMATION AS-

SEMBLEUR

1.3.1 Généralités
L’assembleur est un langage dont le fonctionnement est très proche du langage machine;
il est le langage de bas niveau le plus populaire. Il est également très utilisé pour la
conception des systèmes d’exploitation.
Pour exécuter un programme en langage assembleur, (c’est à dire traduire un pro-
gramme en langage machine), on doit passer par les étapes suivantes:

1. Saisie du code à l’aide d’un éditeur de texte

2. Compiler le programme à l’aide d’un compilateur

3. Éditer les liens pour avoir un programme exécutable.

Ces étapes peuvent se résumer par la figure 1.6.

Comme tout programme, un code assembleur obéit à des règles bien définies. Ainsi,
on retrouve dans un tel programme des définitions, des données et des instructions.

1.3.2 Instructions
La syntaxe des instructions est définie comme suit:
16 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

figure

Figure 1.6: Exécution d’un code assembleur

{Label:} Mnémonique {opérande} {; commentaire}

• Le champ Label est destiné pour marquer une ligne qui sera une cible d’instruction
de saut ou de branchement. Elle peut être formée de 31 caractères alphanumériques
au maximum. Il se termine par ‘:’ et ne peut pas commencer par un chiffre. Il n’est
pas sensible à la casse.

• Le champ mnémonique est un mot spécifique permettant de remplacer chaque

opcode hexadécimale.

Quelques mnémonique

() syntaxe Description
Mnémonique
()
MOV MOV destination, source Copie le contenu de source
dans destination
1.3. INTRODUCTION A LA PROGRAMMATION ASSEMBLEUR 17

() syntaxe Description
Mnémonique
()
XCHG XCHG destination, source Échange les contenus de
source et de destination
JMP JMP MonLabel Saute à l’instruction
pointée par MonLabel
CMP CMP nbre1, nbre2 Sert à comparer deux
nombres nombre1 et
nombre2
()

• Le champ opérande est un champ optionnel selon l’instruction

• Le champ commentaire permet d’expliquer plus en détail une instruction

Exemple d’instruction: ET1: MOV AX, 500H. Cette instruction permet de met-
tre la valeur 500 dans le registre AX.

1.3.3 Les Directives

Une directive est une information que le programmeur fournit au compilateur. Elle n’est
pas transformée en une instruction en langage machine. Elle est utilisée par exemple pour
créer de l’espace mémoire pour des variables (déclaration de variable), pour définir des
constantes et bien d’autres.
Pour déclarer une directive, on utilise la syntaxe suivante:
{Nom} Directive {opérande} {; commentaire}

• Le champ opérande dépend de la directive

• Le champ Nom indique le nom des variables : c’ est un champ optionnel

selon la directive.

Quelques directives
18 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS

() Syntaxe Description Exemple

Directive
()
EQU nom EQU Assigne une valeur à une val EQU 50
expression variable
DB nom DB expression Définit une variable de 8 vil DB 12H
bits. Les valeurs qu’on peut
stocker dans cette directive
sont comprises de 0 à 28 − 1
DW nom DW expression Définit une variable de 8 yy DW ?
bits. Les valeurs qu’on peut
stocker dans cette directive
sont comprises de 0 à 216 − 1
DD nom DD expression Définit une variable de 8 ff DD 15500000H
bits. Les valeurs qu’on peut
stocker dans cette directive
sont comprises de 0 à 232 − 1
DUP nom DUP Utilisé lorsque l’on veut tab DB 100 DUP(15)
expression déclarer un tableau de n
cases, toutes initialisées à la
même valeur.
()

1.3.4 Exemple complet d’un code assembleur

Écrivons un code assembleur pour sommer les entiers de 1 à 1000.

Algorithme: somme
Var sum,tem: entier;
Debut
sum <-- 0;
temp <-- 1;
tantque(temp<=1000)faire;
sum <-- sum+temp;
temp <-- temp + 1;
FinTantque;
1.3. INTRODUCTION A LA PROGRAMMATION ASSEMBLEUR 19

ecrire(sum);
Fin

Version assembleur

org 100h

sum dw 00h; Variable sum avec pour initialisation à 0

temp dw 01h; Variable temp avec pour initialisation à 1
mov AX, [sum]; copie du contenu de sum dans le registre AX
mov BX, [temp]; copie du contenu de temp dans le registre BX

again
add AX, BX; addition des valeurs contenues dans AX et BX
inc BX ; incrémentation de la valeur contenu dans BX
cmp BX, 1000;comparaison de la valeur contenue dans BX et 1000.
jbe again; On retourne à "again" si la condition est vérifiée

mov {[}sum{]}, AX; copie de la valeur contenue dans AX dans sum

end

1.3.5 Exercices en Assembleur

Exercice 1 : Écrivez un code assembleur qui permet de calculer le carré d’un nombre.

Exercice 2 : Écrivez un code assembleur qui permet de calculer la somme des nombres
binaires suivants: 1010 et 1001.

Exercice 3 : Écrivez un code assembleur qui permet d’effectuer un saut si un nombre

est pair.

Exercice 4 : Écrivez un code assembleur qui permet d’effectuer la multiplication par

addition successive

Exercice 5 : Écrivez un code assembleur qui permet d’effectuer la division par sous-
traction successive.
20 CHAPTER 1. INTRODUCTION À L’ARCHITECTURE DES ORDINATEURS
Chapter 2

Introduction à l’algorithmique

2.1 Rôle des Algorithmes en Informatique

Qu’est ce qu’un algorithme? En quoi l’étude des algorithmes est-elle utile?

2.1.1 Algorithmes
Un algorithme est une procédure de cacul bien définie qui prend en entrée une valeur, ou
un ensemble de valeurs, et qui donne en sortie une valeur, ou un ensemble de valeurs. Un
algorithme est donc une séquence d’étapes de calcul qui transforment l’entrée en sortie.
On peut aussi considérer un algorithme comme un outil permettant de résoudre un
problème de calcul bien spécifié. L’énoncer du problème spécifie, en termes généraux, la
relation désirée entre l’entrée et la sortie. L’algorithme décrit une procédure de calcul
spécifique permettant d’obtenir cette relation entrée/sortie.

Exemple: Problème de tri . Entrée: suite de n nombres < a1 , a2 , ..., an >. Sortie:
une permutation (réorganisation) < a′1 , a′2 , ..., a′n > de sorte que a′1 ≤ a′2 ≤ a′3 ≤ ... ≤ a′n
Une instance d’un problème consiste en l’entrée requise par le calcul d’une solution
au problème.

Exemple d’instance . < 31, 40, 56, 20, 40, 58 >.

Un algorithme est dit correct si, pour chaque instance en entrée, il se termine en
produisant la bonne sortie. On dit qu’un algorithme correct résout le problème donné.
Un algorithme peut être spécifié en langage humain ou en langage informatique, mais
aussi être sur un système matériel. L’unique obligation est que la spécification fournisse
une description précise de la procédure de calcul à suivre.

21
22 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

2.1.2 Exemple de problèmes susceptibles d’être résolus par les

algorithmes
• Réseaux sociaux: Algorithmes utilisés dans facebook, Twitter, WhatsApp, ...

• Vente en ligne: Algorithmes utilisés dans https://www.lohce.com/

• Bio-informatique: Le projet du génome humain a pour but d’identifier les 100

000 gènes de l’ADN humain, de déterminer les séquences de 3 milliard de paires de
bases chimiques ...

• Autres exemples donnés par les étudiants.

2.1.3 Structures de données

Une structure de données est un moyen de stocker et organiser des données pour faciliter
leur accès et leur modification. Il n’y a aucune structure de données qui réponde à tous
les besoins. Ainsi, il est importantde connaître les forces et les limitations de chacune de
ces structures.

2.1.4 Problèmes difficiles

Le problème du voyageur de commerce.

2.1.5 Influence des algorithmes sur la technologie

Activité sur la Complexité, le temps d’exécution, la fréquence du processeur.

2.2 Langage Algorithmique

2.2.1 Structure d’un algorithme

Algorithme [:nom_algorithme]
[Entree : Description des variables d’entrées]
[Sortie : Description des variables de sortie]
var var1,var2,.... typeVariable;
debut:
instruction 1;
instruction 2;
2.2. LANGAGE ALGORITHMIQUE 23

.
.
.
fin

Un algorithme doit contenir des instructions compréhensibles par celui qui devra
l’exécuter. Les quatres familles d’instructions sont :

1. l’affectation des variables

2. opérations de lecture/écriture

3. les tests logiques

4. les boucles

On a besoin d’un langage algorithmique distinct des langages de programmation parce

que l’algorithmique exprime les instructions résolvant un problème donné indépendam-
ment des particularités de tel ou de tel autre langage.

2.2.2 Les variables

Une variable est un élément permettant de stocker une information dans un programme
ou un algorithme. Une variable peut être vue comme une boite que le programme (ou
l’ordinateur) va récupérer par une étiquette. Dans la réalité, l’ordinateur a un emplace-
ment mémoire (boite) récupéré par une adresse mémoire (l’étiquette) sous forme binaire.

Déclaration des variables:

Elle se fait en attribuant le nom à la variable et en précisant le type de celle-ci. (Elle

consiste à associer une étiquette à un emplacement mémoire).

Type de la variable :

IL correspond à la taille de l’emplacement mémoire et au type de codage à utiliser pour

cette variable.
24 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

Type Numérique classique

• Octet

• Entier

• Réel

var g : octet; var i,j : entier;

type chaîne de caractère Une chaîne de caractère est notée avec les guillemets.

type booléen Contient des valeurs logiques vrai et faux (True et False) ou encore (0
et 1)

autre type

• type date (jour/mois/année)

• type monétaire (deux chiffres après la virgule)

L’instruction d’affectation

L’affectation est le fait d’attribuer une valeur à une variable. A gauche on a la variable
(jamais une valeur ) A droite on a une expression (Une valeur, une variable, ou un en-
semble de valeurs|variables reliées entre elles par des opérateurs et équivalent à une seule
valeur).
Au milieu, on a une flèche orientée vers la gauche. L’affectation est valide si la variable
à gauche est du même type que la valeur à droite. Naturellement, une affectation ne
modifie que la variable de gauche.
Exemple

Algorithme
var A,B entier;
debut:
A <- 4;
B <- 5;
A <- A+B;
fin
2.2. LANGAGE ALGORITHMIQUE 25

Exercice

1. Que contient chacune des variables A, B et C des algorithmes suivant à la fin de

l’exécution ?

Algorithme1
var A,B entier;
debut:
A <- 4;
B <- 5;
A <- A+B;
fin

Algorithme2
var A,B,C entier;
debut:
A <- 4;
B <- A+3;
A <- 3;
fin

Algorithme3
var A,B,C entier;
debut:
A <- 5;
B <- A+4;
A <- A+1;
B <- A-4;
fin

Algorithme4
var A,B,C entier;
debut:
A <- 5;
B <- 3;
C <- A+B;
A <- 2;
26 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

C <- B - A;
fin

Algorithme5
var A,B,C entier;
debut:
A <- 3;
B <- 10;
C <- A+B;
B <- A+B;
A <- C;
fin

Algorithme6
var A,B,C entier;
debut:
A <- 5;
B <- 2;
A <- B;
B <- A;
fin

2. Écrire un algorithme permettant de changer le contenu de deux variables et ce

quelque soit leur contenu préalable. Vous écrirez deux versions de cet algorithme :
Une avec valeur intermédiaire et l’autre sans valeur intermédiaire.

Expressions et opérateurs

Une expression est un ensemble de valeurs, reliées entre elles par des opérateurs et équiv-
alent à une seule valeur.
Exemple
7
5+4
123 - 45 - 844
Est ce que l’expression suivante est valide ? si oui, sous quelle condition ?
Toto -12 +5 - riko
2.2. LANGAGE ALGORITHMIQUE 27

Un opérateur est un signe qui relie deux valeurs pour produire un résultat.

Opérateurs numériques

• + Addition

• - Soustraction

• * Multiplication

• / Division

• % Modulo

La multiplication et la division sont prioritaires devant l’addition et la soustraction.

Opérateurs logiques (ou booléens)

• ET

• OU

• NON

2.2.3 Instructions de lecture et Écriture

La lecture permet à l’algorithme (ou au programme) de lire les valeurs entrées par
l’utilisateur à travers le clavier. L’écriture permet à l’algorithmr (ou au programme)
de communiquer des valeurs à l’utilisateur en les affichant à l’écran.
Syntaxe:

Algorithme
var nom: chaine;
debut:
lire(variable)// une sorte d’affectation à partir du clavier
ecrire("Entrez votre nom");//Affichage à l’écran
lire(nom);
fin

Exercice: Quel est le résultat produit par l’algorithme suivant?

 28 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

Algorithme
var val, double: entier;
debut:
val <-- 231;
double <-- val*2;
ecrire(val, double);
fin

Exercice:Ecrire un algorithme qui demande le nom à l’utilisateur et qui répond à cet

utilisateur par un "Bonjour" suivi du nom de cet utilisateur. On devra avoir un scénario
similaire à celui-ci:

machine: Quel est votre nom?

utilisateur: Messi

machine: Bonjour Messi!

2.2.4 Structure Alternatives

Il y a deux formes possibles pour une structure alternative.

Forme Simple

Si(condition)Alors
Instructions;
FinSi

La condition désigne ici une expression (un booléen, une comparaison entre deux vari-
ables) dont la valeur est vrai ou faux. Si cette condition a pour valeur vrai, la machine
exécute la série d’instructions. Par contre, si cette condition a pour valeur faux, la
machine saute directement aux instructions situées après le finsi.

Forme Complète

Si(condition)Alors
Instructions_1;
Sinon:
2.2. LANGAGE ALGORITHMIQUE 29

Instructions_2;
FinSi

Si la condition a pour valeur vrai, la machine exécute la série d’instructions_1 jusqu’à

la rencontre du mot clé "Sinon". Après ce mot clé, la machine saute directement aux
instructions situées après le "FinSi".
Dans le cas où la condition a pour valeur faux, la machine saute directement à la
première ligne située après le mot clé "Sinon" et exécute l’ensemble des instructions.
Exercice: Écrire une version du "Si ... alors" complète qui est équivalent à la version
simplifiée.
Exercice: Écrire un algorithme qui demande un nombre à l’utilisateur et l’informe
ensuite si le nombre est positif ou négatif.

2.2.5 Structure itératives

Il y a trois principales structures itératives: Tantque, Repeter et Pour.

Structure Tantque

Syntaxe

Tantque(condition)Faire
Instructions;
FinTantque

Fonctionnement On évalue la condition:

• Si la condition est vraie, la machine exécute le bloc d’instructions et on reprend

au début (en testant la condition).

• Si la condition est fausse, on quitte la structure "Tantque" et on exécute les in-

structions situées après le FinTantque.

Remarques

• Les instructions contenues dans cette structure peuvent ne pas s’exécuter. En

d’autres termes, cette boucle permet d’exécuter le bloc d’instructions 0, 1 ou plusieurs
fois.
30 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

• Le corps de la boucle (le bloc d’instructions) est tel qu’on doit pouvoir sortir de la
boucle. Sinon, on aura affaire à une boucle infinie.

Structure Repeter

Syntaxe

Repeter
Instructions;
Jusqu’à(condition)

Fonctionnement

1. On exécute le bloc d’instructions

2. On évalue la condition

• Si la condition est vraie, on quitte la boucle Repeter

• Si la condition est fausse, on reprend à 1.

Remarque. Il y a toujours une exécution du bloc d’instructions. En d’autres termes,

la structure Repeter permet d’exécuter le bloc d’instructions 1 ou plusieurs fois.

Structure Pour

Syntaxe

Pour (id_var allant de val_inf à val_sup [par pas de pas]) faire

Instructions;
FinPour

Fonctionnement On évalue id_var > val_sup:

• Si c’est vrai, on quitte la boucle

• sinon,

– La machine exécute le bloc d’instructions

– la machine fait une incrémentation id_var + pas (le pas par défaut étant 1)

• On recommence au début pour évaluer la comparaison id_var > val_sup.

2.3. STRUCTURES DE DONNÉES DE BASE 31

Remarques

• Il est possible que le bloc d’instructions ne soit jamais exécuté.

• Il est possible d’avoir un intervalle inversé, à condition d’avoir un pas négatif.

• On sert de la structure Pour à partir du moment où l’on connaît le nombre de

répétitions à effectuer dans la boucle. Dans le cas contraire, on utilisera le Tantque
ou le Repeter.

Exercice: Écrire un algorithme qui demande à l’utilisateur un nombre compris entre

1 et 3 jusqu’à ce que la réponse convienne.
Exercice: Écrire un algorithme qui demande à l’utilisateur un nombre, puis affiche
la table de multiplication de ce nombre.

2.3 Structures de données de base

2.3.1 Pointeurs
Un pointeur est une variable permettant de contenir une adresse mémoire. En algorith-
mique, un pointeur d’entier est défini par: var Pˆ entier;
À la création, le pointeur P contient l’adresse NULL. On distingue deux fonctions
pour la gestion de la mémoire (pour un pointeur P):

• nouveau(p): reserve un espace mémoire. On alloue un espace mémoire pour un

élément sur lequel pointe P.

• liberer(p): libère l’espace mémoire qui était occupé par l’élément sur lequel pointe
P.

Exemple en algorithmique:

var P^ entier;
var i entier;
i <-- 4;
P <-- @i;
ecrire(P^); //affichera la valeur de i qui est 4;
32 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

2.3.2 Listes Chainées:

Une liste chainée est une succession de cellules dont la dernière pointe sur une adresse
NULL.
Exemple de représentation:

Syntaxe en algorithmique:

type liste = ^cellule;

cellule = enregistrement
info : type_info; // il s’agit du type de la donnée stoquée
suivant : liste;
fin

var tete, P: liste;

2.3.3 Listes Doublement Chainées:

Il s’agit des listes pouvant être parcourues dans les deux sens.
Exemple de représentation:

Syntaxe en algorithmique:

type d_liste = ^cellule;

cellule = enregistrement
precedent : d_liste;
info : type_info; // il s’agit du type de la donnée stoquée
2.3. STRUCTURES DE DONNÉES DE BASE 33

suivant : d_liste;
fin

var d_tete, d_P: d_liste;

2.3.4 Exercices:
Écrire les algorithmes correspondants aux exercices ci-après (à rendre dans un document
pdf), puis une classe java pour chaque exercice (4 classes).

1. Création d’une liste (par ajout d’éléments)

(a) Écrire un algorithme qui crée une liste avec deux entiers.
(b) Écrire un algorithme qui crée une liste de n éléments entiers entrés par l’utilisateur.
(c) Écrire un algorithme qui crée une liste d’éléments entrés entiers par l’utilisateur,
la liste est achevée lorsque l’utilisateur saisit -1.

2. Recherche d’éléments dans une liste chainée

(a) Écrire une procédure qui recherche une valeur dans une liste chainée et affiche
un message à l’utilisateur disant si la valeur est présente ou pas.
(b) Écrire une procédure qui recherche la dernière occurence d’une valeur dans une
liste chainée et affiche un message à l’utilisateur disant si la valeur est présente
ou pas, et si elle est présente la position de la dernière occurence.

3. Suppression d’éléments dans une liste chainée

(a) Écrire une procédure qui supprime le premier élément d’une liste chainée.
(b) Écrire une procédure qui supprime la première occurrence d’une valeur passée
en paramètre.
(c) Écrire une procédure qui supprime toutes les occurrences d’une valeur dans
une liste chainée.

4. Listes doublement chainées. Écrire une procédure permettant d’afficher une

liste doublement chainée:

(a) dans l’ordre d’enrégistrement,

(b) dans l’ordre inverse de l’enrégistrement.
34 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

2.3.5 Piles.
Définition.

Une pile est une liste ou une collection d’élements dans laquelle on ne peut introduire ou
enlever un élément qu’à une extrémité appelée tête de pile ou sommet de pile.
Le dernier élément inséré sera le premier élément à être supprimé ou retiré de la pile:
premier arrivé, dernier servi, en anglais Last In, First Out (LIFO). La figure 2.3.5 illustre
une pile d’entiers.

Figure 2.1: Illustration d’une pile d’entiers

Exemples Courants:

• Pile de livres,

• Pile d’assiètes,

• Pile de cartes

• Autres exemples (donnés par les étudiants).

2.3.6 Opérations sur une pile.

Une pile est caractérisée par les opérations suivantes:

• empiler(P: Pile, elt:type_elt) qui permet d’ajouter un élément en tête de la pile.

• depiler(P: Pile):type_elt qui permet d’enlever l’élément en tête de pile.

• initialiser(P:Pile) qui permet d’initialiser la pile (la péprarer à recevoir les don-
nées).

• vider(P:Pile) qui permet de vider le contenu de la pile.

• sommet(P:Pile):type_elt qui retourne le sommet de la pile.

2.3. STRUCTURES DE DONNÉES DE BASE 35

Exercices d’application:

Une pile peut être réalisée en stoquant ses éléments dans un tableau ou dans une liste
chainée. Écrire en algorithmique puis une classe java permetant de:

1. Réaliser une pile à l’aide d’un tableau.

2. Réaliser une pile à l’aide d’une liste chainée.

3. Qu’est ce qui change fondamentalement d’après vous?

2.3.7 Files:
Définition:

Une file est une structure de données correspondant à une liste d’éléments ou une col-
lection d’éléments dans laquelle on insère des nouveaux éléments à la fin (queue) et on
enlève les éléments au début (tête de file). En d’autres termes, dans une file, le premier
élément inséré est aussi le premier élément retiré; en anglais First In, First Out (FIFO).
La figure 2.3.7 illustre une file d’entiers.

Figure 2.2: Illustration d’une file d’entiers

Exemples Courants:

• Une file d’attente des clients d’une banque.

• Un autre exemple donné par les étudiants.

36 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

2.3.8 Opération sur une file

Une file est caractérisée par les opérations suivantes:

• enfiler(F: File, elt:type_elt) qui permet d’ajouter un élément en queue de la pile.

• defiler(F: File):type_elt qui permet d’enlever l’élément en tête de file.

• initialiser(F:File) qui permet d’initialiser la file (la péprarer à recevoir les données).

• vider(F:File) qui permet de vider le contenu de la file.

2.3.9 Exercices d’application:

Tout comme une pile, une file peut être réalisée en stoquant ses éléments dans un tableau
ou dans une liste chainée. Écrire en algorithmique puis une classe java permetant de:

1. Réaliser une file à l’aide d’un tableau.

2. Réaliser une file à l’aide d’une liste chainée.

3. Qu’est ce qui change fondamentalement d’après vous?

2.3.10 Éléments de correction:

Liste chainée avec deux éléments:

type liste = ^cellule;

cellule = enregistrement
info : entier;
suivant : liste;
fin

Algorithme: liste_de_2_elements
var tete, P: liste;
Debut
tete <-- null;

nouveau(P);
ecrire("Entrer la première valeur de la liste");
lire(P^.info);
2.3. STRUCTURES DE DONNÉES DE BASE 37

P^.suivant <-- tete;

tete <-- P;

nouveau(P);
ecrire("Entrer la deuxième valeur de la liste");
lire(P^.info);
P^.suivant <-- tete;
tete <-- P;
Fin

Liste chainée avec n éléments:

type liste = ^cellule;

cellule = enregistrement
info : entier;
suivant : liste;
fin

Algorithme: liste_de_n_elements
var tete, P: liste;
i, n: entier;
Debut
ecrire("Entrer le nombre d’éléments de la liste");
lire(n);
tete <-- null;

Pour i allant de 1 à n faire

nouveau(P);
ecrire("Entrer l’élément ", i);
lire(P^.info);
P^.suivant <-- tete;
tete <-- P;
FinPour
Fin
38 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

Recherche d’une valeur dans une liste chainée:

type liste = ^cellule;

cellule = enregistrement
info : entier;
suivant : liste;
fin

Fonction recherche(tete: liste, val: entier):booleen

var P: liste; trouve:booleen;
Debut
P <-- tete;
Tantque ((P<>null) et (P^.info<> val)) faire
P <-- P^.suivant;
FinTantque
Si (P = null) alors
trouve <-- faux;
Sinon
trouve <-- vrai;
FinSi
retourner trouve;
Fin

Affichage d’éléments dans une liste doublement chainée:

type d_liste = ^cellule;

cellule = enregistrement
precedent : d_liste;
info : entier;
suivant : d_liste;
fin

var d_tete, d_P: d_liste;

Fonction affiche_liste(tete: liste):booleen

var P, Q: liste;
2.3. STRUCTURES DE DONNÉES DE BASE 39

Debut
P <-- tete;
Tantque ((P<>null) faire
ecrire(P^.info, " ");
Q <-- P;
P <-- P^.suivant;
FinTantque
Tantque ((Q<>null) faire
ecrire(Q^.info, " ");
Q <-- Q^.precedent;
FinTantque

Fin

Suppression du premier élément d’une liste:

type liste = ^cellule;

cellule = enregistrement
info : entier;
suivant : liste;
fin

Procedure supprime_tete(var tete: liste)

var P: liste;
Debut
Si (tete<>null) alors
P <-- tete;
tete <-- P^.suivant;
liberer(P);
Sinon
ecrire("La liste est vide");
FinSi
Fin
40 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

Implémentation d’une file d’entiers à l’aide d’un tableau:

File = enregistrement
tableau Tab[N]: entier;
tete : entier;
queue : entier;
longueur_file: entier;
fin
Fonction enfiler(f: File, a: entier):File
Debut
Si (file_pleine(f)<>vrai) alors
f.Tab[f.queue] <-- a;
f.queue <-- f.queue + 1;
Sinon
ecrire("La file est pleine");
FinSi
retourner f;
Fin

Fonction defiler( var f: File):entier

var val_retour: entier
Debut
Si (file_vide(f)<>vrai) alors
val_retour <-- f.Tab[f.tete];
f.tete <-- f.tete + 1;
Sinon
ecrire("La file est vide");
val_retour <-- -1;
FinSi
retourner val_retour;
Fin

Fonction file_pleine(f: File):booleen

var val_retour: booleen
Debut
Si (f.queue = (f.longueur_file +1)) alors
2.4. PROCÉDURES ET FONCTIONS 41

val_retour <-- vrai;

Sinon
val_retour <-- faux;;
FinSi
retourner val_retour;
Fin

Fonction file_vide(f: File):booleen

var val_retour: booleen
Debut
Si (f.queue = f.tete) alors
val_retour <-- vrai;
Sinon
val_retour <-- faux;
FinSi
retourner val_retour;
Fin

Fonction init_file(f: File, N: entier):file

var val_retour: booleen
Debut
f.longueur_file <-- N;
f.tete <-- 1;
f.queue <-- 1;
retourner f;
Fin

2.4 Procédures et Fonctions

Dans certains cas, il est interessant de regrouper sous un même nom les instructions
agissant dans le même but afin de faciliter l’écriture d’un programme. On peut procéder
de deux manières:

• En utilisant les fonctions. Elles permettent d’effectuer un calcul et retournent une

seule valeur (résultat).
42 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

• En utilisant les procédures. Elles permettent de réaliser un traitement sans forcé-

ment retourner un resultat précis. Une fonction peut être vue comme une procédure
qui retourne une et une seule valeur.

Les procédures et les fonctions sont parfois appelées des sous-programmes.

2.4.1 Syntaxe d’une fonction

La syntaxe d’une fonction est la suivante:

fonction: nom_fonction(liste_des_parametres):Type_result
Var resultat: Type_result;
declaration_des_objets_locaux_a_la_fonction;
Debut
instructions_fonction;
retourner resultat;
Fin

Exemple: Ecrire une fonction qui calcule le périmètre d’un rectangle.

fonction: perimetre_rectancle(largeur:entier, Longueur:entier):entier

Var resultat: entier;
Debut
resultat <-- (2*(longueur+largeur));
retourner resultat;
Fin

2.4.2 Syntaxe d’une procédure

La syntaxe d’une procédure est la suivante:

procedure: nom_procedure(liste_des_parametres)
declaration_des_objets_locaux_a_la_fonction;
Debut
instructions_procedure;
Fin
2.4. PROCÉDURES ET FONCTIONS 43

Exemple: Ecrire une procédure permettant de faire l’échange du contenu de deux

variables.

procedure: echange_1(A:reel, B:reel)

Var aux: reel;
Debut
aux <-- A;
A <-- B;
B <-- aux;
ecrire("Les valeurs de", A,"et de", B, "ont été échangées");
Fin

Exercice: Écrire une fonction max3 qui compare trois entiers et retourne le max de
ces entiers. Écrire ensuite une procédure max_et_min qui affiche le max et le min de
trois entiers en se servant de max3. Indications: pour déterminer le min, se servir de
l’appel de max3 avec les opposés des nombres.

2.4.3 Transmission des paramètres

Il existe deux modes de transmission des paramètres:

• Par valeur: Le paramètre transmis n’est jamais affecté par la modification dans
la procédure ou la fonction appelée.

• Par adresse ou par reférence: Le paramètre transmis dans ce cas peut être
modifié et on recupère les résultats dans la fonction qui appelle.

La transmission dans les exemples précédents était la transmission par valeur. Dans
une transmission par adresse, le mot clé var est ajouter avant la variable.
Exemple: Ecrire une autre version de la procédure permettant de faire l’échange du
contenu de deux variables avec une transmission par adresse.

procedure: echange(var A:reel, var B:reel)

Var aux: reel;
Debut
aux <-- A;
A <-- B;
B <-- aux;
44 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

ecrire("Les valeurs de", A,"et de", B, "ont été échangées");

Fin

Dites ce que fait le programme test suivant:

Algorithme: test
Var a,b: reel;
Debut
a <-- 10;
b <-- 20;
echange_1(a,b);
ecrire(a,b);
echange_1(a,b);
ecrire(a,b);
Fin

2.4.4 Fonctions recursives

Une fonction est dite recursive lorsqu’elle s’appelle elle-même.
Exemple: Ecrire une fonction qui calcule le factoriel d’un entier n.

fonction: factoriel(n:entier):entier
Debut
Si(n=0)alors
retourner 1;
Sinon
retourner n*factoriel(n-1);
FinSi
Fin

2.4.5 Exercices
• PGCD: Écrire une fonction qui prend en paramètres deux entiers et calcule leur
PGCD en utilisant l’algorithme d’Euclide.

• PPMC: Écrire une fonction qui prend en paramètres deux entiers et calcule leur
PPMC.
2.5. ANALYSE DES ALGORITHMES 45

• Division par soustraction successives: Écrire une fonction qui réalise la division
des entiers par soustractions successives.

• Multiplication par additions successives: Écrire une fonction qui réalise la

multiplication de deux entiers par multiplications successives.

• Table de multiplication: Écrire une procédure qui affiche la table de muliplica-

tion d’un entier entré en paramètre.

• Palindrome: Écrire une fonction qui prend en paramètre une chaine de caractère
et dit si cette chaine est un palindrome.

2.5 Analyse des algorithmes

2.5.1 Généralités.

Dans le cadre de ce cours, l’analyse d’un algorithme reviendra à l’analyse de sa complexité

en temps. La complexité en temps d’un algorithme est mesurée à partir du nombre
d’instructions ou d’étapes exécutées par cet algorithme.
La complexité en temps est déterminée à partir d’une instruction dite baromètre. Il
s’agit de l’instruction la plus exécutée dans l’algorithme. La complexité peut être données
selon trois cas:

• Le pire des cas. Il s’agit du cas où l’agorithme prend le plus grand temps.

• Le meilleur des cas. Il s’agit du cas où l’algorithme prend le plus petit temps.

• Le cas moyen. C’est le temps d’exécution moyen que prendra l’algorithme quelque
soit la taille du jeu de données.

La complexité retenue pour un algorithme est généralement donné par le pire des cas.

2.5.2 Ordre de Grandeur – Notation de Landau.

En complexité, on a juste besoin de connaître l’ordre de grandeur de la fonction donnant

l’expression de la complexité.
46 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

La O-notation.

Soit g(n) une fonction de N. O(g(n)), "O de g(n)", est l’ensemble des fonctions f(n) tel
qu’il existe une constante C et un entier n0 de sorte qu’à partir de n ≥ n0 , f (n) ≤ Cg(n)
. Ceci se note:
O(g(n)) = {f (n) : ∃ C, ∃n0 | ∀n ≥ n0 , f (n) ≤ Cg(n)}.

Sur le schéma, on voit que la courbe de f(n) est en bas de celle de Cg(n). Cg(n) est
la borne maximale de f(n).

La Ω-notation.

Soit g(n) une fonction de N. Ω(g(n)), "Omega de g(n)", est l’ensemble des fonctions f(n)
tel qu’il existe une constante C et un entier n0 de sorte qu’à partir n ≥ n0 , f (n) ≥ Cg(n).
Ceci se note:
Ω(g(n)) = {f (n) : ∃C, ∃n0 | ∀n ≥ n0 , f (n) ≥ Cg(n)}

Sur le schéma, on voit que la courbe de f(n) est au dessus de celle de Cg(n). Cg(n)
est la borne minimale de f(n).
2.5. ANALYSE DES ALGORITHMES 47

La θ-notation.

Soit g(n) une fonction de N. θ(g(n)) est l’ensemble des fonctions f(n) tels qu’il existe
deux constantes C1 et C2 et un entier n0 de sorte qu’à partir n ≥ n0 , f(n) est encadré par
C1 g(n) et C2 g(n). Ceci se note:
θ(g(n)) = {f (n) : ∃C1 , C2 et n0 | ∀n ≥ n0 , 0 ≤ C1 g(n) ≤ f (n) ≤ C2 g(n)}

Exercices:

1. Soient f(n) et g(n) deux fonctions dépendant de n. Montrer que:

f (n) = θ(g(n)) ⇔ (f (n) = O(g(n)) et f (n) = O(g(n)))

n2
2. Montrer que 2
− 3n = θ(n2 )

Pour résoudre la question 2, on cherche C1 , C2 et n0 de sorte que: 0 ≤ C1 n2 ≤

n2
2
− 3n ≤ C2 n2
n2 n2
Pour C1 = 18 , C2 = 4 et n0 = 10, on a: 0 ≤ 8
≤ 2
− 3n ≤ 4n2

Autres notations

o-notation o(g(n)) = {f (n) : ∀C > 0, ∃n0 | ∀n ≥ n0 , 0 ≤ f (n) < Cg(n)}

Exercices:

1. Expliquer ce que cela veut dire.

2. A-t’on 2n = o(n2 )? 2n2 = o(n2 )?

Ici, on veut exprimer le fait que f est très petit devant g.

48 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE

ω-notation f (n) ∈ ω(g(n)) ⇔ g(n) ∈ o(f (n)). En d’autres termes, ω(g(n)) = {f (n) :
∀C > 0, ∃n0 | ∀n ≥ n0 , 0 ≤ Cg(n) < f (n)}
Exercices:

1. Expliquer ce que cela veut dire.

2. A-t’on 2n = ω(n2 )? 2n2 = ω(n2 )?

2.5.3 Résolution des équations

Considérer les équations suivantes pouvant être obtenues à partir des algorithmes recur-
sifs.
(
T (0) = C1
3.a)-
T (n) = T (n − 1) + C2

 T (0) = C1


3.b)- T (1) = C2

 T (n) = T ( n ) + C

2 3

 T (0) = C1


3.c)- T (1) = C2

 T (n) = 2T ( n ) + C

2 3

Proposer une méthode permettant de les resoudre, puis les resoudres.

Résolution de l’équation 3.a.

T (n) = T (n − 1) + C2
= (T (n − 2) + C2 ) + C2 , on remplace T (n − 1) par son expression
= (T (n − 3) + C2 ) + 2C2
= (T (n − 4) + C2 ) + 3C2
= ...
= (T (n − k) + C2 ) + (k − 1)C2
= T (n − k) + kC2
Si l’on prend k=n, on aura:
T (n) = T (n − n) + nC2
= T (0) + nC2
T (n) = C1 + nC2
Ainsi, un algorithme ayant une complexité avec une telle équation sera en O(n) ou
même θ(n).
2.5. ANALYSE DES ALGORITHMES 49

Résolution de l’équation 3.b.

T (n) = T ( n2 ) + C3 , On a T ( n2 ) = T ( n4 ) + C3
= T ( n4 ) + 2C3 , On a T ( n4 ) = T ( n8 ) + C3
= T ( n8 ) + 3C3 , On a T ( n8 ) = T ( 16
n
) + C3
n
= T ( 16 ) + 4C3
= T ( 2n4 ) + 4C3
= ...
= T ( 2nk ) + kC3
Si l’on prend k = log2 (n), on aura:
T (n) = T ( 2nk ) + kC3
= T ( 2logn2 (n) ) + log2 (n)C3
= T ( nn ) + log2 (n)C3
= T (1) + log2 (n)C3
= C2 + log2 (n)C3
Ainsi, un algorithme ayant une complexité avec une telle équation sera en O(log2 (n))
ou même θ(log2 (n)).
50 CHAPTER 2. INTRODUCTION À L’ALGORITHMIQUE