Introduction à l’algorithmique

Introduction
• Algorithme: Procédure décrivant, étape par
étape, une méthode permettant de résoudre
un problème.
• Mot provenant du nom d’un mathématicien
arabe du IXeme siècle El-Khawarizmi
• C’est la base de tout programme informatique

Exemple: Recette de la sauce blanche:

1. Faire revenir l’oignon haché fin dans du beurre,

2. Ajouter la farine, bien mélanger;
3. Rajouter le lait chaud, et mélanger pour éviter les grumeaux;
4. Laisser mijoter 15 minutes
Algorithme: Suite finie d’instructions vérifiant:

• Chaque étape est décrite de façon précise;

• Chaque étape est déterministe: produit des
résultats uniques;
• L’algorithme s’arrête après un nb fini
d’instructions
• Reçoit des données en entrée;
• Produit des données en sortie;
• Généralité: Applicable à des ensembles
différents de données d’entrée
 Différence entre problème et
instance du problème
• Exemple d’un problème: Tri d’un
ensemble d’éléments
– Entrée: Suite de n éléts a1,…an
– Sortie: La suite réordonnée

• Instances du problème:
– Suite de nombres: 475, 787, 34, 245, 56, 350
– Suite de noms: Pierre, Christine, Sylvie,
Samuel, Fabien
 Exemple d’un algorithme
1. x := a;
2. Si b>x, alors x := b;
3. Si c>x, alors x := c;

:= Opérateur d’assignation
y := z signifie ``copie la valeur de z dans y’’.
Valeur de z inchangée

Paramètres d’entrée: a, b, c
Valeur de sortie: x = max (a,b,c)
 Pseudo-Code
Algorithme maximum: Retourne le
maximum de 3 entiers
• Entrée: Trois entiers a, b, c; Trace de l’algorithme pour:
• Sortie: x contenant la valeur maximale
parmi a, b, c a=1; b=5; c=3

x=1
1. Procédure max(a,b,c) x=5
2. x := a;
3. Si b>x alors // Si b plus grand que x, mettre x à jour
4. x := b;
5. Si c>x alors // Si c plus grand que x, mettre x à jour
6. x := c;
7. Retourner (x)
8. Fin max
Pseudo-Code: Notation proche du code des langages de
programmation (C, Pascal). Notation standard mais pas
rigoureuse

• Titre de l’algorithme, description brève, entrées, sorties

• Procédures consécutives
• Numéroter les lignes (facultatif)
• Procédure commence par le mot ``Procédure’’, suivit du
nom, suivit des paramètres
• Instructions (lignes exécutables) entre ``Procédure’’ et
``Fin’’, exécutées l’une après l’autre
• Bloc d’instructions entre ``Début’’ et ``Fin’’
• Ligne de commentaires signalée par // (ou /* */)
• ``Retourne (x)’’ termine une procédure et retourne la
valeur de x
 Instruction Si-Alors-Sinon
(If-Then-Else)
Si p alors Si condition p vérifiée, exécuter action.
action

Si p alors
Si condition p vérifiée, exécuter action 1. Sinon,
action 1;
exécuter action 2.
Sinon
action 2;

Si x ≥ 0 alors Bloc de conditions entre Début et Fin.

Début
x := x-1;
a := b+c;
Fin
 Instruction Tant que
Tant que p Faire Tant que p est vrai exécuter action
action;
Algorithme Plus-Grand-Element: Retourne la plus grande Trace de l’algorithme:
valeur d’une liste
Entrée: n entiers S1,…, Sn n=4; S1= -2; S2=6; S3=5; S4=6
Sortie: grand contenant le plus grand élément
grand =-2 i=2
Procédure plus-grand (S,n)
grand := S1; grand = 6 i=3
i:=2;
i=4
Tant que i ≤ n Faire
Début i=5
Si Si > grand alors // une plus grande valeur a été trouvée
grand := Si;
i := i+1;
Fin
Retourne (grand)
Fin plus-grand;
 Instruction Pour (For)
Pour var := init à limite Faire À chaque passage dans la boucle, var est
incrémenté de 1. On s’arrête dès que
action;
var > limite

Algorithme Plus-Grand-Element: Réécriture de l’algorithme précédent mais

avec une boucle ``Pour’’
Entrée: n entiers S1,…, Sn
Sortie: grand contenant le plus grand élément

Procédure plus-grand (S,n)

grand := S1;
Pour i =1 à n Faire
Si Si > grand alors // une plus grande valeur a été trouvée
grand := Si;
Retourne (grand)
Fin plus-grand;
 Subdivision d’un problème en sous-
problèmes (plusieurs procédures)

• Problème: Trouver le plus petit nombre

premier strictement supérieur à un entier
positif donné
– Procédure pour déterminer si un entier m est
un nombre premier. Il suffit de tester si m est
divisible par un entier entre 2 et m/2
– Utiliser cette procédure pour trouver le plus
petit nombre premier p supérieur à un entier
n.
 Entrée: Un entier positif m Entrée: Un entier positif n
Sortie: Vrai si m est premier, Faux si non. Sortie: Le plus petit nb premier m > n
Procédure est-premier (m) Procédure premier-plus-grand (n)
Pour i := 2 à ENT(m/2) Faire m := n+1;
Si m mod i = 0 alors // i divise m Tant que est-premier(m) est Faux Faire
Retourne (Faux) m := m+1;
Retourne (Vrai) Retourne(m)
Fin est-premier Fin est-premier

Trace de premier-plus-grand pour Trace

Trace
dede
est-premier
est-premier
pour
pour
m=9:
m=11:
m=10:
n=8:
i=2 11
9
10mod
mod
mod222===110
m=9 i=3 9 mod 3 = 0
i=5 11 mod 5 = 1
m = 10
m = 11
 Algorithme d’Euclide
• Trouver le plus grand diviseur commun (pgcd) de deux
entiers

Définition: q est un diviseur commun de m et n si q divise à

la fois m et n (le reste de la division entière est 0)
Le pgdc de m et n est le plus grand entier q divisant à la
fois m et n.

Exemple: pgcd(4, 6) = 2; pgcd(3,8) = 1;

pgcd(9, 12) = 3;

Utile pour la simplification de fractions:

9/12 = 3.3/4.3 = 3/4
Théorème 1: Soient m, n et c trois entiers
1. Si c est un diviseur commun de m et n, alors c divise (m+n).
2. Si c est un diviseur commun de m et n, alors c divise (m-n).
3. Si c divise m, alors c divise mn

Soient a, b deux entiers >0. Si on divise a par b, on obtient

un reste r et un quotient q vérifiants:
a = bq+r, avec 0≤r<b, et q≥0

À l’aide du théorème 1 on montre:

Théorème 2: Soient a, b deux entiers positifs. Soient q le
quotient et r le reste de la division entière de a par b.

Alors pgcd(a,b) = pgcd(b,r)

 Trouver le PGCD de a et b
Exemple: pgcd(30, 105)
• 1ère méthode: Trouver tous les diviseurs de a et b, et
trouver le diviseur commun le plus grand
– Diviseurs de 30: 1, 2, 3, 5, 6, 10, 15, 30
– Diviseurs de 105: 1, 3, 5, 7, 15, 21, 35, 105
 pgcd(30, 105) = 15

• 2ème méthode: Utiliser le théorème 2

– 105 = 30.3 + 15. Donc pgcd(105, 30) = pgcd(30,15)
– 30 = 15.2 + 0. Donc pgcd(30, 15) = pgcd(15,0)
– pgcd(15,0)=15
 pgcd(105,30)=pgcd(30,15)=pgcd(15,0)=15

La méthode 2 est la méthode d’Euclide

 Méthode d’Euclide
Soient r0, r1 deux entiers strictement
positifs, tels que r0=r1.q+r2 avec 0≤r2<r1

• Si r2 = 0, pgcd (r0, r1) = r1

• Sinon, rediviser ri par ri+1 tant que ri+1 est
différent de 0
• Si rn est le premier reste nul, alors
pgcd(r0,r1) = pgcd(r1,r2) = … =pgcd(rn-1,rn)= pgcd(rn-1,0) = rn-1
 Algorithme d’Euclide
Entrée: a, b deux entiers positifs Trace de l’algorithme pour
a=504 et b=396
Sortie: pgcd(a,b)
504 396 a
108 1
Procédure pgcd(a,b)
Tant que b pas 0 Faire
b 396 108 a
Début
72 3
diviser a par b: a = b.q+r, 0 ≤ r < b;
a:=b; b 108 72 a
b:=r; 36 1
Fin
72 36 a
Retourner (a) b 0 2
Fin pgcd
b
 Procédure récursive
• Procédure qui s’invoque elle-même
Exemple: n! = n(n-1)(n-2)…2.1 Si n≥0
0! = 1
n! = n(n-1)! pour n≥1
5! = 5.4! 4! = 4.3! 3! = 3.2! 2! = 2.1! 1! = 1.0!

= 120 = 24 =6 =2 =1

• Toute procédure récursive doit avoir une condition

d’arrêt: cas de base qui permet de ne plus invoquer
la procédure.
Ici, la condition d’arrêt est n=0
Entrée: Entier n≥0
Sortie: n!
Procédure factoriel (n)
Si n = 0 alors
Retourne (1) factoriel( 0 ):
Retourne (n. factoriel(n-1))
Retourne: 1
Fin factoriel

Trace pour n =3:

factoriel( 3 ): factoriel( 1 ):
factoriel( 2 ):
Retourne: 3. factoriel(2) Retourne: 1. factoriel(0)

Retourne: 2. factoriel(1)
1.1=1
3.2=6
2.1=2
 Procédure itérative pour le calcul de n!
Entrée: Entier n≥0 Trace pour n =3 :
Sortie: n!
res = 1 courant = 3
Procédure factoriel-iteratif (n)
res = 1; courant = n; res = 3 courant = 2
Tant que courant>0 Faire
res = 6 courant = 1
res := res * courant;
courant := courant-1; res = 6 courant = 0
Fin Tant que
Retourne (res)
Fin factoriel-iteratif
 Procédure récursive pour le calcul du pgcd
Entrée: a, b deux entiers >0
Sortie: pgcd(a,b) pgcd-rec(108, 72)
Procédure pgcd-rec (a,b) 108 = 72 . 1 + 36
Si b = 0 alors pgcd-rec(72,36)
Retourner (a);
36 pgcd-rec(72,36)
diviser a par b: a = b.q+r, 0 ≤ r < b;
pgcd-rec(36, 0)
Retourner (pgcd-rec (b,r))
Fin pgcd-rec 36
Trace pour a=504 et b=396: pgcd-rec(396, 108)
pgcd-rec(36, 0)
pgcd-rec(504, 396) 396 = 108 . 3 + 72
pgcd-rec(108,72) 36
504 = 396. 1 + 108
pgcd-rec(396, 108) 36
36
 Nombres de Fibonacci
Exemple: Un robot peu avancer par des pas de 1 ou 2
mètres.

Calculer le nombre de façons différentes de parcourir

une distance de n mètres

Distance Suite de pas Nb de

possibilités

1 1 1
2 1,1 ou 2 2
3 1, 1, 1 ou 1, 2 ou 2, 1 3
4 1,1,1,1 ou 1,1,2 ou 1,2,1 ou 2,1,1 ou 2,2 5
• Pas(n): Nombre de Entrée: n

possibilités pour parcourir n Sortie: Pas(n)

mètres.
• Pas(1) = 1, Pas(2) = 2; Procédure pas-robot (n)

• Pour n>2: Si n=1 ou n=2 alors

– Si premier pas = 1 mètres, Retourne (n)

il reste n-1 mètres -> Pas(n-1) Retourne (Pas(n-1) +

– Si premier pas = 2 mètres, Pas(n-2) )
il reste n-2 mètres -> Pas(n-2) Fin pas-robot

Donc, Pas(n) =
Séquence de Fibonacci:
Pas(n-1)+Pas(n-2)
f1 = 1
f2 = 2
fn = fn-1 + fn-2 pour n>2