--- Algo 18-19

Chapitre 3 : Structures Algorithmiques

Introduction
Nous allons étudier dans le cadre de ce cours quatre structures algorithmiques
I. Structure linéaire
I.2- Algorithme linéaire ou séquentielle

Elle est caractérisée par une suite d’instructions à exécuter successivement dans l’ordre énoncé.

Les actions successives sont mentionnées les unes après les autres.

Algorithme Somme_Nombre
Variables
a, b : réel ;
s : réel ;
Début
Afficher (‘Saisir le nombre a ‘) ;
Saisir (a) ;
Afficher (‘Saisir le nombre b ‘) ;
Saisir (b);
s←a+b;
afficher (s) ;
Fin

Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un rôle essentiel dans le
résultat final. Considérons les deux algorithmes suivants :
Exemple 1
Variable A en Numérique
Début
A ← 34
A ← 12
Fin

Exemple 2
Variable A en Numérique
Début
A ← 12
A ← 34
Fin
Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle est 34. Ceci ne doit
pas nous étonner. Lorsqu’on indique le chemin à quelqu’un, dire « prenez tout droit sur 1km, puis à
droite » n’envoie pas les gens au même endroit que si l’on dit « prenez à droite puis tout droit pendant
1 km ».
Enfin, il est également clair que si l’on met de côté leur vertu pédagogique, les deux algorithmes ci-
dessus sont parfaitement impertinents ; à tout le moins ils contiennent une incohérence. Il n’y a aucun
intérêt à affecter une variable pour l’affecter différemment juste après. En l’occurrence, on aurait
tout aussi bien atteint le même résultat en écrivant simplement :

1
 --- Algo 18-19
Exemple 1
Variable A en Numérique
Début
A ← 12
Fin

Exemple 2
Variable A en Numérique
Début
A ← 34
Fin

II. Structure de test ou alternative (schéma conditionnel)

1. La structure alternative (SI…….Alors……….Sinon)

Dans cette structure, l’exécution d’un des deux traitements distincts ne dépend que du résultat d’un
test effectué sur la condition qui peut être une variable ou un événement.

• Si la condition est vérifiée, seul le premier traitement est exécuté

• Si la condition n’est pas vérifiée, seul le deuxième traitement est effectué.
Algorithme signe_du_nombre
Var N: Réel;
Début
Ecrire (‘’ Saisir un nombre
quelconque‘’) ;
Lire (N);
Si (N ≥ 0) Alors
Ecrire (‘’ Nombre Positif’’) ;
Sinon
Ecrire (’’ Nombre Négatif’’) ;
Fin Si
Fin

2. La structure conditionnelle a choix

La structure conditionnelle à choix permet de faire un choix parmi plusieurs choix proposés.
Le sélecteur permet de définir le choix du traitement à effecteur.
La structure conditionnelle à choix peut être représentée comme suit.

2
 --- Algo 18-19

Application : écrire un algorithme qui affiche le résultat de l’application d’un

opérateur sur deux opérandes

III. Structure itérative (ou boucle)

C’est un schéma permettant de répéter un ensemble d’opérations.

1. Structure POUR…FAIRE
On connaît le nombre d’itérations.

3
 --- Algo 18-19
Algorithme bizarre
Var i : Entier;
Début
Pour i allant de 1 à 10
Faire
Ecrire (‘’ Bonjour’‘) ;
Fin Pour
Fin

2. Structure TANT QUE…FAIRE

On teste d'abord la condition et la séquence est exécutée tant que la condition est vraie.

Algorithme
contrôle_saisie
Var n : Réel;
Début
Répéter
Ecrire (‘’ nombre :’’);
Lire (n) ;
Jusqu’à n < 0;
Fin

Remarque : la vérification de la condition s’effectue après les actions. Celles-ci sont donc exécutées au moins
une fois.

1. Structure REPETER JUSQU'A (ou FAIRE …TANT QUE) ou structure répétitive

La séquence est exécutée au moins une fois, elle est répétée tant qu'elle est vraie.

Autre Notation Algorithmique Algorithme contrôle_saisie

Var n : Réel;
Répéter Début

<Traitement> Ecrire (‘nombre :’) ;

Lire (n) ;
Jusqu'à (condition d'arrêt)
répéter
Ecrire (‘’nombre : ’’);
Lire (n) ;
Jusqu’à (n==0)
FinAlgo

4
 --- Algo 18-19
IV. La structure parallèle
La structure de parallélisme permet d’effectuer simultanément un ensemble fini d’action. Elle
s’effectue sous la forme suivante.
En parallèle faire
Action 1
Action 2
…
Action n
Fin Parallèle
Pour mieux comprendre cette instruction, sa sémantique consiste à exécuter en même temps les
actions action 1, action 2,…., action n. Puis sortir de la structure.
Important :
Pour éviter les conflits lors de l’exécution de cette structure, on impose que les actions
à exécuter en parallèle soient totalement indépendantes. En d’autres termes, deux
actions de la structure ne doivent ni lire, ni accéder aux mêmes variables. Compte tenu
de la complexité de cette structure et de son apport important dans l’optimisation du
temps d’exécution des programmes, l’algorithmique du parallélisme est devenu un
domaine spécifique et très fécond de l’informatique.

V. Notion de complexité d’algorithmes

Pour résoudre un problème, on a besoin des ressources de l’ordinateur (la

mémoire pour stocker les données et le temps des calculs pour les opérations à réaliser
par le processeur).
La complexité d’un algorithme mesure la quantité de chacune de ces grandeurs
physiques (temps de calcul, taille de la mémoire occupée). L’analyse des algorithmes
consiste à quantifier ces deux grandeurs physiques dans le but de comparer plusieurs
algorithmes résolvant le même problème. Le but de l’analyse de la complexité de
l’algorithme est d’être capable d’affirmer « sur toute machine et quel que soit le
langage de programmation, l’algorithme A1 est meilleur que A2 pour les données de
grande taille » ou « l’algorithme A est optimal pour résoudre le problème B en nombre
d’opération X ».
1. Opération fondamentale
Pour certains algorithmes, on peut mettre en évidence certaines opérations telles
que le temps d’exécution de l’algorithme soit proportionnel au nombre de ses
opérations. Ces opérations sont dites fondamentales.
2. Principe d’invariance
Si t1(n) et t2(n) sont les temps nécessaires pour exécuter le même algorithme sur
les machines M1 et M2, on a la relation t 1(n) ≤ c t2 (n) ou c est une constante réelle
positive. Ceci implique que la complexité des algorithmes sera exprimée à une
constante multiplicative près. Si le nombre d’opérations fondamentales est t(n) ou n est
5
 --- Algo 18-19
la taille des données manipulées par l’algorithme ; alors sur la machine M1, on a t1(n)
= c1t(n) et sur la machine M2, on a t2(n) = c2 t(n). Les constantes c1 et c2 dépendent de
la puissance de la machine.
3. Conditions pour l’analyse des algorithmes
• Le choix des opérations que l’on prend en compte ne doit pas dépendre du
langage ni de la structure de programmation.
• La complexité dépend de la taille des données
• La complexité dépend pour une taille fixée des différentes données
possibles.
Complexité en moyenne, aux meilleurs et au pire des cas
En général, la complexité des algorithmes pour résoudre une classe de problèmes
d’une taille données n’est pas la même quel que soit l’instance du problème. On
distingue donc la complexité dans le meilleur des cas et dans le pire des cas.
Meilleur des cas : les données manipulées sont les plus favorables
Pire des cas : les données manipulées sont les plus défavorables
Complexité en moyenne : moyenne des complexités calculées sur tous les cas
possibles.
4. Calcul du nombre d’opérations fondamentales
Dans une séquence, le nombre d’opérations fondamentales s’ajoute. Dans un
branchement conditionnel, il faut majorer le nombre d’opérations fondamentales.
Dans une seule boucle, si ni est le nombre d’opérations fondamentales a
l’itération no i, le nombre total d’opération est la somme des ni (∑𝑚𝑎𝑥
𝑖=1 ni) dans une
procédure ou une fonction, il faut évaluer le nombre d’opération fondamentale de la
fonction et de la procédure en utilisant la même stratégie.

5. Comparaison des algorithmes

1 Notion de Complexité
La complexité algorithmique est une notion qui concerne l'évaluation des
performances des algorithmes réalisant les mêmes procédés ou les mêmes
fonctionnalités et permettant de comparer et de déterminer si un algorithme "a" est
meilleur qu'un algorithme "b" et s'il est optimal ou s'il ne doit pas être utilisé.
L'étude de la complexité algorithmique prend en considération le nombre
d’opérations, plus précisément le temps d’exécution nécessaire sur ordinateur et
l’encombrement mémoire, en fonction de la taille du problème à traiter à savoir le
nombre de variables et le nombre de contraintes du problème. Pour des données de
grande taille, les différentes performances entre algorithme peuvent devenir énormes.
C’est donc pour des données de grande taille qu’on va comparer les algorithmes

6
 --- Algo 18-19
Considérons l’exemple-1 suivant :

{Début}
S:= 0 ; I : =1 ; N:=10 {"1"}
while I <= N do {"2"}
S = S +K[I] {"3"}
I = I+1 {"4"}
end do; {End}
Le temps d’exécution nécessaire pour cet algorithme t(n), composé de plusieurs
temps de chaque instruction. Nous supposons que :
• t1 est le temps d’exécution entre le début et la lecture des différentes
variables d'initiation {"1"}
• t2 représente le temps d’exécution de la comparaison {"2"}
• t3 est le temps d’exécution de l’action {"3"}
• t4 est le temps d’exécution de l’action {"4"}

Sachant que le temps t2, t3, t4 sont bien définis et inchangés durant l'exécution
de cette ligne. Par ailleurs ces temps représentent une boucle qui se répète n fois. Donc
le temps nécessaire pour l'exécution de la boucle est donné par :
n*tb avec tb= t2 + t 3 + t 4
De ce fait, le temps d’exécution t(n) de cet algorithme s’écrit :
t(n) = t1+ t 2+n * tb
Ce qui signifie que le temps d’exécution dépend linéairement de la taille n.

2 Évaluation temporelle
L'évaluation temporelle d'un algorithme peut avoir plusieurs possibilités parmi
elles lorsqu'il s'agit d'une :
• Somme des temps : l'exécution de trois actions l'une après l'autre ou chaque action demande
un temps de traitement relatif,
Action 1 : Traitement 1 (t1)
Action 2 : Traitement 2 (t2 ) temps d'exécution : tn = t1+ t2+ t3
Action 3 : Traitement 3 (t3)

• Maximum de temps exp : c'est dans le cas d'une boucle avec la condition si

si < condition est vérifiée > alors on effectue

Action 1 avec temps de traitement1 (t1)
sinon temps d'exécution : tn = Max (t1, t2)
Action 2 avec temps de traitement 2 (t2)
7
 --- Algo 18-19

• Somme des temps de passages successifs exp:

tant que < condition est vérifiée > faire Traitement (t1)
Le temps d'exécution : tn = n* t1 avec n le nombre de tests à effectuer

Note : d'une manière générale, les performances asymptotiques des algorithmes dépendent
principalement du nombre de variables, n, et la taille du problème, en négligeant les termes de degré
inferieur par exemple :
y(n) = n3 + 3n2 + 4 n + 10 est une complexité d'ordre O(n3)
y(n) = n log n + 12 n + 17 est une complexité d'ordre O(n log n)