Chapitre 1

Notion d'algorithme

1.1 Concepts de base

1.1.1 Algorithme
Une succession nie d'opérations qui donne la solution d'un problème
donné. Pour écrire un algorithme, on utilise un pseudo-langage compréhen-
sible par une communauté. Donc, l'idée générale d'un algorithme est de don-
ner la solution d'un problème sous forme d'opérations qui peuvent être tra-
duites dans un langage compréhensible par la machine tout en le gardant
lisible et compréhensible par une personne ordinaire.

1.1.2 Programme
Un programme est un assemblage et un enchaînement d'instructions élé-
mentaires écrites dans un langage de programmation, et exécuté par un ordi-
nateur an de traiter les données d'un problème et renvoyer un ou plusieurs
résultats.
1
1.1.3 Langage de programmation
Un langage de programmation fournit un ensemble de mots-clés et de
règles de syntaxe qui permettent de créer des instructions formant des pro-
grammes et qui peuvent s'exécuter, sans souci, sur une machine.

1.2 Structure d'un algorithme

La gure suivante donne la structure générale d'un algorithme :

La première ligne (1) permet juste d'identier l'algorithme. Donc, le nom

attribué ne change pas l'exécution et les résultats. Avant de mettre les ins-
tructions, il faut déclarer (2)les constantes(3) et les variables(4) utilisées dans
l'algorithme. La partie principale de l'algorithme se trouve entre les mots clés
`début' et `n' (5). Elle contient la suite d'instructions à exécuter.
Exemple :
2
1.2.1 Notion de varible
Une variable est un mot qui permet l'identication de l`emplacement mé-
moire où on stocke une valeur à manipuler. Malgré que le choix est libre du
nom de la variable, il préférable, pour des raisons de lisibilité et de compréhen-
sion de choisir des noms de variables en fonctions de ce qu'elles représentent.
Par exemple : Moyenne, Poids, Taille,...etc.
La notion de type d'une variable est capitale, car elle implique le choix du
codage de la variable (par exemple, un entier sur 32 bits et un caractère sur
16 bits) ainsi que les possibilité d'usage ( par exemple : on ne peut pas mul-
tiplier un caractère par un nombre entier).
Exemple de déclaration des variables :
M, Max : Entier
Poids, Moyenne : Réel
Premier : Bouléen
1.2.2 Notion de constante
On peut assimiler la notion d'une constante à une variable dont la valeur
ne change pas au cours de l'exécution de l'algorithme.
Exemple de déclaration des constantes :
TVA = 0,17
N = 50
Admis = Vrai
3
1.3 Les types d'instructions

La partie principale d'un algorithme contient la suite d'instruction qui

va être traduite vers un langage de programmation. Il existe quatre types
d'instruction dont le détail est donné par la suite :
1.3.1 Les instructions d'entrée/sortie
Ce type d'instruction est utilisé pour interagir avec l'utilisateur, en lui per-
mettant d'entrer des valeurs des variables. Ainsi, le résultat des traitements
et des messages d'information peuvent être achés à l'utilisateur via ce type
d'instruction. En réalité, il existe plusieurs périphériques et manières pour
échanger des données avec un algorithme ou un programme (via des chiers,
des bases de données, des formulaires,...). Toutefois, pour se concentrer sur
les principes de l'algorithmique, on se contente par les entrées et les sorties
standards, à savoir, l'écriture sur le clavier et l'achage sur écran. L'exploi-
tation des autres possibilités vont être abordées dans la matière dédiée à la
programmation.
Instruction d'entrée

C'est l'instruction de lecture de données sur le périphérique d'entrée.

Structure générale :

Exemple :
Lire(Taille)
Lire (x, y)
Instruction de sortie

C'est l'instruction de restitution de résultats sur le périphérique de sortie.

:
Exemple :
Structure générale

Écrire (moyenne)
4
Écrire (` entrer la taille')
Écrire (`le résultat est :', max)

1.3.2 L'instruction d'aectation

Cette instruction permet d'aecter une valeur à une variable, après l'éva-
luation d'un expression logique ou arithmétique.
A la place d'une expression, on peut utiliser une simple valeur ou une variable
Il faut noter que le résultat de l'évaluation de l'expression doit avoir le même
type que la variable qui va le recevoir.
Structure générale :

Exemple 1 :
x ← 15, 2
x←y
x←y+4

Quelles sont les valeurs des variables a,b et c écrites par l'algo-
rithme suivant?
Exercice

Algorithme Aectation1
5
 Variables :
a,b,c : entier Début
a ← 10
b←a∗2
a ← a − b/2
c←b+a∗2
Ecrire ( , , )
abc
Fin.
:
, ,
Solution
a = 10 b = 20 c = 40
,
a = −5 b = 20 c = 10 ,
, ,
a = 0 b = 20 c = 20

1.3.3 Les instructions conditionnelles

Ces instructions sont utilisées pour faire le choix entre l'exécution ou non
des blocs d'instructions suite à l'évaluation d'une condition. On en distingue
trois types :
L'instruction conditionnelle simple

Ce type d'instructions permet de faire le choix entre l'exécution ou non

d'un seul boc d'instructions.
Structure :

Exemple :A←5
B ← 12
SI (B > A ∗ 2) alors B ← A
Fin Si
Ecrire (B)
6
L'instruction conditionnelle alternative

Ce type d'instructions permet de faire le choix de l'exécution entre deux

blocs d'instructions.
Structure :

Exemple :
A←5
B ← 12
SI (
B >A∗2 ) alors
B←A
Sinon
B ←A+4
Fin Si
Ecrire (B)

L'instruction conditionnelle de choix

Ce type d'instructions permet de faire le choix de l'exécution entre plu-

sieurs blocs selon la valeur d'une variable donnée.
Structure :

7
 :
Lire (x)
Exemple

Selon le cas (x)

x = 1 : Ecrire (`Très Faible')
x = 2 : Ecrire (`Faible)
x = 3 : Ecrire (`Moyen)
x = 4 : Ecrire (`Bien')
x = 5 : Ecrire (`Excellent')
Sinon
Ecrire (`Valeur hors intervalle acceptée')
Fin Si
Soit l'algorithme suivant :
Algorithme Test2
Exercice

Déclarations :
a, b, c : Entier
Début
Lire (a, b)
Si (b/2 > a) Alors :
c←b−a
Sinon
c←b+a
a←b−c
Fin si
Ecrire (a, b, c)
Fin.
Quelles sont les instructions exécutées pour les valeurs : a = 5, b = 10?
1.3.4 Les instructions itératives
Les instructions itératives ou répétitives, appelées aussi communément
par les développeurs les boucles, permettent d'exécuter plusieurs le même
bloc d'instructions. On en distingue trois types :
L'instruction `Pour'

Dans ce type d'instructions itératives on connait à l'avance le nombre

d'itérations. En eet, on doit préciser, dans l'entête de l'instruction `Pour',
la valeur initiale et la valeur nale et éventuellement le pas (lorsqu'il est dif-
férent de 1)
8
 Structure :

VI : valeur initiale de la variable i,

VF; valeur nale de la variable i,
V : valeur à ajouter la variable i après chaque itération (par défaut 1).
:
Pour i allant de 1 à 10 faire
Exemple

Ecrire (`L3 Bioinformatique')

Fin pour

L'instruction `Tant que'

Dans ce type d'instructions itératives on ne connait pas forcement à

l'avance le nombre d'itérations. En eet, on continue la répétition de l'exé-
cution du bloc d'instructions tant qu'une condition est encore satisfaite.

Exemple :
i=1
Tant que (i <= 10) faire
Ecrire (`L3 bioinformatique')
Fin Tant que
L'instruction `Répéter'

Comme le cas pour l'instruction `Tant que', l'instruction `Répéter' ne

permet pas de connaitre forcement à l'avance le nombre d'itérations. En
9
eet, on continue la répétition de l'exécution du bloc d'instructions jusqu'à
la satisfaction d'une condition.
Structure :

:
i =1
Exemple

Répéter
Ecrire (`TIC 4 2023')
Jusqu'à (i > 10)
: L'instruction `Tant que' s'exécute zéro ou plusieurs fois, au
moment où, l'instruction `Répéter' s'exécute une ou plusieurs fois.
Remarque

1.4 Complexité d'alogrithme

1.4.1 Situation
Le temps d'exécution d'un algorithme dépend des facteurs suivants :
 Les données utilisées par le programme;
 La qualité du compilateur (langage utilisé);
 La machine utilisée (vitesse, mémoire,. . .);
 La complexité de l'algorithme lui-même
On cherche à mesurer la complexité d'un algorithme indépendamment de
la machine et du langage utilisés, c-à-d uniquement en fonction de la taille
des données n que l'algorithme doit traiter. Par exemple, dans le cas de tri
d'un tableau, n est le nombre d'éléments du tableau, et dans le cas de calcul
d'un terme d'une suite n est l'indice du terme, ...etc.
1.4.2 O-notation
Soit la fonction T (n) qui représente l'évolution du temps d'exécution d'un
programme P en fonction du nombre de données n. Par exemple :
10
 T (n) = cn2

Où c est une constante non spéciée qui représente la vitesse de la ma-

chine, les performances du langage, ...etc. On dit dans l'exemple précédent
que la complexité de P est O(n ). Cela veut dire qu'il existe une constante c
2

positive tel que pour n susamment grand on a :

T (n) ≤ cn2

Cette notation donne une majoration du nombre d'opérations exécutées

(temps d'exécution) par le programme P. Un programme dont la complexité
est O(f(n)) est un programme qui a f(n) comme fonction de croissance du
temps d'exécution.
1.4.3 Règles de calcul de la complexité d'un algorithme
La complexité d'une instruction élémentaire

Une opération élémentaire est une opération dont le temps d'exécution

est indépendant de la taille n des données tel que l'aectation, la lecture,
l'écriture, la comparaison ...etc. La complexité d'une instruction élémentaire
est .
O(1)

La multiplication par une constante

O(c ∗ f (n)) = O(f (n))

Exemple :
3
O( n4 ) = O(n3 )

La complexité d'une séquence de deux modules

La complexité d'une séquence de deux modules M1 de complexité O(f(n))

et M2 de complexité O(g(n)) est égale à la plus grande des complexité des
deux modules : O(max(f(n), g(n))).
O(f (n)) + O(g(n)) = O(max(f (n), (g(n))

11
La complexité d'une conditionnelle

La complexité d'une conditionnelle

est le max entre les complexités de l'évaluation de <Cond>, M1 et M2.

La complexité de la conditionnelle est : M axO(h(n)), O(f (n)), O(g(n))

La complexité d'une boucle

La complexité d'une boucle est égale à la somme sur toutes les itérations
de la complexité du corps de la boucle.

La complexité de la boucle est :

m
X
M ax(h(n), f (n))
i=1

où m est le nombre d'itérations exécutées par la boucle.

Exemples

12
Types de complexité algorithmique

 T (n) = O(1), temps constant : temps d'exécution indépendant de la

taille des données à traiter.
 T (n) = O(log(n)) , temps logarithmique : on rencontre généralement
une telle complexité lorsque l'algorithme casse un gros problème en
plusieurs petits, de sorte que la résolution d'un seul de ces problèmes
conduit à la solution du problème initial.
 T (n) = O(n), temps linéaire : cette complexité est généralement obte-
nue lorsqu'un travail en temps constant est eectué sur chaque donnée
en entrée.
 T (n) = O(n.log(n)) : l'algorithme scinde le problème en plusieurs
sous-problèmes plus petits qui sont résolus de manière indépendante.
La résolution de l'ensemble de ces problèmes plus petits apporte la
solution du problème initial
 T (n) = O(n ), temps quadratique : apparaît notamment lorsque l'al-
2

gorithme envisage toutes les paires de données parmi les n entrées (ex.
deux boucles imbriquées) Remarque : O(n ) temps cubique
3

 T (n) = O(2 ), temps exponentiel : souvent le résultat de recherche

n

brutale d'une solution.

13