Algorithme Final

Introduction à
L’algorithmique
Pr Oubedda Latifa
Introduction à L’algorithmique 2023/2024
1 Qu’est – ce qu’un algorithme ?
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 (le touriste se retrouve là où il voulait aller). Si l’algorithme
est faux, le résultat est aléatoire.
un algorithme est un ensemble de règles logiques et chronologiques

qu’on doit suivre pour aboutir à la résolution d’un problème particulier. Ces
règles sont constituées d’un nombre fini d’opérations élémentaires
arithmétiques (+, -, *, /, \) et logique (AND, OR, NON). Ces opérations seront
exécutées dans un ordre bien déterminé.
Un algorithme peut être assimilé à un raisonnement que l’on peut traduire avec
un langage que toute personne peut comprendre. Ce langage est appelé LDA :
Langage de Description d’Algorithme qui n’est pas un langage informatique
mais un pseudo-code utilisé pour simplifier l’écriture algorithmique.
Le programme informatique est donc la traduction du LDA à un autre langage
compréhensible pour la machine (Pascal, Visual Basic, C, C++, C#, Java…)
3
La programmation commence par un raisonnement logique et chronologique qui sera explicité
dans un algorithme par des instructions élémentaires suivant un certain ordre logique afin
d’aboutir aux résultats souhaités. Ces instructions sont écrites avec le langage LDA dans un
premier temps pour bien magner la structure de l’algorithme et dans un deuxième temps ces
instructions seront traduisent avec un langage informatique compréhensible par l’ordinateur
qui va exécuter ces instructions.
Exemple-1
Ecrire un plan d’algorithme qui permet de résoudre l’équation ax+b = 0
 Début algorithme
 Retenir (saisir, lire) la valeur de a.
 Retenir (saisir, lire) la valeur de b.
 Si a est égal à zéro il y aura pas de solution.
 Sinon la valeur de x est obtenue en divisant -b par a.
 Afficher la valeur de x
 Fin algorithme
Exemple 2. Calcul de la TVA

Un client achète une quantité Q d'un produit valant M dirhams l'unité. Ecrire le plan de
l'algorithme permettant de calculer le montant TTC et le montant TVA pour la marchandise
achetée.
Plan de l'algorithme
1. Début de l'algorithme
2. Retenir (lire, saisir) la quantité Q
4
3. Retenir (lire, saisir) le prix unitaire M
4. Retenir (lire, saisir) le taux TVA
5. Calculer le montant hors taxe en multipliant la quantité Q par le prix unitaire M.
Nommons cette grandeur MHT.
6. Calculer le montant de la TVA en multipliant le montant hors taxe par le taux de la
TVA
7. Calculer le montant TTC en ajoutant au montant hors taxe (MHT) le montant de la
TVA
8. Afficher le montant hors taxe
9. Afficher le montant TTC Fin de
l'algorithme
Exemple-3 : Recherche d’un mot dans un dictionnaire.

On veut écrire un plan d’algorithme qui permet de faire une recherche d’un mot dans un
dictionnaire.
Méthode 1 : Recherche séquentielle
a. Début algorithme.
b. Retenir (saisir, lire) le mot à rechercher.
c. Ouvrir le dictionnaire à la première page.
d. Tant que le mot ne se trouve pas sur la page courante et la page courante n'est pas la
dernière exécuter l'étape e) sinon passer à l'étape f).
e. Passer à la page suivante.
f. Si le mot s'y trouve lire la définition sinon ce mot ne se trouve pas dans le
dictionnaire.
g. Fin de l'algorithme.
Bien évidement cette méthode n’est pas rapide. Et ce c’est pas la méthode qu’on utilise pour
faire ce genre de recherche ? . La méthode de recherche la plus intuitive est la suivante :
Méthode 2 : Autre méthode de Recherche
a. Début algorithme.
b. Retenir (saisir, lire) le mot à rechercher.
c. Ouvrir le dictionnaire à la page du milieu.
d. Tant que le mot ne se trouve pas sur la page courante et la page courante n'est pas la
dernière exécuter l'étape e) et f) sinon passer à l'étape g).
e. Si le mot se trouve dans la partie droite ouvre la page du milieu de cette partie
f.Sinon ouvre la page du milieu de la partie gauche g.
Si le mot s'y trouve lire la définition sinon ce mot ne se trouve pas dans le
dictionnaire.
h. Fin de l'algorithme.
D’après l’exemple-2 on peut conclure que plusieurs résonnement (algorithmes) peuvent
aboutir aux mêmes résultats. Donc il est toujours préférable de garder l’algorithme qui donne
5le résultat le plus rapidement possible sans consommer beaucoup de mémoire.
2 Comment formaliser un algorithme ?

Historiquement, plusieurs types de notations ont représenté des algorithmes.
Il y a eu notamment une représentation graphique, avec des carrés, des losanges, etc. qu’on
appelait des organigrammes. Aujourd’hui, cette représentation est quasiment abandonnée,
pour deux raisons. D’abord, parce que dès que l’algorithme commence à grossir un peu, ce
n’est plus pratique. Ensuite parce que cette représentation favorise le glissement vers un
certain type de programmation, dite non-structuré, que l’on tente au contraire d’éviter.
C’est pourquoi on utilise généralement une série de conventions appelée « pseudo-code », qui
ressemble à un langage de programmation 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.
Dans ce "langage", les algorithmes sont représentés par des blocs d'actions. On appellera bloc
d'actions un ensemble d'actions enchaînées séquentiellement dont l'exécution ne peut
commencer que par la première action du bloc et ne peut se terminer que par la dernière.
D'où la notation:
Début bloc
Action 1;
Action 2;
…………
Action n;
Fin bloc
2.1.1 Structure fondamentale d’un algorithme
 Nom de l’algorithme :
o Il permet tout simplement d’identifier un algorithme parmi d’autres.
 Les déclarations :
o C’est une liste exhaustive de variables utilisées et manipulées dans le corps de

l’algorithme.
 Le corps de l’algorithme :
o Dans cette partie de l’algorithme, sont placées les tâches à exécuter

(instructions, opérations, …).
 Les commentaires :
o Pour permettre une lecture plus aisée et plus compréhensive de l’algorithme
 Les Constantes :
o Elles représentent des chiffres, des nombres, des caractères, des chaînes de
caractères, … dont la valeur ne peut pas être modifiée au cours de l’exécution
de l’algorithme.
 Les Variables :
o Elles peuvent stocker des chiffres des nombres, des caractères, des chaînes de
caractères,… dont la valeur peut être modifiée au cours de l’exécution de
l’algorithme.
 Les Structures :
o Elles permettent de rassembler plusieurs variables ou constantes sous un même
7
identificateur, on parle également d’entités ou d’objets.
3 Les variables et les constantes :

Les constantes et les variables sont définis dans la partie déclarative par deux caractéristiques
essentielles, à savoir :
 L’identificateur : Il représente le nom de la variable, de la constante ou de la

structure. Il est composé généralement de lettres mais peut également contenir et de
chiffres.
 Il ne doit pas commencer par des chiffres
 Il ne doit pas contenir d’espaces, de caractères de ponctuation ou de

caractères accentués.
 Le type : Il représente la nature de la variable ou de la constante (entier, réel, booléen,

chaîne de caractères…).
En pseudo-code la déclaration se fait de la manière suivante :
Var <nom variable> : type de la variable
Exemples :
 var age : réel

 var adresse, ville : chaine
 var nbr_enfants , age : entier
3.1 Les types des variables

De façon générale, pour toute variable censé contenir une ou plusieurs informations devant
être traitées par le processeur, l’ordinateur doit lui réserver de la mémoire volatile (RAM). La
taille mémoire nécessaire pour stocker cet objet dépend de la nature de l’information en
question.
Exemple d’informations de base :

Les nombres entiers : Le caractère :
0, -1, 45, 36, -10 en décimal
45H, 0FBH, 64H en hexadécimal ‘a’ , ‘A’ , ’*’ , ’7’ , ’z’ , ’!’ , ….
10101111, 1011 en binaire
Les nombres réels : La chaîne de caractères
-3.67, 4.2569, –564.0, 18.36 10e-6 "électronique", "cd ROM de 80mn" , …

Le booléen :
Il ne peut prendre que deux états possibles : VRAI ou FAUX (True ou False)
8
Les différents types de variables données en langage C sont représentés dans le tableau ci-
dessous.
Type de donnée Signification Taille (en octets) Plage de valeurs

acceptée
char Caractère 1 -128 à 127
unsigned char Caractère non 1 0 à 255

signé
short int Entier court 2 -32 768 à 32 767
unsigned short Entier court non 2 0 à 65 535

int signé
int Entier 2 (sur processeur 16 bits) -32 768 à 32 767
4 (sur processeur 32 bits) -2 147 483 648 à 2
147 483 647
unsigned int Entier non signé 2 (sur processeur 16 bits) 0 à 65 535
4 (sur processeur 32 bits) 0 à 4 294 967 295
long int Entier long 4 -2 147 483 648 à 2
147 483 647
unsigned long Entier long non 4 0 à 4 294 967 295
int signé
float Flottant (réel) 4 3.4*10-38 à 3.4*1038
double Flottant double 8 1.7*10-308 à 1.7*10308
long double Flottant double 10 3.4*10-4932 à

long 3.4*104932
Les différents opérateurs utilisés dans les algorithmes sont :
Arithmétique Comparaison
Opérateur Algo Opérateur Algo

Addition + Supérieur stricte >
Soustraction - Inférieur stricte <
Multiplication * Supérieur ou égal ≥
Division / Inférieur ou égal ≤

Modulo MOD Egal =
9
Division entière \ Différent ≠
Puissance ^
Logique
Opérateur Algo
Fonction ET ET
Fonction OU OU
Fonction OU Exclusif OUX
Fonction NON NON
Dans les instructions Il y a un certain ordre d’exécution de ces opérateurs. Cette est mentionné
ci-dessous :
Priorité croissante de bas vers le haut

Opérateur algorithme
Opérateur de multiplication *
Opérateur de division /
Opérateur d'addition +
Opérateur de soustraction -
Opérateur d'infériorité stricte <
Opérateur de supériorité stricte >
Opérateur d'infériorité ou d'égalité <=
Opérateur de supériorité ou d'égalité >=
Opérateur d'égalité =
Opérateur d'inégalité <>
Opérateur et logique ET ET
Opérateur ou logique OU OU
Opérateur d'affectation 
3.2 L’opérateur Affectation

L'opération par laquelle on attribue une valeur à une variable s'appelle affectation. Dans un
algorithme (pseudo-code), l'instruction d'affectation se note avec le signe "←". le signe "←
" se traduit dans les langage informatique par le signe " = ". Le signe = est utilisé dans
certains langages à la fois comme étant opérateur de comparaison mais aussi comme
opérateur d’affectation
Exemples :
Variables A, B, C en Entier
Début
A ←5
B ←3
C←A + B
A ←2
C ← B –A + B
Fin
Après exécution de cet algorithme on aura A=2, B=3, C=4
Variables A, B en Entier
Début
A ➛5
B ➛A+ 4
A ➛A+ 1
B ➛A –7
B ➛A -B -7
Fin
Après exécution de cet algorithme on aura A=6, B=0
Var A, B, K : entiers
Lire (A)
Lire (B)
K A
A B
B K
Ecrire (A, B)
Cet algorithme permet d’échanger les valeurs de deux variables A et B, et ce quel que soit
leur contenu préalable.
4 Structures de contrôles
Sans ces structures un algorithme va s’exécuter d’une manière linéaire c.-à-d. une exécution
suivant l’ordre où elles sont énoncées.
Traitement 1
Traitement 2
Traitement 3
11
Traitement 4
Les structures de contrôles permettent de contrôler l’exécution linaire d’une suite
d’instructions. Il existe deux catégories de structures de contrôles
11
 Structures de contrôle alternatives
 Structures de contrôle itératives (répétitives)
1. Les structures de contrôles Alternatives

Une structure alternative offre la possibilité de donner des issues différentes à l’exécution
d’un algorithme. Ces issues vont être exécutées mutuellement. On peut rencontrer plusieurs
formes de structures alternatives.
1. La structure alternative réduite SI ... ALORS….FIN SI:

Cette structure permet de contrôler un seul bloc d’instruction. Dans cette structure,
l’exécution du traitement T2 ne dépend que la réalisation de la condition qui le précède.
Si la condition est vérifiée les traitements se font dans cet ordre : (T1 T2  T3).
Si la condition n’est pas vérifiée les traitements se font dans cet ordre : (T1 T3).
Cette structure est utilisée dans un algorithme de la manière suivante :
SI <condition> ALORS
[<bloc d'actions-1>]
FIN SI
[<bloc d'actions-2>]
4.1.2 La structure alternative complète SI ... ALORS…SINON….FIN SI :

Avec cette structure on peut contrôler deux blocs d’instruction. L’exécution de l’un des deux
traitements distincts possibles T2 et T3 ne dépend que la réalisation de la condition qui les
précède :
12
Si la condition est vérifiée les traitements se font dans l’ordre suivant: (T1 T2  T4).
Si la condition n’est pas vérifiée les traitements se font dans l’ordre suivant: (T1 T3  T4).
Dans un algorithme on écrit :
SI <condition> ALORS
[<bloc d'actions 1>]
SINON
FIN SI
4.1.3 Structure Alternative multiple : cas des conditions disjointes

Dans cette structure, l’exécution des traitements Ti dépend de la réalisation de la condition Ci
et de la réalisation de la négation de la condition précédente Ci-1.
Ti s’exécute si ᵃiᵃᵄᵃ ᵃ̅7̅−̅1est
̅ vrai.
Cette structure est utilisée dans les algorithmes de la manière suivante :
13Si <condition1> Alors

Traitement 1;
Sinon
Si <condition2> Alors
Traitement 2;
Sinon
Traitement 3;
Sinon
Traitement 4;
Sinon
Traitement 5;
Fin Si
Fin Si
Fin Si
Fin Si
Si on n’a pas d’instruction à mettre entre le «sinon » et « si », on peut les écrire sur la même
ligne. Dans ce cas on aura besoin de fermer avec « FinSi » que le premier « si » utilisé.
Traitement 1;
Sinon Si <condition2> Alors
Traitement 2;
Traitement 3;
Traitement 4;
Sinon
Traitement 5;
Fin Si
4. Structure alternative : (Cas des conditions non disjointes)

1. Contrôle de deux traitements
Dans on doit combiner les conditions avec les opérateurs logiques AND et/ou OR et/ou XOR.
Exemple :
14Si C1 AND C2 AND C3 AND ……AND Cn Alors

Traitement 1
Sinon
Traitement 2
FinSi
4.1.4.2 Contrôle de plusieurs traitements

Dans ce cas on doit imbriquer les structures alternatives. L’algorithme va être donné par
l’organigramme suivant :
L’algorithme en pseudo code est donnée par :

.
.
Si <condition(n)> Alors
Traitement n
Sinon
Traitement n’
Fin si
.
.
Sinon
Traitement 3’
Fin Si
Sinon
Traitement 2’
Sinon
Traitement 1’
Fin Si
Exemple : on veut écrire un algorithme qui permet de résoudre l’équation : ax2 + bx + c = 0 et

15ceci quel que soit les valeurs de a, b et c saisies par l’utilisateur.
Pour résoudre ce problème on doit traiter 4 cas possibles :
Si (a=0) AND (b=0) AND (c=0) alors la solution est IR

Si (a=0) AND (b=0) AND (c#0) alors la solution est impossible
Si (a=0) AND (b#0) alors il existe une seule solution « -c/b »
Si (a#0) alors il existe deux solutions (calcul de Delta)
L’algorithme est donnée par :
Var a, b, c : entiers
Var x1, x2, D : réels
Lire (a, b, c)
Si (a=0) alors
Si (b=0) alors
Si (c=0) alors
Ecrire(«la solution est I R »)
Sinon
E crire(«impossible»)
Finsi
Sinon
x1  -c/b
Ecrire(«la solution est :», x1)
Finsi
Sinon
D  b^2 – 4*a*c
Si (D>0) alors
Ecrire(«les solutions sont: », (-b+sqrt(D))/(2*a), (-b-sqrt(D))/(2*a))
Sinon
Si (D=0) alors
Ecrire(«la solution est: », -b/(2*a))
sinon
Ecrire (« pas de solution dans I R »)
FinSi
FinSi
F inSi
Fin
2. Structures de contrôle itératives
Les structures itératives permettent de répéter l’exécution d’un ensemble d’instructions une ou
16plusieurs fois. Ces structures sont regroupées sous deux grandes familles selon si : le nombre
de répétitions est connu ou pas.
1. Cas où le nombre de répétition est connu (Pour….allant….suivant):
Dans cette structure, la sortie de la boucle d’itération s’effectue lorsque le nombre souhaité de
répétition est atteint.
On utilise donc une variable d’itérations caractérisée par :
• sa valeur initiale V i
• sa valeur finale Vf
• son pas de variation p
En pseudo-code on écrit :
Pour i Vi à Vf [pas p]

[<bloc d’actions >]
Suivant i
Dans le cas où la valeur finale de l’indice est inférieure à sa valeur initiale le pas de variation
est négatif, la structure est dite «décroissante». Dans le cas contraire, le pas est positif et la
structure est dite «croissante ».
Exemple :
L’algorithme qui permet de faire la somme de N valeurs est :
Var V, S, N, i entiers
S0
Lire (N)
Pour i  1 à N Ecrire
(« V= ») Lire
(V)
SS+ V
Suivant i
Ecrire(« la somme est : », S)
La simulation de l’exécution de cet algorithme pour N=3 est donnée par le tableau ci-
dessous :
i=0 var=2 S=0+2 2
17i=1 var=-3 S=2-3 -1
i=2 Var=4 S=-1+4 3
i=3 Var=-8 S=3-8 -5
i=4 Arrêt des itérations
Donc après l’arrêt de la boucle, les valeurs qui reste en mémoire de i et S sont : i=4, S=-5
Cas des boucles imbriquées

Dans quelques problèmes, on sera ramené à utiliser des boucles impliquée. Dans ce cas on
doit utiliser deux conteurs i et j. la variation de « j » va se faire dans la variation de « i ». on
fait varier le compteur i de i0 à if et pour chaque « i » on fait varier « j » de j0 à jf.
Pour i allant de Vi à Vf [pas p]

Pour j allant de Wi à Wf [pas p]
Suivant j
Suivant i
2. Cas où le nombre de répétition est inconnu

1. Structure : Tant que …. Faire
Dans cette structure, la sortie de la boucle d’itération s’effectue lorsqu’une condition n’est
plus vérifiée. Tant que la condition est vérifiée on répète l’exécution du bloc d’instruction
contrôlé. Le nombre des itérations peut être calculé après la sortie de la boucle.
i  V0
Tant que <condition> faire
i  i+1
Fin tant que
Dans cette structure la vérification de la condition se fait avant l’exécution du bloc

d’instruction. Le bloc d’instruction peut donc ne jamais être exécuté.
Exemple :
Nous voulons écrire un algorithme qui calcul la somme des valeurs saisies à l’entrée. On
arrête le calcul de la somme lorsque l’utilisateur saisi la valeur var = -1. La valeur -1 ne doit
être intégrée dans le calcul de la somme.
Var S, var : entier
i1
18S  0
Ecrire ("saisir la valeur", i)
Lire (var)
Tant que (var < > -1) faire
S  S + var
ii+ 1
Ecrire ("saisir la valeur", i)
Lire (var)
Fin tant que
Ecrire("La somme est :", S)
Ecrire("Le nombre de valeur sommées est :", i-1)
Une simulation de cet algorithme est donné par :
var=2 i=1 S=0+2 2
var=-3 i=2 S=2-3 -1
Var=4 i=3 S=-1+4 3
Var=-8 i=4 S=3-8 -5
Var=-1 i=5 Arrêt des itérations
A l’arrêt de l’algorithme on aura dans la mémoire : Var=-1, i=5, S=-5.
4.2.2.2 Structure : Répéter …..Tant que

Dans cette structure, la sortie de la boucle d’itération s’effectue lorsqu’une condition n’est
plus vérifiée. Tant que la condition est vérifiée on répète l’exécution du bloc d’instruction
contrôlé. Le nombre des itérations est donné après la sortie de la boucle.
i  V0
Répéter
i  i+1
Tant que <condition>
Dans ce cas la vérification de la condition se fait après l’exécution du bloc d’instruction. Donc
le bloc d’instruction s’exécute au moins une fois.
Exemple :
Nous voulons écrire un algorithme qui calcul la somme des valeurs saisies à l’entrée. On
19arrête le calcul lorsque la somme devienne supérieure à 1000.
Var S, var, i: entier

i1
S0
Répéter
Ecrire("Saisir la valeur", i)
Lire (var)
S  S + var
ii+ 1
Tant que (S < 1000)
Ecrire ("La somme est :", S)
Ecrire("Le nombre de valeur sommées est :", i-1)
Avec la boucle tant que faire
 condition vérifiée avant chaque exécution du traitement
 le traitement peut donc ne pas être exécuté
 la condition porte surtout sur la saisie de nouvelles variables (relance)
Avec la boucle répéter tant que
 condition vérifiée après chaque exécution du traitement
 le traitement est exécuté au moins une fois
 la condition porte surtout sur le résultat du traitement
4.2.2.3 Choisir entre pour... tant que… répéter…
Le choix entre les structures de répétition déjà mentionnées se fait suivant deux critères :
Est que le nombre d’itération connu ou pas ?
Est que le Traitement doit être exécuté avant ou après le test d’arrêt de la boucle ?
5 Algorithme du calcul du Maximum et du Minimum

20On veut trouver la valeur maximale (minimale) d’un ensemble de valeurs dont le nombre est
inconnu. La saisie de ces nombres se termine lors de la saisie d’un nombre nul. La valeur 0
ne doit pas appartenir à l’ensemble de nombre dont on cherche le maximum. La méthode
qu’on va utiliser est une méthode itérative. Le principe c’est de comparer chaque valeur avec
la suivante et d’éliminer la valeur la plus petite (la plus grande). On gardera en mémoire que
la valeur maximale (minimale).
Var x, Max, Min : réels

Ecrire (« donner la 1ère la valeur non nulle»)
lire (X)
Max  X
Min  X
i=2
Tantque (X < > 0)
si (X > = Max) alors
Max  X
FinSi
si (X < = Min) alors
Min  X
FinSi
Ecrire (« donner la valeur », i)
lire (X)
i  i+1
Fin tant que
Ecrire(« saisie terminée »)
Ecrire(« la plus petite valeur est: », Min) Ecrire
(« la plus grande valeur est: », Max) Ecrire
(« la plus petite valeur est: », Min)
6 Les tableaux
Dans la plus part du temps, on aura besoin dans des algorithmes de garder en mémoire
plusieurs valeurs. Dans ce cas on doit déclarer des tableaux. Ces dernières permettent de
stoker plusieurs variables de même type sous un même identificateur. On peut déclarer des
tableaux d’entiers de réels ou de caractères. Chaque tableau possède des dimensions, on
parlera de tableau à :
- une dimension ou on peut stoker une liste de données par exemple.

- deux dimensions qui peut être utilisé dans le traitement d’image
- trois dimensions qui peut être utilisé pour stocker des données spatiales
- à quatre dimensions pour stocker des données spatiales qui évoluent avec le temps
Le nombre de dimension d’u tableau n’est pas limité mais l’espace mémoire réservé pour un
tableau augmente fortement avec le nombre de dimension. Problème de la taille limité de la
21mémoire.
6.1 Accès aux données
Pour accéder aux données un tableau possède des indices. Un tableau à une dimension
possède un indice, pour un tableau à deux dimension on trouve deux indices (indice ligne et
indice colonne), dans un tableau à trois dimensions on a besoin de trois indices (ligne, colonne
et profondeur).
Les cases sont numérotées à partir de zéro, autrement dit que le plus petit indice est zéro. Lors
de la déclaration d’un tableau on doit préciser sa dimension. C-a-d le nombre de cases qu’on
doit réserver dans la mémoire pour stocker toutes les valeurs qu’on aura besoin dans notre
traitement. On précise donc dans la déclaration la plus grande valeur de l'indice qui est
différente du nombre de cases du tableau. Si, par exemple, on veut 12 emplacements, le plus
grand indice sera 11.
Syntaxe en pseudo-code :
Var tab1(11) : entiers

Var Tab2(19)(29) : réels
…….
En mémoire un tableau occupe un seul bloc continu et linéaire. Chaque case du tableau
déclaré correspond à une allocation d’un ensemble continu d’emplacement mémoire appelé
« élément mémoire ». Chaque case est adressée par l’adresse mémoire qui correspond au
premier emplacement mémoire réservé pour stocker le contenu de cette case. La taille de
l’élément mémoire dépond du type de données stockées dans le tableau. La figure-1
représente l’implantation dans la mémoire centrale d’un tableau à deux dimensions.
22
Exemple-1 :
Tableau Tab (19) : entiers

Pour i = 0 à 19
Lire (Tab(i))
Suivant i
Dans cet algorithme on a déclaré un tableau T(19). On peut stocker donc 20 valeurs.
Var Tab : entiers

Pour i = 0 à 19
Lire (Tab(i))
Suivant i
Dans cet algorithme on a déclaré une variable Tab. On va stocker donc en mémoire que la
dernière valeur saisie.
Exemple-2:
On veut saisir une suite de nombres, puis afficher cette suite après avoir divisé tous les
nombres par la valeur maximale de la suite. Nécessité donc de conserver les nombres en
mémoire.
Pour un ensemble de 5 valeurs, l’algorithme qui permet de résoudre le problème est :
Tab T(4) entier

23
Var Max entier
Ecrire(« donner la 1ère valeur »)
Lire (T(0))
Max  T(0)
Pour i = 1 à 4
Ecrire(« donner les valeur », i)
Lire (T(i))
Si (T(i) > Max) alors
Max  T(i)
Fin si
Suivant i
Ecrire (« les nouvelles valeurs sont: »)
Pour i = 0 à 4
Ecrire(T(i)/Max))
Suivant i
2. Les tableaux Dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre d’éléments que devra
comporter un tableau. La dimension du tableau va être connue au cours du traitement.
Dans ce cas on peut :
- Déclarer un tableau avec une dimension maximale. Cette proposition comporte
deux Inconvénient :
- on ne peut pas être sûr du nombre d’élément qu’on doit stocker dans le tableau.
- on aura une grande consommation de la mémoire.
- Déclarer un tableau dynamique
- déclarer le tableau sans préciser au départ sa dimension
- au cours du programme, on va fixer la dimension via une fonction de
dimensionnement : Dim().
- Si on veut des cases supplémentaires au cours de l’exécution (cad agrandir le
tableau), on utilise une fonction de redimensionnement du tableau ReDim()..
Var Notes() en Numérique
Var nb en Numérique
24 Début
Ecrire("Combien y a-t-il de valeurs à saisir ?")
Lire(nb)
Dim(Notes, nb)
…………
Ecrire(« Nous voulons ajouter des valeurs »)
Lire(nb’)
ReDim(Notes, nb+nb’)
…..
…..
…..
Fin
Exemple-1:
Donner un algorithme qui stocke n notes dans un tableau de valeur et calcule et affiche la
moyenne. L’utilisateur peut saisir un nombre n de note.
Tableau Note() : réels

Var S, Moy : réel
Var i, n : entier
Début
Ecrire(« donner le nombre de note »)
Lire(n)
Dim(Note, n)
S0
Pour i  0 à n-1
Ecrire(« donner la note », i+1)
lire(Note(i))
SS+Note(i)
Suivant i
Moy  S/n
Ecrire(« la moyenne est : », Moy)
Exemple-2:
Exercice:
Donner un algorithme qui stocke un certain nombre inconnu de notes dans un tableau de
valeur et calcule et affiche la moyenne. L’utilisateur peut arrêter la saisie en entrant (-1).
var Note() : réels
Var S, Moy : réel
25Var i, n : entier
i=0
Dim(Note, 1)
Lire(Note(0))
S0
Tant que (Note(i)<>-1) faire
SS+Note(i)
i  i+1
Redim(Note, i+1)
lire(Note(i))
Fin tant que
Moy  S/n
Ecrire(« la moyenne est : », Moy)
7 Les fonctions & les procédures
1. Structuration
La décomposition en plusieurs sous-programmes est un moyen efficace pour bien contrôler un

programme informatique (diviser pour mieux régner). Les fonctions et les procédures
permettent de décomposer un programme complexe en une série de sous-programmes plus
simples, lesquels peuvent à leur tour être décomposés eux-mêmes en fragments plus petits, et
ainsi de suite.
Les fonctions et les procédures présentent donc un intérêt primordial dans les conceptions des
algorithmes. Ils ont comme rôles de :
 Regrouper un ensemble d’instruction dans le même algorithme afin de pouvoir y faire
appel autant de fois que nécessaire.
 Avoir un algorithme principal qui fait appel aux différents fonctions et/ou procédures
 Avoir une lisibilité et identification faciles des erreurs.
Il est inutile de connaître comment est définie une fonction ou une procédure pour y faire
appel. Par contre il est nécessaire de connaître sa déclaration (son manuel d’utilisation):
26  Quel est son rôle?
 Quels sont les arguments à fournir?
 Quelles est la valeur retournée?
2. Les paramètres d’entrés de sorties et d’entrés/sortie

Les procédures et les fonctions peuvent nécessiter éventuellement un ou plusieurs paramètres
d’entrée ou de sortie.
Un paramètre d’entrée est la référence à une variable manipulée par la procédure ou la

fonction. Dans ce cas la valeur d’une variable du programme principal est copiée dans ce
paramètre.
Un paramètre de sortie est une variable dont la valeur est affectée par les instructions du
sous-programme
Un paramètre d’entrée-sortie Un paramètre peut jouer à la fois le rôle de paramètre d’entrée

et de sortie.
3. Les fonctions
Les fonctions sont des sous-programmes admettant des paramètres et retournant un seul
résultat (comme les fonctions mathématiques y=f(x,y,. . .)
 les paramètres sont en nombre fixe (n>0)
 une fonction possède un seul type, qui est le type de la valeur retournée
 la valeur de retour est spécifiée par l'instruction « retourner (renvoyer) »
Généralement le nom d’une fonction doit être explicite: Maximum() ; Minimum()
Syntaxe en pseudo-code
Fonction (E a : entier, E b : chaine: ) : réel

Début
Var ….., res en réel
…..
…..
Renvoi res
Fin
Remarque :
Dans la syntaxe, on précise qu’un paramètre est d’entrée ou de sortie si on précède le
paramètre par, respectivement, la lettre « E » ou « S ». Si ne précède le paramètre par aucune
lettre on le considère comme d’entrée. Un paramètre est noté d’entrée-Sortie s’il est précédé
par « E/S ».
Exercice1 : Ecrire un algo qui permet de calculer les termes U1, U2, …., U10 d’une suite
arithmétique connaissant le premier terme U0, la raison « r » et le rang « n ».
27
Solution :
1. terme (E rang : entier, E raison : entier, E terme0 : entier) : Entier

2. Début
3. var val : entier
4. val  terme0 + raison*rang
5. Renvoi val
6. Fin
1. Début
2. Var n, U0, U, r : entier
3. Ecrire(« premier terme ?»)
4. Lire(U0)
5. Ecrire(« raison ?»)
6. Lire(r)
7. Ecrire(« les termes U0, U1, …U10 sont: »)
8. Pour n=1 à 10
9. U terme(n, r, U0)
10. Ecrire(U)
11. Ecrire(« »)
12. Suivant n
13. Fin
Exercice2 : Ecrire une fonction Maximum(T, n) qui permet de trouver le maximum d’un
tableau d’un certain nombre de valeurs. Ecrire un algorithme test qui appelle cette fonction.
Solution
Maximum(T(): réel, n : entier)
Var Max : reél
Var i : entier
Max  T(0)
POUR i 1 à n-1
SI(T(i) > Max) ALORS
Max  T(i)
FIN SI
suivant i
Renvoyer(Max)
Tableau V( ) : réels
Var M : reél
28Var N, k : entiers
Début
Ecrire(‘’’N=‘’)
Lire (N)
Dim(V, N)
POUR k  0 à N-1
Ecrire(« donner la valeur », k)
lire(V(k))
SUIVANT k
M  Maximum(V, N) Ecrire
(« le max est : », M)
7.4 Les Procédures
Les procédures sont des sous-programmes qui ne retournent aucun résultat. Par contre elles
admettent des paramètres d’entrés, de sorties ou d’Entrés/Sorties.
Syntaxe en pseudo-code
Procédure (E a, chaine: S b, réel : E/S c)

Début
Var ….. en réel
…..
…..
Fin
Exercice-1 :
Ecrire une procédure permute(a, b) qui permute les valeurs de ceux variables entiers.
Ecrire une autre procédure Tri (x, y, z) qui tri dans l’ordre croissant en appelant la procédure
permute(a, b). Ecrire un algorithme d’essai.
Solution :
Permuter (a : entier, b: entier)
Début
Var k : entier
K a
ab
bk
Fin
Trier (x: entier, y : entier, z : entier)
Début
29Si (x<y) alors
Permuter(x, y)
Fin si
Si (y<z) alors
Permuter(y, z)
Fin si
Si (x<y) alors
Permuter(x, y)
Fin si
Fin
Var w1, w2, w3 : entiers

Ecrire(« donner les 3 valeurs »)
Lire (w1, w2, w3)
Trier(w1, w2, w3)
Ecrire(« les valeurs triées sont: » , w1, w2, w3)
Attention!!!!
Dans le langage C la permutation ne va pas s’effectuer à cause des noms des paramètres
fictifs et formels qui ne sont pas les mêmes. Dans ce cas les adresses de ces paramètres seront
différentes. Par conséquent La permutation va se faire seulement pour les valeurs stockées
dans les adresses des paramètres fictifs.
Pour surmonter ce problème on propose deux solutions :
 Prendre les mêmes noms des paramètres ce qui est impossible dans ce cas.
 Copier dans les paramètres d’entrées les adresses des variables et non pas les valeurs
donc nécessité d’utiliser les pointeurs
Exercice-2 :
Créer une fonction max2(a, b) qui renvoi le maximum de deux variables:
Créer une fonction VMAX(T) qui permet trouver le maximum des éléments d’un vecteur de 4
valeurs et ceci en appelant la fonction max2().
Créer un algorithme d’essai.
Solution :
30Max2(a: réel, b: réel) : réel

Dédut
Var k : réel
K a
Si (b>a) alors
K b
Finsi
Renvoyer (k)
VMAX(T(3)): réel
Début
Var M :réel
M  Max2(Max2(Max2(T(0), T(1)),T(2)),T(3))
Renvoyer (M)
Tableau V(3) :réel

Var k : entier
Pour k  0 à 3
Ecrire(« donner la valeur», k)
Lire V(k)
Suivant k
Ecrire(« la maximum est: », VMAX(V))
7.5 Les pointeurs
Afin de pouvoir manipuler les adresses mémoires, nous utilisons les pointeurs. Ces derniers
sont des variables qui contiennent l’adresse des variables d’un certain type. On parle des
pointeurs d’entiers des pointeurs des réels etc….
Il y a deux façons pour manipuler les adresses des variables
En déclarant une variable d’un certain type de valeur. L’adresse sera manipuler par
« &nomvariable » tandis que la valeur stockée dans cette adresse sera donnée par
« nomvariable »
Syntaxe:
Var x : entier
Lire(x)
Ecrire (« l’adresse de x est : &x)
Ecrire (« la valeur de x est : x)
En déclarant un pointeur sur une variable d’un certain type. L’adresse sera manipulée par
« nompointeur » et la valeur stockée dans cette adresse est donnée par « *nompointeur »
31
Syntaxe:
Var x : entier
Var p : pointeur_entier
Lire(x)
P = &x
Ecrire (« l’adresse de x est : p)
Ecrire (« la valeur de x est : *p)
Nous reprenons ci-dessous l’algorithme de l’exemple précédant qui demande la création

d’une procédure qui permute les valeurs de deux variables (page 29-30) mais cette fois en
utilisant les pointeurs.
Permuter (a : pointeur-entier, b: pointeur-entier)

Début
Var k : entier
K  *a
*a  *b
*b  k
Fin
Trier (x: pointeur-entier, y : pointeur-entier, z : pointeur-entier)

Début
Si (*x<*y) alors
Permuter(x, y)
Fin si
Si (*y<*z) alors
Permuter(y, z)
Fin si
Si (*x<*y) alors
Permuter(x, y)
Fin si
Fin
Var w1, w2, w3 : entiers

Ecrire (« donner les 3 valeurs »)
Lire (w1, w2, w3)
Trier(&w1,&w2, &w3)
Ecrire (les valeurs triées sont: », w1, w2, w3)
326. Processus d’analyse
1. La décomposition en sous traitement

Le processus d’analyse permet de décomposer un traitement complexe en sous traitement
« plus simples » mais différent du précédent. À leur tour, ces sous problèmes seront à leur
tour décomposés jusqu’à un niveau d’opération « élémentaires » faciles à réaliser.
7.6.2 La décomposition récursive

Dans certain cas, le sous traitement est une illustration du problème initial, mais pour un cas
« plus simple ». Par conséquent, la solution du problème s’exprime par rapport à elle-même!
On appelle ce phénomène récursivité.
Dans un raisonnement par récurrences : pour résoudre un problème complexe on appelle le

même traitement initial mais avec un cas plus simple.
Exemple de Récursivité
La factoriel de n est donnée par :
n! = 1*2*…..*(n-1)*n
n! = n*(n-1)!
Pour calculer la valeur de n!, il suffit donc de savoir calculer (n-1)! Et ensuite de multiplier
33
cette valeur par n.
Le sous problème du calcul (n-1)! Est le même problème initial, mais pour un cas « plus
simple » car (n-1 < n)
7. Les fonctions récursives

Pendant le traitement d’une fonction nous pouvons appeler d’autres fonctions déjà déclarées
(décomposition en sous problèmes).
Nous pouvons aussi, Pendant le traitement d’une fonction, appeler la même fonction initiale
mais avec des arguments plus simples (décomposition récursive)
Une fonction récursive est une fonction qui s’appelle elle-même dans son traitement. Si la
fonction appelée n’est autre que la fonction qui appelle, on déclenche une boucle infinie.
1. Exemples
1. Fonction Factoriel
Ecrire l'algorithme de la fonction factorielle en employant les deux méthodes itérative et
récursive.
Résonnement itérative Résonnement récursive
Fact(n: entier): entier Fact(n: entier) : entier

Var res, i : entier Début
Si (n = 0) alors Var res : entier
res  Si(n=1) alors
1 Sinon res  1
Res  1 sinon
Pour i  2 à Res  n*Fact(n-1)
n Res  finSi
Res*i Renvoyer (res)
Suivant Fin fonct
i Fin si
Revoyer (Res)
Fin Fontion
Algorithme : principal
var N : entier
Début
Ecrire(« donner la valeur de N »)
Lire(N)
Ecrire(N, ‘’!=’’, FACT(N))
Fin
Fin Algo
Simulation: de du résonnement récursive pour N = 5
34Fact(5)=5*Fact(4)
=5*4*Fact(3)
=5*4*3*Fact(2)
=5*4*3*2*Fact(1)
=5*4*3*2*1
7.7.1.2 Fonction Racine carrée
La valeur de la racine carrée d'un nombre A peut-être approximée en employant la suite

récurrente d'ordre 1 suivante:
On constate que la récursivité ne porte pas sur la variable principale du problème A (variable
dont on cherche la racine : A) mais la récursivité porte sur une autre variable X
Solution :
1. Réel racine(A : réel, X : réel)

2. Début
3. variable res en réel
4. Si ABS(X * X – A) < = 0,001 Alors
5. Res x
6. Sinon
7 . R es  racine(A, ( X + A /X ) /2)
8. FinSi
9. Délivre res
10.Fin
1. Var Z réel
2. Ecrire(‘’Z=‘’)
3. lire(Z)
4. Ecrire(‘’la racine carré de’’, z, ‘’est’’, racine(Z, 1))
5. Fin
Simulation A=2, X=1
35Res = racine(2, 1.5)

2,25 – 2 = 0,25 > 0,001
Res = racine(2, 1,416)
Res = racine(2, 1,414)
|(1,414)2 – 2| = 0,0006 < 0,001
7.7.1.3 Recherche du Maximum avec une méthode récursive

Soit la fonction Max(a, b) qui renvoi le maximum de deux réels.
Ecrire une fonction récursive « RecMax(V, n) » qui renvoi le maximum des valeurs d’un
tableau V de dimension n. cette fonction aura pour argument les éléments du vecteur V et la
dimension n
Cette fonction récursive doit renvoyer la valeur suivante:
Solution
Max(a: entier, b: entier) Algo principale

Début Tableau T() : entier
Si a > b alors Var N, i : entiers
renvoyer (a) Ecrire(« donner la dimension du tableau »)
Sinon Lire (N)
renvoyer (b) Dim(T, N)
Fin si Pour i 0 à N-1
Fin Fonct Ecrire(‘’T()=‘’, i)
lire(T(i))
RecMax(V() : entier, n : entier) Suivant i
Var G : entier Ecrire(« le maximum est : », RecMax(T,
Si (n=2) alors N))
G  Max(V(0), V(1)) Fin algo
sinon
G  Max(RecMax(V, n-1), V(n-1))
Finsi
Renvoyer (G)
Fin Fonct
7.7.1.4 Recherche du Maximum avec la Méthode de diviser pour régner
36Pour trouver le maximum des valeurs d’un tableau de dimension n (V(0..n-1)) en utilise la
méthode « diviser pour régner ». Cette méthode se compose de trois étapes
Diviser : diviser le tableau en deux sous-tableaux.

Régner : trouver récursivement le maximum et le minimum dans chaque demi-tableau.
Combiner : retourner le maximum des deux maximums trouvés.
Algorithme :
On suppose qu’on dispose d’une fonction Max() qui permet de trouver la maximum de deux
valeurs.
Soit les variables :
Deb : indice du premier élément du tableau
Fin : indice du dernier élément du tableau
Med : indice du milieu d tableau
Max1 : le maximum du premier demi-tableau
Max2 : le minimum du deuxième demi-tableau
Fonction FMax(V() : entier, deb :entier, fin : entier)

Début
Var mid, max1, max2 : entiers
Si ((fin - deb) <=1) alors
Renvoyer(Max(v[fin], v[deb]));
sinon
mid  (deb + fin)/2;
max1 FMax(v, deb, mid);
max2  FMax(v, mid+1, fin);
Renvoyer(Max(max1, max2));
Fin Si
Fin Fonction
8 Les algorithmes de Tri

Les tableaux permettent de stocker plusieurs éléments de même type au sein d'une seule
entité. Trier un tableau c'est donc ranger les éléments d'un tableau en ordre croissant ou
décroissant.
Il existe plusieurs méthodes de tri qui se différencient par leur complexité d'exécution et leur
complexité de compréhension pour le programmeur.
 Nous exposons dans ce cours deux méthodes :
 le tri par minimum (maximum) successif (tri de selection)
 Le tri à bulles
Dans ces deux méthodes de tri, on doit utiliser une procédure qui permet d'échanger (de
permuter) la valeur de deux variables.
37
1. Permuter (E/S a, b : Entier)
2. var T : Entier
3. Début
4. T a
5. ab
6. bT
7. Fin
8.1 Le tri par la méthode du Min ou Max successif (Tri par sélection)
Cette méthode consiste à parcourir le tableau de gauche à droite, on cherche le plus petit
élément puis on le positionne dans l’indice i du tableau. On recommence la même opération
pour le sous-tableau de droite qui commence par l’indice i+1.
plus généralement : Pour trier le sous-tableau t[i..nbElements] il suffit de positionner au rang

i le plus petit élément de ce sous-tableau et de trier le sous-tableau t[i+1..nbElements]
Par exemple, pour trier [221, 215, 130, 163, 147, 120] suivant un ordre croissant, on va avoir
les boucles suivantes :
Il nous faut donc :
- une fonction Index_min() qui soit capable de déterminer l’indice du petit élément d'un
tableau à partir d'un certain rang.
- Une procédure Tri() qui appelle la fonction Index_Min() pour trouver l’indice i_min
correspondant au minimum puis permute l’élément i_min avec l’élément i.
Index_min(V(): entier, n:entier, rang: entier) :entier Tri(T() : entiers, N: entier)

Début Début
Var i, pmin, Min : entiers Var i_min, i, k : entiers
Min  V(rang) Pour i = 0, N-2
Pmin  rang i_min  Index_min(T, N, i)
Pour i  rang+1, n-1 si(i < > i_min) alors
38 si V(i)<Min alors k  V(i)
Min V(i) V(i)  V(i_min)
pmin V(i_min)  k
i fin si Fin si
Suivant i Suivant i
Renvoyer(pmin Fin procédure
) Fin fontion
Algo test
Tableau Tab() : entiers
Var i, D : entiers
Début
Ecrire(« donner le nbre de valeurs)
Lire(D)
Dim(tab, D)
Pour i  0, D-1
Ecrire(« Tab() », i)
lire(Tab(i))
Suivant i
Tri(tab, D)
Pour i  0, D-1
Ecrire(Tab(i)
) Suivant i
8.2 Le tri par la méthode à bulles

Cette méthode consiste à parcourir le tableau du début à la fin et en échangeant tout couple
d'éléments consécutifs non ordonnés jusqu'à ce que le minimum (maximum) se case à droite
(à gauche). On recommence la même opération mais cette fois avec le tableau sans les
éléments déjà casés.
Par exemple, pour trier [130, 156, 213, 230, 300] suivant un ordre décroissant, on va avoir les
boucles suivantes :
39
i=2 ; ………….
Avec cette méthode on utilisera deux boucles imbriquées.
Tri(V():entier, n:entier) Algo test

Début Tableau Tab() : entiers
Var k, i, j : entiers Var i, D : entiers
Pour i  0 à n-2 Début
Pour j  0 à n-2 - i Ecrire(« donner le nbre de valeurs)
si (V(j)>V(j+1) alors Lire(D)
k  V(j) Dim(tab, D)
V(j)  V(j+1) Pour i  0, D-1
V(j+1)  k Ecrire(« Tab() », i)
Finsi lire(Tab(i))
Suivant j Suivant i
Suivant i Tri(tab, D)
Fin procédure Pour i  0, D-1
Ecrire(Tab(i)
) Suivant i
9 Les algorithmes de Recherche

1. Recherche linéaire dans un ensemble non trié
On procède par une recherche linéaire on parcourant le tableau et lorsque qu’on trouve le
nombre recherché (T(i)=X) on renvoi l’indice correspondant. Si on parcourt tous le tableau
sans trouver la valeur recherchée on déclare que le nombre n’existe pas.
Recherche(T(), X , Nb)
Var i, R : entier
40i  0
Tant que (i<=Nb-1 ET T(i) < > X) Alors
i  i+1
Fin tant que
Si (i = Nb) alors
Ecrire (« le nombre est introuvable »)
Sinon
Ecrire (« le nombre de trouve dans l’indice »)
Renvoyer (i)
FinFonction
9.2 Recherche linéaire dans un ensemble trié suivant un ordre croissant

On procède par une recherche linéaire on parcourant le tableau et tant que l’élément du
tableau est inférieur au nombre recherché (t(i) < X) on continu la recherche. Si on parcourt
tous le tableau sans trouver la valeur recherchée on déclare que le nombre n’existe pas.
Recherche(T(), X , Nb)
Var i, R : entier
i0
Tant que (i<=Nb-1 ET T(i) < X) Alors
i  i+1
Fin tant que
Si (i = Nb) alors
Sinon
Renvoyer (i)
Fin
9.3 Recherche par la méthode de Dichotomie

Nous allons illustrer cette méthode à travers l’exemple du jeu du nombre caché qu’on va
traiter avec deux méthodes normale et dichotomique.
Le jeu du nombre caché
Une personne choisi un nombre compris entre 1 et 100, on doit deviner ce nombre. Nous
allons faire des propositions et la personne répond "trop grand", "trop petit" ou "gagné". Le
jeu s’arrête lorsqu’on va trouver le nombre.
L’algorithme à travers lequel on va trouver le nombre caché est :
Soit N un nombre choisi entre 0 et 100 et P la proposition pour deviner N

Var X , N, P
41Ecrire (« donner un nombre entre 0 et 100)
Lire (N)
L ire (P)
Tant que (P < > N) faire
Si (P > N) alors
Ecrire (« trop grand »)
Sinon
Ecrire (« trop petit »)
Fin Si
Lire (P)
Fin tant que
Ecrire (« gagné »)
Si on procède avec cette méthode, nous allons passer beaucoup de temps à chercher le nombre
caché. Quelles techniques de jeu peut-on employer pour gagner le plus rapidement possible ?
La technique-1: Si on propose un nombre G plus grand que celui recherché, on va proposer un

autre nombre dans l’intervalle [0..G-1]
Si on propose après un nombre P plus petit que celui recherché, on va proposer un autre
nombre dans l’intervalle [P+1..G-1] et ainsi de suite
Chaque fois qu’on propose un nombre on limite plus l’intervalle de recherche
Var X , N, P, Min, Max : entier;

Ecrire(« choisir un nombre entre 0 et 100 ");
Lire(N)
Lire(P)
Min=0;
Max=100;
Tant que (P < > N)
Si (P > N) Alors
Max = P-1;
Ecrire("donner un nbre entre", Min, Max)
Sinon
Min = P+1;
printf("donner un nbre entre", Min, Max)
FinSi
Lire (P);
Fin tant que
Ecrire("gagné");
La technique-2 Méthode de dichotomie:

42
Cette méthode est identique à la précédente seulement les valeurs proposées seront proche du
milieu des intervalles [Min..Max]. la proposition va être donc trouvée dans un traitement dans
l’algorithme.
Chaque fois qu’on propose un nombre on limite plus l’intervalle de recherche en écrasant les
valeurs de Min et Max.
Var X , N, P, Min, Max : entier

Ecrire("donner un nombre entre 0 et 100 ");
Lire(N);
Min  0;
Max  100;
P  (Max+Min)/2;
Ecrire(P);
Tant que (P < > N) faire
Si (P > N) Alors
Max = P-1
Sinon
Min = P+1
Fin Si
P= (Max+Min)/2;
Ecrire(P);
Fin tant que
Ecrire("gagné", P);
Simulation
Le nombre caché est 72
Min Max Proposition milieu
0 100 50 9.3.1 Utilisation

de la dichotomie
51 100 75
résolution de f(x)
51 74 62 =0
f est une fonction
63 74 68
définie sur l’intervalle
69 74 71 [a, b] et strictement
monotone sur [a; b].
72 74 73
On cherche à résoudre
72 72 72 numériquement
l’équation f(x) = 0.
gagné
On peut éliminer tout d’abord les cas où f(a)=0 ou f(b)=0. L’existence d’une racine sur
l’intervalle ]ᵄ, ᵄ [ est subordonnée au fait que f(a) et f(b) sont de signe contraires, ce qui
43équivaut à ƒ ( ᵄ ) × ƒ ( ᵄ ) < 0, et que f est continue sur [a,b].
Si P est un réel de ]ᵄ, ᵄ [, la position X0 par apport à P peut être testée par l’algorithme
suivant :
Si ᵅ (ᵄ) × ᵅ (ᵄ ) < 0 alors

Chercher X0 dans ]ᵄ , ᵄ ]
Sinon
Chercher X0 dans ]ᵄ , ᵄ ]
Pour trouver la solution le plus rapidement possible nous allons utiliser la méthode de
dichotomie. On prendra pour P le milieu de [a, b].
On itérera le processus jusqu’à obtenir par exemple ƒ ( ᵄ ) < s avec s → 0
Var X , N, P, Min, Max : réel

Lire(Min) Lire
(Max)
Si (f(Max)*f(Min)>0) Alors
Ecrire("pas de solution")
Sinon
P=(Max+Min)/2;
Ecrire(P)
tant que (abs(f(P)) > 0.001) faire
si (f(Min) * f(P)<=0) Alors
Max  P
sinon
Min  P
Fin Si
P=(Max+Min)/2;
Fin tant que
Ecrire(« la solution est:", P);
Fin Si
Fin
9.3.2 Utilisation de la dichotomie pour chercher le Maximum

Cette méthode pour trouver le maximum est déjà exposée dans le paragraphe 7-6-1-4.
Complexité Algorithmique
44
Différents algorithmes, donnant le même résultat, ont des couts différents en termes de temps
d'exécution (nombre d'opérations effectuées par l'algorithme) et taille mémoire (taille
nécessaire pour stocker les différentes structures de données pour l'exécution). Le but d’un
algorithme est de proposer une solution à un problème posé, en minimisant le temps de
traitement et la taille de mémoire consommée. Ces deux concepts sont appelés la complexité
en temps et en espace de l'algorithme.
La complexité algorithmique permet donc de mesurer les performances d'un algorithme et de

le comparer avec d'autres algorithmes réalisant les mêmes fonctionnalités. C’est un concept
fondamental pour tout programmeur, elle permet de déterminer si un algorithme a et meilleur
qu’un algorithme b et s’il est optimal ou bien il ne doit pas être utilisé.
Le temps d'exécution d'un programme dépend directement des nombres de calculs et de

données. Plus la complexité est faible, moins l’algorithme effectue de calculs, et plus il est
performent. Les boucles sont la principale cause du nombre important de calculs. Si elles sont
indispensables à la programmation, leur utilisation mal contrôlée engendre un nombre
croissant de traitement.
1. L’analyse de la complexité :
Il existe plusieurs méthodes pour analyser la performance d’un algorithme. Par exemple on
peut citer l’analyse moyenne et l’analyse pessimiste. L’analyse pessimiste est la plus
courante. Elle informe sur le nombre de calculs à prendre en compte dans le pire des cas.
Contrairement à l’analyse moyenne, qui informe sur le temps moyen des calculs.
Dans un algorithme de recherche d’une donnée parmi N données initiales on doit parcourir,
dans le pire des cas, toutes les données. L’analyse pessimiste indique que la recherche
effectue N comparaison. Dans ce cas la complexité est dite linéaire et elle notée O(N). la
notation O formalise que l’analyse de performance porte sur la limite supérieure.
L’intérêt principal de cette analyse pessimiste est d’évaluer les algorithmes dans leur
fonctionnement extrême. Le pire des cas est connu à l’avance.
2. Règles générales
Les règles générales utilisées pour calculer la complexité algorithmique sont :
1. le temps d'exécution TE d'une affectation, d’une incrémentation, d’une opération

élémentaire ou d'un test est considéré comme constant c.
2. Le temps d'une séquence d'instructions est la somme des TE des instructions qui la
composent.
3. le temps d'un branchement conditionnel est égal au TE du test plus le max des deux TE
correspondant aux deux alternatives (dans le cas d'un temps max).
45
4. Le temps d'une boucle est égal au coût du test de sortie de boucle plus le corps de la
boucle.
Exemple-1 Algorithme de permutation
Var T : Entier
Début
T a
ab
bT
fin
Soit t1 le temps d’exécution constant de l’affectation

Le temps d’exécution de cette algo pour n données T(n) est :
T(n) = t1+t1+t1 = 3t1
La complexité de cette algo est constante, elle est en O(1)
Exemple-2: Algorithme de calcul d'une somme
début
R <-- 0
i <-- 1
TantQue i < = n Faire
R <-- R+T[i]
i <-- i+1
FinTantQue
Fin
On pose les temps d’exécution suivants:

t1 : affectation
t2 : test
t3 : somme
t4 : incrémentation
Soit T(n) le temps d’exécution de cette algo pour n données :
Puisque t1, t2, t3 et t4 sont des constantes qui ne dépendent pas du nombre de données n
46
L’algorithme est donc asymptotiquement linéaire en n. Cet algorithme à une complexité O(n).
Exemple-3: Calcul d'une somme avec un test logique
R <-- 0
i <-- 1
TantQue i < = N Faire
R <-- R+T[i]
Si R>1000 Alors
R<-- 2*R
FinSi
i <-- i+1
FinTantQue
Soient les constants temps suivants :
t1 : affectation
t2 : test
t3 : somme
t4 : incrémentation
t5: multiplication
Le temps d’exécution est :
Cet algorithme à une complexité O(n).
Exemple-4 : calcul du factorielle (fonction récursive)
Fonction factorielle(n :naturel) : naturel

Début
Si n  0 alors
res  1
Sinon
res  n*factorielle(n-1)
Finsi
Renvoyer (res)
Fin
47
Soient les constants temps :
t1: test
t2: multiplication
Dans le cas d’un traitement récursif les deux branchements vont être exécutés
T(n) = t1 + t2 + T(n-1)
T(n) = (n+1)*t1 + n*t2 = (t1+t2)*n + t1
La complexité est linéaire O(n)
Exemple-5 (Algo avec deux boucles imbriquées).
B<--0
i <--1
Pour i <-- 1 à n Faire
B<--B+2
Pour j <-- 1 à n Faire
T[i,j] <-- (1+T[i,j])*B
Suivant j
Suivant i
Soient :
t1: affectation
t2: somme
t3: test
t4: multiplication
t5: incrémentation
48
Cette algorithme à une complexité en puissance O(n2).
3. Calcul de la complexité des algorithmes usuels

Les algorithmes usuels peuvent être classés en un certain nombre de grandes classes de
complexité.
 Les algorithmes logarithmiques ou sous-linéaires, dont la complexité est en général en

O(logn). sont considérés comme les plus rapides. C'est le cas de la recherche d'un
élément dans un ensemble ordonné fini de cardinal n.
 Les algorithmes linéaires en complexité O(n) ou en O(nlogn) sont considérés comme
rapides, comme l'évaluation de la valeur d'une expression composée de n symboles ou
les algorithmes optimaux de tri.
 Plus lents sont les algorithmes de complexité située entre O(n2) et O(n3), c'est le cas de
la multiplication des matrices et du parcours dans les graphes.
 Au-delà, les algorithmes polynomiaux en O(nk) pour k > 3 sont considérés comme
lents, sans parler des algorithmes exponentiels (dont la complexité est supérieure à
tout polynôme en n) que l'on s'accorde à dire impraticables dès que la taille des
données est supérieure à quelques dizaines d'unités.
Exemple : Algorithmes de recherche
Recherche linéaire :
Fonction Recherche (T(), X , Nb)

Var i, R : entier
i0
Tant que (i<=Nb-1 ET T(i) <> X) Alors
i  i+1
Fin tant que
Si (i = Nb) alors
Sinon
Renvoyer (i)
Le Pire des cas est celui où l’élément cherché est absent du tableau. On va effectuer n tests:
49
T(n)=n*C
La complexité est donc linéaire : O(n).
Le temps d’exécution est proportionnel aux nombres de données. Il existe un algorithme plus
efficace
Recherche dichotomique :
Fonction Recherchedico(T() : entier, Nb : entier, X : entier): entier

Var m : entier
Min  0;
Max  Nb-1;
m  (Max+Min)/2;
Tant que (T(m) < > X) faire
Si (T(m) > X) Alors
Max = m-1
Sinon
Si (T(m) < X) Alors
Min = m+1
Fin Si
P= (Max+Min)/2;
Fin tant que
Renvoyer (m);
Le temps d’exécution est :
Pour résoudre cette récursivité on pose :
N=2k
Donc
La complexité est donc logarithmique : O(log(n))

50
Dans le tableau ci-dessous on expose l’ordre de grandeur du temps nécessaire à l'exécution
d'un algorithme d'un type de complexité

Algorithme Final

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithme Final

Transféré par

Droits d'auteur :

Formats disponibles

Introduction à

1 Qu’est – ce qu’un algorithme ?

Un algorithme, c’est une suite d’instructions, qui une fois exécutée

un algorithme est un ensemble de règles logiques et chronologiques

Exemple 2. Calcul de la TVA

Exemple-3 : Recherche d’un mot dans un dictionnaire.

Méthode 1 : Recherche séquentielle

Méthode 2 : Autre méthode de Recherche

2 Comment formaliser un algorithme ?

o Il permet tout simplement d’identifier un algorithme parmi d’autres.

o C’est une liste exhaustive de variables utilisées et manipulées dans le corps de

o Dans cette partie de l’algorithme, sont placées les tâches à exécuter

o Pour permettre une lecture plus aisée et plus compréhensive de l’algorithme

3 Les variables et les constantes :

 L’identificateur : Il représente le nom de la variable, de la constante ou de la

 Il ne doit pas commencer par des chiffres

 Il ne doit pas contenir d’espaces, de caractères de ponctuation ou de

 Le type : Il représente la nature de la variable ou de la constante (entier, réel, booléen,

En pseudo-code la déclaration se fait de la manière suivante :

Var <nom variable> : type de la variable

 var age : réel

3.1 Les types des variables

Exemple d’informations de base :

Les nombres réels : La chaîne de caractères

-3.67, 4.2569, –564.0, 18.36 10e-6 "électronique", "cd ROM de 80mn" , …

Type de donnée Signification Taille (en octets) Plage de valeurs

unsigned char Caractère non 1 0 à 255

unsigned short Entier court non 2 0 à 65 535

double Flottant double 8 1.7*10-308 à 1.7*10308

long double Flottant double 10 3.4*10-4932 à

Les différents opérateurs utilisés dans les algorithmes sont :

Opérateur Algo Opérateur Algo

Division / Inférieur ou égal ≤

Priorité croissante de bas vers le haut

3.2 L’opérateur Affectation

Après exécution de cet algorithme on aura A=2, B=3, C=4

1. Les structures de contrôles Alternatives

1. La structure alternative réduite SI ... ALORS….FIN SI:

4.1.2 La structure alternative complète SI ... ALORS…SINON….FIN SI :

4.1.3 Structure Alternative multiple : cas des conditions disjointes

13Si <condition1> Alors

4. Structure alternative : (Cas des conditions non disjointes)

14Si C1 AND C2 AND C3 AND ……AND Cn Alors

4.1.4.2 Contrôle de plusieurs traitements

L’algorithme en pseudo code est donnée par :

Exemple : on veut écrire un algorithme qui permet de résoudre l’équation : ax2 + bx + c = 0 et

Si (a=0) AND (b=0) AND (c=0) alors la solution est IR

L’algorithme est donnée par :

1. Cas où le nombre de répétition est connu (Pour….allant….suivant):

Pour i Vi à Vf [pas p]

i=0 var=2 S=0+2 2

17i=1 var=-3 S=2-3 -1

i=2 Var=4 S=-1+4 3

i=3 Var=-8 S=3-8 -5

i=4 Arrêt des itérations

Cas des boucles imbriquées

Pour i allant de Vi à Vf [pas p]

2. Cas où le nombre de répétition est inconnu

Cette structure est utilisée dans un algorithme de la manière suivante :

Dans cette structure la vérification de la condition se fait avant l’exécution du bloc

Une simulation de cet algorithme est donné par :

var=2 i=1 S=0+2 2

var=-3 i=2 S=2-3 -1

Var=4 i=3 S=-1+4 3

double Flottant double 8 1.710-308 à 1.710308