Cours Complet Algorithmique II

ALGORITHMIQUE II
Hajar LAZAR
Département d’Informatique
Faculté des Science de
Semlalia –Marrakech-
1
PLAN DUCOURS
2
 RAPPELS : NOTATIONSALGORITHMIQUES
 TABLEAUX A PLUSIEURS DIMENSION
 FONCTIONS ET PROCEDURES
 RECURSIVITE
 ALGORITHMES ITERATIFS DE TRIS
 COMPLEXITE ET PREUVE D’ALGORITHMES
 STRUCTURES /ENREGISTREMENTS
 FICHIERS
Notations algorithmiques
3
Algorithme
Un algorithme, traduit dans un langage compréhensible par l’ordinateur
(ou langage de programmation, C par ex), donne un programme, qui peut
ensuite être exécuté, pour effectuer le traitement souhaité.
2
4
Structure d’un algorithme

Un algorithme doit être lisible et compréhensible par plusieurs personnes.
Algorithme : Nom d’Algorithme
Données : Les entrées de l’algorithme

Résultats : Les sorties de l’algorithme
Déclarations : Variables, constantes…
Début
Ensemble d’instructions ;
Fin
 Une variable possède :

- un nom
- une valeur
- un type
(la valeur d’une variable peut changer au cours de
l’exécution)
Déclaration : <variable> : <type>
Exemple
Variable A, B : entier
d : réel
❑ Une expression, pour untype, est soit une constante, soit une
variable, soit constituée à l’aide de constantes, de variables,
de parenthèses et des opérateurs
 Un type est un ensemble de valeurs sur lesquelles on définit

des opérations.
• Types de base :
✓ Entier : Opérateurs arithmétiques +, -, *, div, mod
✓Réel : Opérateurs arithmétiques +, -, *, /
✓Booléen : Opérateurs logiques et, ou, non
✓Caractère : constante (lettre imprimable) entre
apostrophe.
- Les opérateurs relationnels permettant de faire des
comparaisons: <, , =, >, , 
Le Résultat de la comparaison est une valeur booléenne.
Entrée\Sortie
▪Un algorithme peut avoir des interactions avec l’utilisateur

et communiquer avec lui dans les deux sens, les sorties
sont des envois de messages a l'utilisateur, les entrées sont
des informations fournies par l'utilisateur.
▪Il peut demander à l’utilisateur de saisir une information afin

de la stocker dans une variable et peut afficher un résultat
(du texte ou le contenu d’une variable)
Instruction d'écriture (Sortie)

Elle permet la restitution de résultats sur le périphérique de sortie (en
général l'écran)
Syntaxe : écrire(liste d'expressions)
▪Cette instruction réalise simplement l'affichage des valeurs des

expressions décrites dans la liste.
▪Ces instructions peuvent être simplement des variables ayant des
valeurs ou même des nombres ou des commentaires écrits sous forme de
chaînes de caractères.
Exemple :
écrire(x, y+2, "bonjour")
Instruction lecture (Entrée)

L'instruction de prise de données sur le périphérique d'entrée (en général
le clavier)
Syntaxe : lire(liste de variables)
▪L'exécution de cette instruction consiste à affecter une valeur à la

variable en prenant cette valeur sur le périphérique d'entrée
Exemple :
Lire(x, y, A)
10
Exemple
Cet algorithme demande a l'utilisateur de saisir une valeur numérique, ensuite il
affiche la valeur saisie, puis la même valeur incrémentée de 1.
Algorithme : Affichage incrément

▪
variables :
a, b : entier
DEBUT
écrire("Saisissez une valeur numérique") lire(a)
b a+1
écrire("Vous avez saisi la valeur ", a, ". ") écrire(a,
"+ 1 = ", b)
FIN
11
La structure Si
L’instruction si alors sinon permet de conditionner l’exécution d’un
algorithme à la valeur d’une expression booléenne.
Syntaxe :
si <expression booléenne> alors
▪ <suite d’instructions exécutées si l’expression est vrai>
sinon
<suite d’instructions exécutées si l’expression est fausse>
finsi
La deuxième partie de l’instruction est optionnelle, on peut avoir :

si <expression booléenne> alors
<suite d’instructions exécutées si l’expression est vrai>
finsi
12
Structure Si
Exemple
Algorithme : Valeur Absolue
Données : La valeur à calculer
Résultat : La valeur Absolue
▪
début
si valeur ≥ 0 alors
valeurabsolue ← valeur
sinon
valeurabsolue ← valeur * -1
finsi
fin
13
Structure de choix multiple

Lorsque l’on doit comparer une même variable avec plusieurs valeurs, comme par
exemple :
si abréviation = "M" alors
écrire( "Monsieur" )
Sinon
▪
si abréviation = "Mme" alors

écrire("Madame")
sinon
si abréviation = "Mlle" alors
écrire( "Mademoiselle" )
sinon
écrire( "Monsieur, Madame " )
fsi
fsi
fsi
On peut remplacer cette suite de si par l’instruction Selon
14

Syntaxe
selon <identificateur : V> faire
V1 : instructions 1
V2 : instructions 2
▪ …
Vn : instructions n
[autres: instructions]
finSelon
▪ V1,. . . ,Vn sont des constantes de type scalaire (entier, réel, caractère
…)
▪ instructions i est exécutée si V = Vi (on quitte ensuite le selon)
▪ instruction autre est exécutée si quelque soit i, V ≠ Vi
15

Exemple
selon abréviation faire

"M" : écrire( " Monsieur " )
"Mme" : écrire( " Madame " )
▪
"Mlle" : écrire( " Mademoiselle " )
autres: écrire( " Monsieur, Madame " )
finSelon
16
Structure itératives
▪Un algorithme peut répéter le même traitement plusieurs fois, avec éventuellement
quelques variantes.
▪Dans certain cas, Il est impossible de savoir à l'avance combien de fois

▪
la même instruction doit être décrite.
▪Utilisation des instructions en boucle qui répètent plusieurs fois une même
instruction.
▪Deux formes existent : la première, si le nombre de répétitions est connu avant

l'exécution de l'instruction de répétition ( Pour ), la seconde s'il n'est pas connu (
Tant que et répéter… jusqu’à). L'exécution de la liste des instructions se nomme
itération.
17
Répétition inconditionnelle
▪Il est fréquent que le nombre de répétitions soit connu à l'avance, et que l'on ait besoin
d'utiliser le numéro de l'itération afin d'effectuer des calculs ou des tests.
Syntaxe de Pour :
pour <variable> := <initiale> à <final> faire
action
Fpour
▪La variable prend successivement toutes les valeurs entières entre valeur initiale et
valeur finale. Pour chaque valeur, la liste des instructions est exécutée.
▪Où initiale et finale sont des expressions de même type que celui de la variable
contrôlant la boucle, le type peut être entier, caractère ou énuméré)
18
• La valeur utilisée pour énumérer les itérations est appelée valeur

d'itération, indice d'itération ou compteur. L'incrémentation par 1
de la variable est implicite.
Remarque: la boucle pour affecte la valeur de initiale à variable et compare

cette valeur à celle de finale avant d’exécuter action.
19
 Exemple: calcul de 1+2+…+n (n entier 1 fixé)
Programme somme_des_n_premiersTermes
/ / partie déclaration
n : entier; s : entier; i : entier; (ou n, i, s : entier)
Début
/ / Lecture des données
Écrire (" n = " ); lire(n);
/ / calcul de la somme s := 0;
pour i := 1 à n faire
s := s + i;
fpour;
/ / affichage du résultat écrire("1+ 2 + … + n = ", s);
fin
20
Répétition conditionnelle
▪Dans beaucoup de cas, on souhaite répéter une instruction tant qu'une certaine
condition est remplie, alors qu'il est à priori impossible de savoir à l'avance au bout
de combien d'itérations cette condition cessera d'être satisfaite.
▪Dans ce cas, on a deux possibilités :

▪ la boucle Tant que
▪ la boucle Répéter jusqu'à
21
Boucle Tant que

Syntaxe :
tant que condition faire
liste d'instructions FinTantQue
▪Cette instruction a une condition de poursuite dont la valeur est de type booléen et
une liste d'instructions qui est répétée si la valeur de la condition de poursuite est vraie :
la liste d'instructions est répétée autant de fois que la condition de poursuite a la valeur
est vraie.
▪Etant donné que la condition est évaluée avant l'exécution des instructions à répéter, il
est possible que celles-ci ne soient jamais exécutées.
▪Il faut que la liste des instructions ait une incidence sur la condition afin qu'elle puisse
être évaluée à faux et que la boucle se termine (Il faut toujours s'assurer que la condition
devient fausse au bout d'un temps fini.) 39
22
Boucle Tant que

Contrôle de saisie d'une lettre alphabétique jusqu’à ce que le caractère entré soit
valable
…
Variable C : caractère
Debut
Écrire (" Entrez une lettre majuscule ");
Lire (C);
TantQue ((C < 'A‘) ou (C > 'Z')) faire
Ecrire ("Saisie erronée. Recommencez");
Lire (C);
FinTantQue
Ecrire ("La saisie est valable ");

Fin
23
Boucle Répéter jusqu'à

Syntaxe :
Répéter
liste d'instructions
jusqu'à condition
La séquence d'instructions est exécutée au moins une fois et jusqu'à ce que

l'expression soit vraie. Dès que la condition est vrai, la répétitivité s'arrête.
24
Boucle Répéter jusqu'à

Exemple
Algorithme : saisirLargeurRectangle
Variable : largeur : entier
début
répéter
écrire ("indiquez la largeur du rectangle :") lire(largeur)
si largeur < 1 alors
écrire ("erreur : indiquez une valeur > 0")
finSi jusqu'à largeur >=1
fin
25
Les boucles Tant que et Répéter jusqu’à
• Différences entre les boucles TantQue et Répéter jusqu’à :
- La séquence d'instructions est exécutée au moins une fois dans la

boucle Répéter jusqu’à , alors qu'elle peut ne pas être exécutée dans
le cas du Tant que.
- Dans les deux cas, la séquence d'instructions est exécutée si la

condition est vraie.
- Dans les deux cas, la séquence d'instructions doit nécessairement faire

évoluer la condition, faute de quoi on obtient une boucle infinie.
26
Structure itératives
Conclusion
Exemples
27
• Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui

calcule et affiche le carré de ce nombre.
• Écrire un algorithme qui permet d’effectuer la saisie d’un nom, d’un prénom et
affiche ensuite le nom complet
• Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui

teste et affiche s'il est divisible par 7 ou non
• Le prix de disques compacts (CDs) dans espace de vente varie selon le nombre à
acheter: 5 DH l’unité si le nombre de CDs à acheter est inférieur à 10, 4 DH l’unité
si le nombre de CDS à acheter est compris entre 10 et 20 et 3 DH l’unité si le
nombre de CDs à acheter est au-delà de 20.
Écrivez un algorithme qui demande à l’utilisateur le nombre de CDs à acheter, qui

calcule et affiche le prix à payer
• Calcul de x à la puissance n où x est un réel non nul et n un entier positif ou

nul
Exemples
27
Exemple 1: lecture et écriture
Écrire un algorithme qui demande un nombre entier à

l'utilisateur, puis qui calcule et affiche le carré de ce
nombre.
Algorithme Calcul_du_Carre Rôle : calcul du carre

Données : un entier
Résultats : le carre du nombre
variables A, B : entier
Début
écrire("entrer la valeur de A ");
lire(A);
B ← A*A;
écrire("le carré de ", A, " est :", B);
Fin
Exemples
27
Exemple 2: lecture et écriture
Écrire un algorithme qui permet d’effectuer la saisie d’un nom,

d’un prénom et affiche ensuite le nom complet
Algorithme AffichageNomComplet
…
variables Nom, Prenom, Nom_Complet : chaîne de caractères
Début
écrire("entrez le nom");
lire(Nom);
écrire("entrez le prénom");
lire(Prenom);
Nom_Complet ← Nom & " " & Prenom;
écrire("Votre nom complet est : ", Nom_Complet);
Fin
7
Exemples
27
Exemple 3: tests
Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui teste
et affiche s'il est divisible par 7 ou non
Algorithme Divsible_par7
Variable n : entier
Début
Ecrire (" Entrez un entier : ");
Lire (n)
Si (n%7=0) alors
Ecrire (n," est divisible par 7");
Sinon
Ecrire (n," n'est pas divisible par 7");
Finsi
Fin
Exemples
27
Exemple 4: tests imbriqués
⚫ Leprix de disques compacts (CDs) Variables unites : entier

dans espace de vente varie selon le
nombre à acheter: prix : réel
5 DH l’unité si le nombre de CDs à Début
acheter est inférieur à 10,
Ecrire ("Nombre d’unités ");
4 DH l’unité si le nombre de CDS à
acheter est compris entre 10 et 20 Lire (unites);
et 3 DH l’unité si le nombre de CDs à Si unites < 10 Alors
acheter est au-delà de 20. prix ← unites*5;
Sinon Si unites < 20 alors prix ← unites*4;
⚫ Écrivez un algorithme qui demande Sinon prix ← unites*3;
à l’utilisateur le nombre de CDs à Finsi
acheter, qui calcule et affiche le prix à Finsi
payer
Ecrire (“Le prix à payer est : ”, prix);
Fin
Exemples
27
Exemple 5: boucle Pour

Calcul de x à la puissance n où x est un réel non nul et n un entier positif
ou nul
…
Variables x, puiss : réel
n, i : entier
Debut
Ecrire (" Entrez respectivement les valeurs de x et n "); Lire (x, n);
puiss ← 1;
Pour i 1 à n faire
puiss← puiss*x;
FinPour
Ecrire (x, " à la puissance ", n, " est égal à ", puiss);
Fin
18
TABLEAUX
28
⚫ Supposons que l'on veut calculer le nombre d’étudiants ayant une note
supérieure à 10 pour une classe de 20 étudiants.
⚫Jusqu’à présent, le seul moyen pour le faire, c’est de déclarer 20

variables désignant les notes N1, …, N20:
•La saisie de ces notes nécessite 20 instructions lire(Ni).

•Le calcul du nombre des notes>10 se fait par une suite de tests de 20
instructions Si :
nbre ← 0;
Si (N1 >10) alors nbre ←nbre+1
FinSi
…
Si (N20>10) alors nbre ←nbre+1
FinSi
cette façon n’est pas très pratique

TABLEAUX
29
⚫C’est pourquoi, les langages de programmation offrent la possibilité de

rassembler toutes ces variables dans une seule structure de donnée
appelée tableau qui est facile à manipuler.
⚫Un tableau est un ensemble d'éléments de même type désignés par un

identificateur unique;
⚫Une variable entière nommée indice permet d'indiquer la position d'un

élément donné au sein du tableau et de déterminer sa valeur.
TABLEAUX
30
⚫La déclaration d'un tableau s'effectue en précisant le type de ses

éléments et sa dimension (le nombre de ses éléments)
⚫Syntaxe :
Variable tableau identificateur [dimension] : <TypeTab>
⚫Exemple :
variable tableau notes[20] : réel
⚫On peut définir des tableaux de tous types : tableaux d'entiers, de

réels, de caractères, de booléens, de chaînes de caractères, …
TABLEAUX
31
Les tableaux à une dimension (vecteurs)
variable tableau tab[10] : entier
0 1 2 3 4 5 6 7 8 9
45 54 1 -56 22 134 49 12 90 -26
▪Ce tableau est de longueur 10. Chacun des dix nombres du tableau est repéré par
son rang, appelé indice
▪Pour accéder à un élément du tableau, il suffit de préciser entre crochets
l'indice de la case contenant cet élément.
▪Pour accéder au 5ème élément (22), on écrit : Tab[4]
▪Les instructions de lecture, écriture et affectation s'appliquent aux tableaux
comme aux variables.
x ← Tab[0] (x=45)
Tab[6] ← 43
TABLEAUX
32
⚫Pour accéder au ièm e élément, on écrit tab[i-1] (avec 0<=i<10)
⚫Selonles langages, le premier indice du tableau est soit 0, soit 1. Le plus

Souvent c'est 0 (c'est ce qu'on va utiliser en pseudo-code).
⚫Dans ce cas, tab[i] désigne l'élément i+1 du tableau tab.
⚫Ungrand avantage des tableaux est qu'on peut traiter les données qui y
sont stockées de façon simple en utilisant des boucles.
⚫Les éléments d’un tableau s’utilisent comme des variables.

TABLEAUX
33
Tableaux : accès et modification
⚫Lesinstructions de lecture, écriture et affectation s'appliquent aux tableaux

comme aux variables.
⚫Exemples :
x ← tab[0];
La variable x prend la valeur du premier élément du tableau (45 selon le
tableau précédent).
tab[6] ← 43;
Cette instruction a modifié le contenu du 7ème élément du tableau (43 au
lieu de 49).
TABLEAUX
34
Relation entre tableaux et boucles
⚫Les boucles sont extrêmement utiles pour les algorithmes associés aux
tableaux.
⚫Pourparcourir les éléments du tableau selon l’ordre croissant (ou
décroissant) des indices, on utilise des boucles.
⚫Le traitement de chacun des éléments étant souvent le même, seule la
valeur de l’indice est amenée à changer.
⚫Une boucle est donc parfaitement adaptée à ce genre de traitements.

TABLEAUX
35
Pour le calcul du nombre d'étudiants ayant une note supérieure à 12

avec les tableaux, on peut écrire :
Constante N=20 : entier

Variables i, nbre : entier
tableau notes[N] : réel
Début
nbre ← 0;
Pour i ← 0 à N-1 faire
Si (notes[i] >12) alors
nbre ←nbre+1;
FinSi
FinPour
écrire ("le nombre de notes supérieures à 12 est : ", nbre);

Fin
TABLEAUX
36
Tableaux : saisie et affichage

Constante Max=200 : entier
Variables i, n : entier
tableau Notes[max] : réel
ecrire("entrer la taille du tableau :") ;
lire(n);
Debut
/* saisie */
Pour i  0 à n-1 [par 1] faire
écrire ("Saisie de l'élément ", i + 1);
lire (T[i] );
FinPour
/* affichage */
Pour i  0 à n-1 [par 1] faire
écrire ("T[",i, "] =", T[i]);
FinPour
Fin
TABLEAUX
37
Tableaux : Exercice
• Ecrire un programme qui déclare un tableau de 100 entiers

et qui l’initialise par les nombres entiers de 1 à 100.
• Ecrire un programme qui permet de saisir 20 nombres réels

en simple précision et les stocker dans un tableau
TABLEAUX
31
Tableaux : Exercice
Algorithme : tableau test

Variable tableau a [100], i: entiers
début
pour i <- 0 à 99 [par 1] faire
a[i]<- i+1
Fin Pour
Fin
TABLEAUX
31
Tableaux : Exercice corrigé

Algorithme : saisie_tab
Variable tableau a [20]: réels en simple précision
i : entier
début
pour i <- 0 à 19 [par 1] faire
écrire ("Saisie de l'élément ", i + 1);
lire(a[i])
Fin Pour
Fin
TABLEAUX
31
Tableaux à deux dimensions
⚫Les langages de programmation permettent de déclarer des tableaux

dans lesquels les valeurs sont repérées par deux indices.
⚫Ceci est utile par exemple pour représenter des matrices.

⚫En pseudo-code, un tableau à deux dimensions se déclare ainsi :
variable tableau identificateur[dim1] [dim2] : type

⚫Exemple :
⚫une matrice A de 3 lignes et 4 colonnes dont les éléments sont réels :
variable tableau A[3][4] : réel
⚫A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à

l’intersection de la ligne i+1 et de la colonne j+1
⚫Les tableaux peuvent avoir n dimensions.

TABLEAUX
32
⚫ La matrice A dans la déclaration suivante :

variable tableau A[3][5] : réel
peut être explicitée comme suit : les éléments sont rangées dans un tableau
à deux entrées.
0 1 2 3 4
0 12 28 44 2 76
1 23 36 51 11 38
2 43 21 55 67 83
▪Ce tableau a 3 lignes et 5 colonnes. Les éléments du tableau sont

repérés par leur numéro de ligne et leur numéro de colonne.
▪. Par exemple A[1][4] vaut 38

TABLEAUX
33
Exemples : lecture d'une matrice
⚫La saisie des éléments d'une matrice :
Constante N=100 :entier

Variable i, j, m, n : entier
tableau A[N][N] : réel
Début
ecrire("entrer le nombre de lignes et le nombre de colonnes :") ;
lire(m, n);
Pour i  0 à m-1 [par 1] faire
écrire ("saisie de la ligne ", i + 1);
Pour j  0 à n-1 [par 1] faire
écrire ("Entrez l'élément : ligne ", i+1, " et colonne ", j+1);
lire (A[i][j]);
FinPour
FinPour
Fin
TABLEAUX
33
⚫Affichages des éléments d'une matrice :
Constante N=100 : entier

Variable i, j, m, n : entier
tableau A[N][N]: réel
Début
ecrire("entrer le nombre de lignes et le nombre de colonnes :") ;
lire(m, n);
Pour i  0 à m-1 [par 1] faire
Pour j  0 à n-1 [par 1] faire
écrire ("A[",i, "] [",j,"]=", A[i][j]);
FinPour
FinPour
Fin
TABLEAUX
33
Initialisation de matrice
⚫Pour initialiser une matrice on peut utiliser par exemple les instructions
suivantes :
T1[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};

T2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
T3[4][4] = {{1,2,3}, {4,5,6}, {7,8,9}};
T4[4][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
TABLEAUX
34
Traitements opérant sur des tableaux
▪Créer des tableaux

▪Ranger des valeurs dans un tableau
▪Récupérer, consulter des valeurs rangées dans un tableau
▪Rechercher si une valeur est dans un tableau
▪Mettre à jour des valeurs dans un tableau
▪Modifier la façon dont les valeurs sont rangées dans un tableau (par exemple : les
trier de différentes manières)
▪Effectuer des opérations entre tableaux : comparaison de tableaux,
multiplication,...
TABLEAUX
34
Exercices:
1. Ecrire un algorithme qui déclare et remplisse un tableau de 7

valeurs entiers en les mettant toutes à zéro.
2. Ecrire un algorithme qui déclare et remplisse un tableau contenant

les six voyelles de l’alphabet
3. Ecrire un algorithme permettant, à l’utilisateur de saisir les notes

d'une classe. Le programme, une fois la saisie terminée, renvoie le
nombre de ces notes supérieures à la moyenne de la classe.
TABLEAUX
34
Corrigés:
1.
Variable i , Tableau tab[6] : entiers
Debut
Pour i ← 0 à 6 faire
tab[i] ← 0
i Suivant
Finpour
Fin
2.
Variable Tableau tab[6] : caractère
Debut
Tab[0] ← "a"
Tab[1] ← "e"
Tab[2] ← "i"
Tab[3] ← "o"
Tab[4] ← "u"
Tab[5] ← "y"
Fin
TABLEAUX
34
Variables Nb, Som, Moy, Nbsup :réels Moy ← Som / Nb

Tableau T[30],i: entiers NbSup ← 0
Debut Pour i ← 0 à Nb – 1 faire
Ecrire ("Entrez le nombre de notes à saisir : ") Si T[i] > Moy Alors
Lire (Nb) NbSup ← NbSup + 1
Pour i ← 0 à Nb – 1 faire FinSi
Ecrire( "Entrez le nombre n° ", i + 1) i Suivant
Lire (T[i]) finpour
i Suivant Ecrire (NbSup, " élèves dépassent la moyenne de la classe")
finpour Fin
Som ← 0
Pour i ← 0 à Nb – 1 faire
Som ← Som + T[i]
i Suivant
finpour
Les procédures et les fonctions
34
Notion de réutilisabilité
l’instant, un programme est une séquence d’instructions mais sans partage

⚫ Pour
des parties importantes ou utilisées plusieurs fois.
⚫Lebloc suivant peut être exécuté à plusieurs endroits
Répéter
Ecrire("Entrez un nombre entre 1 et 100 : ")
Lire(i)
TantQue ((i < 1) ou (i > 100))

⚫ Bonne pratique : Ne jamais dupliquer un bloc de code !
⚫ Ce qu’on veut recopier doit être mis dans une fonction.

34
⚫Résoudre le problème suivant :
Écrire un programme qui affiche, en ordre croissant, les notes d’une

classe suivies de la note la plus faible, de la note la plus élevée et de
la moyenne.
revient à résoudre les sous problèmes suivants :
-Remplir un tableau des notes saisies par l’utilisateur
-Afficher un tableau des notes
-Trier un tableau de notes en ordre croissant
-Trouver le plus petit réel d’un tableau
-Trouver le plus grand réel d’un tableau
-Calculer la moyenne d’un tableau de réels
34
Algorithme TraitTableau;
Variables tableau tab[100] : réel;
pPetit, pGrand, moyen : réel;
Début
Saisir(tab);
Afficher(tab);
pPetitplusPetitElements(tab);
pGrandplusGrandElements(tab);
moyen calculerMoyen(tab);
Trier(tab);
Fin
34
Chacun de ces sous-problèmes devient un nouveau problème à résoudre.

Si on considère que l’on sait résoudre ces sous-problèmes, alors on sait “
quasiment” résoudre le problème initial.
Donc écrire un programme qui résout un problème revient toujours à écrire
des sous-programmes qui résolvent des sous parties du problème initial.
En algorithmique, il existe deux types de sous-programmes :
-Les fonctions
-Les procédures
⚫Un programme long est souvent difficile à écrire et à comprendre.
⚫C’estpourquoi, il est préférable de le décomposer en des parties appelées
sous-programmes ou modules.
⚫Les fonctions et les procédures sont des modules (groupe d'instructions)

indépendants désignés par un nom.
34
Elles ont plusieurs avantages :
⚫Permettent d’éviter de réécrire un même traitement plusieurs fois. En effet,

on fait appel à la procédure ou à la fonction aux endroits spécifiés.
⚫Permettent d’organiser le code et améliorent la lisibilité des programmes.

⚫Facilitent la maintenance du code (il suffit de modifier une seule fois).
⚫Ces procédures et fonctions peuvent éventuellement être réutilisées dans

d'autres programmes.
Les fonctions
35
⚫Lerôle d'une fonction en programmation est similaire à celui d'une

fonction en mathématique : elle retourne un résultat au programme
appelant.
⚫Lecorps de la fonction est la portion de programme à réutiliser ou à

mettre en évidence.
⚫Les paramètres de la fonction : (les «entrées», ou les «arguments»)

ensemble de variables extérieures à la fonction dont le corps dépend pour
fonctionner.
Les fonctions
35
⚫Une fonction s'écrit en dehors du programme principal sous la forme:
Fonction nom_fonction (paramètres et leurs types) : type_fonction
Variables // variables locales

Début
Instructions; //le corps de la fonction
retourne; //la valeur à retourner
FinFonction
⚫Le nom_fonction : désignant le nom de la fonction.

⚫type_fonction est le type du résultat retourné
.
⚫L'instruction retourne sert à retourner la valeur du résultat.
Les fonctions
35
Caractéristiques des fonctions
⚫La fonction est désignée par son nom.

⚫Une fonction ne modifie pas les valeurs de ses arguments en entrée.
⚫Elle se termine par une instruction de retour qui rend un résultat et un

seul.
⚫Une fonction est toujours utilisée dans une expression (affectation,
affichage,…) ayant un type compatible avec le type de retour de la
fonction.
⚫On doit fournir une valeur pour chacun des arguments définis pour la
fonction (certains langages acceptent des valeurs par défaut).
Les fonctions
35
⚫ La fonction max suivante retourne le plus grand des deux réels x et y fournis en arguments :
Comment appeler la méthode Quels sont les paramétres Quel est le type du résultat
Fonction max (x : réel, y: réel ) : réel

variable z : réel
Début
z ←y;
si (x>z) alors z ←x
finsi; Que fait la méthode
retourne (z);
FinFonction Quel est le résultat
⚫La fonction Pair suivante détermine si un nombre est pair :

Fonction Pair (n : entier ) : booléen
Debut
retourne (n%2=0);
FinFonction
Les fonctions
35
⚫L'utilisation d'une fonction se fera par simple écriture de son nom dans
le programme principale. Le résultat étant une valeur, devra être affecté
ou être utilisé dans une expression, une écriture, ...
⚫Exemple: Algorithme exepmleAppelFonction

variables c : réel, b : booléen
Début
b ←Pair(3);
c ←5*max(7,2)+1;
écrire("max(3,5*c+1)= ", max(3,5*c+1));
Fin
⚫Lorsde l'appel Pair(3); le paramètre formel n est remplacé par le

paramètre effectif 3.
Les fonctions
35
⚫L’évaluation de l’appel : f(arg1, arg2, ..., argN); d’une fonction définie par :
typeR f(type1 x1, type2 x2, ..., typeN xN) { ... }

s’effectue de la façon suivante :
⚫ 1. Les expressions arg1, arg2, ..., argN passées en argument sont

évaluées.
⚫ 2. les valeurs correspondantes sont affectées aux paramètres x1, x2,
..., xN de la fonction f (variables locales à f).
⚫Concrètement, ces deux premières étapes reviennent à faire : x1<-arg1;

x2 <- arg2; ...;xN <- argN;
Les fonctions
35
⚫ 3. les instructions correspondantes au corps de la fonction f sont exécutées.
⚫ 4. l’expression suivant la première commande return rencontrée est évaluée...
⚫ 5. ...et retournée comme résultat de l’appel : cette valeur remplace l’expression de

l’appel, c-à-d l’expression f(arg1, arg2, ..., argN);
⚫ L’évaluation de l’appel d’une méthode peut être schématisé de la façon suivante :

Les fonctions
35
⚫Ecrire
une fonction qui calcule la somme de deux entiers
donnés en paramètres.
⚫Ecrire une fonction qui calcule le produit de trois réels donnés
en paramètres.
⚫Ecrire une fonction Min_2 qui calcule le minimum de deux
entiers donnés en paramètres.
⚫Ecrire une fonction qui teste si n entier est divisible par 3 ou
non.
⚫Ecrire une fonction qui prend en paramètres un nombre entier N
et qui calcule la somme des nombres impaires compris entre 1
et N.
Les fonctions
35
1 4
Fonction somme ( a: int, b: int): int Fonction est_divi_3 ( a: int): int
début début
retourne(a+b) si (n%3==0) alors retourne (1)
sinon retourne(0)
finFonction finsi
2 finFonction
Fonction produit ( a: réel, b: réel, c: réel): réel
début 5
retourne(a*b*c) Fonction somme_imp ( n: int): int
variables i, s=0 : int
finFonction début
3 pour i : 1 à n faire
Fonction Min_2 ( a: int, b: int): int si (n%2!=0) alors
début s<- s+i
si (a<b) alors retourne(a) finsi
sinon retourne(b) finPour
finsi retourne(s)
finFonction finFonction
Les procédures
35
⚫ Dans le cas où une tâche se répète dans plusieurs endroits du programme

et elle ne calcule pas de résultats ou qu’elle calcule plusieurs résultats à la
fois alors on utilise une procédure au lieu d’une fonction.
⚫ Uneprocédure est un sous-programme semblable à une fonction mais qui

ne retourne rien.
⚫ Une procédure s'écrit en dehors du programme principal sous la forme :
Procédure nom_procédure (paramètres et leurs types)

Variables //locales
Début
Instructions constituant le corps de la procédure
FinProcédure
⚫ Remarque : une procédure peut ne pas avoir de paramètres

Les procédures
35
⚫ Pour appeler une procédure dans un programme principale ou dans une autre
procédure, il suffit d’écrire une instruction indiquant le nom de la procédure :
Procédure exempleProcedure (…)

…
FinProcédure
Algorithme exepmleAppelProcédure
Début
exempleProcedure (…)
…
Fin
Remarque :
⚫ contrairement à l'appel d'une fonction, on ne peut pas affecter la procédure appelée
ou l'utiliser dans une expression.
⚫ L'appel d'une procédure est une instruction autonome.

Les procédures
35
Paramètres d'une procédure

⚫ Les paramètres servent à échanger des données entre le programme principale (ou
la procédure appelante) et la procédure appelée.
⚫ Les paramètres placés dans la déclaration d'une procédure sont appelés

paramètres formels. Ils sont des variables locales à la procédure.
⚫ Les paramètres placés dans l'appel d'une procédure sont appelés paramètres
effectifs. ils contiennent les valeurs pour effectuer le traitement.
⚫ Le nombre de paramètres effectifs doit être égal au nombre de paramètres formels.

⚫ L'ordre et le type des paramètres doivent correspondre.
⚫ Ilexiste deux modes de transmission de paramètres dans les langages de
programmation :
La transmission par valeur et la transmission par adresse.

Les procédures
35
Transmission des paramètres
⚫La transmission par valeur : les valeurs des paramètres effectifs sont
affectées aux paramètres formels correspondants au moment de l'appel de
la procédure. Dans ce mode le paramètre effectif ne subit aucune
modification.
⚫La transmission par adresse (ou par référence) : les adresses des
paramètres effectifs sont transmises à la procédure appelante. Dans ce
mode, le paramètre effectif subit les mêmes modifications que le paramètre
formel lors de l'exécution de la procédure.
•Remarque : le paramètre effectif doit être une variable (et non une
valeur) lorsqu'il s'agit d'une transmission par adresse.
Les procédures
35
Transmission des paramètres: exemples
Procédure incrementer1 (x : entier par valeur, y : entier par adresse)

x ← x+1;
y ← y+1;
FinProcédure
Algorithme Test_incrementer1
variables n, m : entier
Début
n ← 3;
m ← 3;
incrementer1(n, m) ; résultat : n=3 et m=4
écrire (" n= ", n, " et m= ", m) ;
Fin
Remarque : l'instruction x ← x+1; n'a pas de sens avec un passage par valeur
Les procédures
35
Transmission des paramètres: exemples
Procédure qui calcule la somme et le produit de deux entiers :
Procédure SommeProduit (x, y: entier par valeur, som, prod : entier par adresse)
som ← x+y; prod ← x*y;
FinProcédure
Procédure qui échange le contenu de deux variables :
Procédure Echange (x : réel par adresse, y : réel par adresse)
Variables z : réel
z ← x;
x ← y;
y ← z;
FinProcédure
SOUS ALGORITHMES
42
 Passage par valeur  Passage par référence
Fonction échnger(x: réel, y : réel) : vide Fonction echnger(ref x: réel, ref y : réel) : vide
z : réel; z : réel;
début début
z := x; z := x;
x := y; x := y;
y := z; y := z;
fin fin
Fonction appelante() a, b : réel Fonction appelante() a, b : réel
début début
a := 2; b:= 7; a := 2; b:= 7;
échanger(a,b); échanger(a,b);
écrire( a = , a); écrire( a = , a);
écrire( b = , b); écrire( b = , b);
fin fin
Les résultas affichés par la fonction appelante :
Les résultas affichés par la fonction appelante : a= 7 b= 2
a= 2 b= 7
Les procédures
35
Variables locales et globales
⚫ On peut manipuler 2 types de variables dans un module (procédure ou fonction) : des

variables locales et des variables globales. Elles se distinguent par ce qu'on
appelle leur portée (leur "champ de définition", leur "durée de vie").
⚫ Une variable locale n'est connue qu'à l'intérieur du module où elle a été définie.
Elle est créée à l'appel du module et détruite à la fin de son exécution.
⚫ Une variable globale est connue par l'ensemble des modules et le programme
principale. Elle est définie durant toute l’application et peut être utilisée et modifiée
par les différents modules du programme.
⚫ La manière de distinguer la déclaration des variables locales et globales diffère selon
le langage
•En général, les variables déclarées à l'intérieur d'une fonction ou procédure sont
considérées comme variables locales.
⚫ En pseudo-code, on va adopter cette règle pour les variables locales et on déclarera

les variables globales dans le programme principale.
Les procédures
35
⚫ Quelles sont les valeurs de a et b après l’exécution du programme suivant:
Fonction f (x : entier): entier Algorithme Test_f

a ← 2; variables a, b : entier
b ← 7; Début
Retourne(a*x+b) a ← 0;
FinFonction b ← 2;
a++
b--
b ← f(a)
Fin
Les procédures
35
⚫ Les variables globales a et b sont initialisées respectivement aux valeurs 0 et 2

⚫ a++ fera passer la valeur de a à 1
⚫ b--, fera passer la valeur de b à 1
⚫ b=f(a); va premièrement provoquer l’exécution de la fonction f avec la paramètre
effectif a puis l’affectation de la valeur retournée par la fonction à la variable b.
⚫ L’exécution de la fonction f: les instructions a=2, b=7; vont modifier les variables a
et b, car celles-ci sont des variables globales. La valeur retournée par f sera 2
*1+7=9
⚫ La valeur 9 est ensuite affectée à b
⚫ Après l’exécution du programme a=2 et b=9.
Les procédures
35
⚫ Quelles sont les valeurs de a et b après l’exécution du programme suivant:
Fonction f (a : entier): entier Algorithme Test_f

k← 1; variables k: entier
écrire (" k= ", k) Début
Retourne (k*a) k ← 0;
FinFonction k++
écrire (" k= ", k)
k←2
k++
écrire (" k= ", k)
k- -
écrire (" k= ", k)
k=f(k)
Fin
Récurrence et Récursivité
35
⚫ Suite récurrente: la définition d’une suite est la donnée

- D’un terme général défini en fonction du (ou des) terme(s) précédant(s)
- D’un terme initial qui permet d’initialiser le calcul
⚫ Principe de récurrence :
Soit P un prédicat (ou propriété) sur IN qui peut être soit vrai soit faux (on
écrira souvent P(n) à la place de P(n) = vrai).
On suppose que
• P(0) vrai
• ∀n ∈IN, P(n) ⇒P(n+1)
Alors , pour tout n ∈IN, P(n) est vrai.
Si on considère le prédicat suivant
P(n) : je sais résoudre le problème pour n alors le principe de récurrence
nous dit que si je sais résoudre le Pb pour n=0 et que si je sais exprimer la
solution pour n en fonction de la solution pour n+1 alors je sais résoudre le Pb
pour n’importe quel n.
35
 Examples:
1. Puissance
a0 = 1 a0 = 1
Ou bien
an+1 = aan an = a an-1 n>0
2. Factoriel
0! = 1
n! = n (n-1)! , n 1
3. Suite de Fibonacci
F0= F1= 1
Fn= Fn-1 + Fn-2 , n2
35
⚫
Un algorithme (ou fonction) est dit récursif s’il est défini en fonction de lui-
même.
 Exemples
▪ Fonction puissance(x : réel, n : entier) : réel
début
si n = 0 alors retourner 1
sinon retourner (x * puissance(x , n-1))
fin
▪ Factoriel (n) début

si n = 0 alors retourner(1)
sinon retourner (n*factoriel(n-1))
fin
▪ fact(n)  Le déroulement de l’appel de fact(3):
début 3*fact(2)
si n = 0 alors Fact(3) 3*2=6 2*fact(1)
retourner(1) sinon 6 2*1=2 1*fact(0)
retourner(n*fact(n-1)) fsi 1*1=1
fin
▪ La condition n = 0 est appelée test
d’arrêt de la récursivité.
❑ Il est impératif de prévoir un test d’arrêt
dans une fonction récursive, sinon
l’exécution ne s’arrêtera jamais.
 L’appel récursif est traité commen’importe
appel de fonction.
L’appel d’une fonction (récursive ou non) se fait dans un
contexte d’exécution propre (pile d’exécution), qui
contient :
▪ L’adresse mémoire de l’instruction qui a appelé la
fonction (adresse de retour)
▪ Les valeurs des paramètres et des variables locales
à la fonction.
L’exécution d’une fonction récursive se fait par des appels

successifs à la fonction jusqu’à ce que la condition d’arrêt
soit vérifiée, et à chaque appel, les valeurs des
paramètres et l’adresse de retour sont mis (empilés) dans
la pile d’exécution.
 L’ordre des instructions par rapport à un appel récursif est important.
 Exemple:
afficher(n)
début
si n > 0 alors
١
afficher(n div 10) écrire(n mod10)
٢
fsi
fin
 L’algorithme récursif afficher(n) permet d’afficher les chiffres d’un entier,
strictement positif, selon la disposition de l’instruction écrie(n mod 10):
-Si l’instruction est placée en ١ , les chiffres sont affichés dans l’ordre inverse
-Si elle est placée en ٢, alors les chiffres seront affichés dans le
bon ordre Pour n = 123, on a :
١ →3 2 1
٢ →1 2 3
Type de Récursivité
 Récursivité simple: Une fonction récursive contient

un seul appel récursif.
 Récursivité multiple: une fonction récursive
contient plus d’un appel récursif (exemple suite de

Fibonacci).
 Récursivité mutuelle( ou croisée): Consiste à
écrire des fonctions qui s’appellent l’une l’autre.

Exemple
Récursivité Mutuelle
Pair(n) Impair(n)
début début
si n = 0 alors si n = 0 alors
retourner vrai retourner (faux)
sinon sinon
retourner (impair(n-1)) retourner (pair(n-1))
fsi fsi
fin fin
Notion de pile
Notion de pile.
Une pile est une structure pour représenter une suite
d’éléments avec la contrainte qu’on ne peut ajouter, ou
enlever, unélément que d’un mêmecôté de la
pile (dit sommet de la pile). ajouter enlever
 Exemple pile d’assiettes. som
4
 Une pile peut être représentée
par un tableau et un indice de sommet

P
Notion de pile
 Opérations définies sur les piles:
▪ initialiser(p : Pile) //Crée une pile vide.

▪ sommet(p : Pile) : élément// Renvoie l’élément au sommet
de la pile p, sous la condition que p soit non vide.
▪ empiler(x : élément, p : Pile) / / ajoute x au sommet de la
pile p.
▪ dépiler(p : Pile) / / supprime l’élément au sommet de la pile p,
sous la condition que p soit non vide.
▪ pileVide(p : Pile) : booléen / / retourne vrai si p est vide.
Notion de pile
 Exemple.
Une expression e est dite bien parenthésée (on selimite au ‘(‘ et ‘)’) si :
1. Le nombre de parenthèses ouvrantes (e() est égal au nombre de
parenthèses fermantes (e)) dans e.
2. Tout préfixe (partie gauche) u de e vérifie: u( - u(  0.
Algorithme: on parcourt l’expression e (de gauche à droite). A chaque

rencontre d’une parenthèse ouvrante on l’empile, et à chaque
rencontre d’une parenthèse fermente on dépile.
Si on arrive à la fin de e avec une pile vide, l’expression e est bien
parenthésée sinon e n’est pas bien parenthésée.
- l’expression (()())() est bien parenthée.

- l’expression ())( n’est pas bien parenthésée.
Transformation du récursif en itératif :
« Dérécursivation »
 Schéma d’un algorithme récursif:
algoR(X)
début Où :
X : liste de paramètres
A C : condition d’arrêt portant sur X
si C(X) alors A, B,D, E: bloc d’instructions (éventuellement vide)
B; (X) : transformation des paramètres
algoR((X));
D;
sinon
E;
fsi;
fin
 Algorithme itératif équivalent.
algoR(X) algoI(X)
Début p : Pile
A début
si C(X)alors initialiser(p);
B; A;
algoR((X)); tantque C(X) faire
D; B;
empiler(X, p);
sinon
X :=  (X);
E;
A;
fsi;
fin ftantque;
E;
tantque (non pileVide(p)) faire
X := sommet(p);
dépiler(p);
D;
ftantque
 Exemple. afficherI(n)
p : Pile;
afficherR(n) Début
début initialiser(p);
si n > 0 alors
tanque n > 0 faire
afficher(n div 10)
écrire(n mod10);
empiler(n, p);
fsi n := n div 10;
fin ftantque
tantque (non pileVide(p)) faire
n := sommet(p);
dépiler(p);
écrire(n mod 10);
ftanque
Récursivité terminale:
 La récursivité d’une fonction F(X) est aussi dite terminale
lorsqu’elle se termine par l’instruction retourner(F((X))). On
ajoute, dans ce cas, un paramètre à la liste X pour contenir
le résultat de retour d’un appel récursive, comme le montre
l’exemplesuivant:
Exemple
fonction FACR(n); fonction FACR'(n,r)

début début
si n=0 alors retourner (1) si n=0 alors retourner (r)
sinon retourner (n* FACR(n-1)); sinon retourner (FACR'(n-1, n*r));
fin. fin.
RÉCURSIVE RÉCURSIVITÉ TERMINALE
fonction FACI(n);
fonction FACI'(n, r) ;
début
début
r: = 1 ;
tant que n > 0 faire
tant que n > 0 faire
{ r : = n* r ; n : = n-1 ; }
{ r := n* r ; n := n-1 ; }
retourner (r) ;
retourner (r) ; fin.
fin.
ITÉRATIVE
Exercices
1. Ecrire une fonction récursive qui permet de calculer la suite suivante:
2. Ecrire une fonction booléenne rend une valeur vrai si un nombre "b"
est diviseur d’un nombre "a" ou faux dans le cas contraire.
3. Ecrire une fonction récursive permettant de calculer la puissance pour
x réel et n entier en utilisant la définition récursive suivante:
Exercices : Solution
Fonction Suite-R (N : Entier) : entier

1. Debut
Si N = 1 Alors
Retourne(1)
Sinon retourne(Suite-R (N-1) + N)
FinSi
Fin
2. Fonction divisible (a, b : entier) : booleen
Debut
Si a ≤ b alors
Retourne(a = b)
Sinon
retourne(divisible (a –b, b) )
FinSi
Fin
Fonction Cal (X : Reel, n : entier) : entier

3. Debut
Si n =0 Alors
retourne(1)
Sinon
Si n Mod 2 = 0 Alors
Retourne(Cal (Cal (X, n Div 2), 2) )
Sinon
retourne(Cal (X, n -1) * X )
FinSi
Finsi
Fin
Analyse descendante
 Pourquoi cet analyse

Il est souvent difficile d’écrire la version définitive du premier coup, on
risque de se perdre dans des détails et de ne pas voir l’essentiel.
On procède par étapes en définissant des actions très générales:
cette méthode est appelée méthode par raffinages successifs ou
l’analyse descendante.
➢ L’analyse descendante est un mode de pensée visant à construire

des algorithmes en partant d’un niveau très général et en détaillant
peu à peu chaque traitement, jusqu’à arriver au niveau de description
le plus bas.
➢ Diviser un problème en sous problèmes pour régner, construire des

modules ou des sous programmes.
Analyse descendante
L’analyse descendante consiste en trois étapes :
1. Diviser le problème en sous problèmes. C’est une partie importante

qui conditionne le reste et qui n’est basée que sur l’expérience.
2. Résoudre chacun des sous problèmes:
• Soit en appliquant à nouveau la première étape (Diviser les sous
problèmes en à résoudre en sous problèmes.
• Soit en résolvant directement le sous problème qui est un problème
simple et connu.
3. Combiner les résultats des sous problèmes. C’est la partie la plus
rigoureuse dans laquelle on doit faire attention à ce que donnent
les sous résultats et à ce qu’il est nécessaire de faire pour obtenir le
résultat final.
Analyse descendante
Etude d’un exemple 1:

Le problème: Ecrire un programme qui lit une suite d’entiers et
détermine si chacun d’eux est pair et qui , dans le cas contraire,
détermine si l’entier est premier.
Première étape: mettre en place la structure générale de la solution
(niveau 1) sans s’occuper des problèmes « comment déterminer si N est
paire et N est premier ».
// Niveau 1: Programme qui lit et étudie une liste d’entiers
Début
Lire un entier N
Tant que N est différent de 0 faire
Déterminer si N est pair et éventuellement s’il est premier
Lire l’entier N suivant
Fin Tq
Analyse descendante
Deuxième étape: il s’agit de raffiner un peu plus le sous problème càd

Déterminer si N est pair et éventuellement s’il est premier
Troisième étape: raffiner les deux modules N est pair et N est premier
// Niveau 3: calculer et afficher
// Niveau 2: Calculer s’il est pair et premier N est premier
Début // Niveau 3: Si N est Div <- 2
si N est pair alors pair Tant que ((N mod div) !=0 et
Ecrire(« N pair ») si (N mod 2)=0 alors (div*div <= à N) faire
sinon incrémenter div
Ecrire(« N est impair ») Fin tq
calculer et afficher si N est premier si N mod div!= 0 alors
fin Ecrire (« N est premier »)
Fin sinon
Ecrire (« N n’est pas premier »)
Analyse descendante
// Dernière étape combiner les résultats des sous programmes
Var N:entier
Début
Lire(N)
Tant que N !=0 faire
si (N mod 2)=0 alors
Ecrire(« N pair »)
sinon
Ecrire(« N est impair »)
div <- 2
Tant que ((N mod div) !=0 et (div*div <= à N) faire
div<-div+1
Fin tq
si N mod div!= 0 alors Ecrire (« N est premier »)
sinon Ecrire (« N n’est pas premier »)
Fin si
N<-N+1
fin si
Fin Tq
Fin
Analyse descendante

Le problème: Ecrire un algorithme qui demande à l’utilisateur un entier
et qui indique si cet entier est un nombre de Armstrong.
Analyse descendante

Le problème: Ecrire un algorithme qui demande à l’utilisateur un entier
et qui indique si cet entier est un nombre de Armstrong.
Les algorithmes de tris
➢ Le tri consiste à ordonner les éléments du tableau dans l’ordre

croissant ou décroissant.
➢ Un tableau T est dit « trié en ordre croissant » si tous les
éléments consécutifs du tableau vérifient: T[i-1]<=T[i]
➢ D’où la définition:
➢ Un tableau vide (n=0) est ordonné (trié),
➢ Un tableau contenant un seul élément n=1 est ordonné,
➢ Un Tableau T[1…..n], n>1 est ordonné si i appartient à [2….n], T[i-1]<=
T[i]
➢ Il existe plusieurs algorithmes connus pour trier les éléments d‘un
tableau
➢ Le tri par sélection et permutation(tri par minimun successif)
➢ Le trie à bulles
➢ Le trie par insertion
Tri par minimum successif
Algorithme:
pour i=1 à n-1 faire
-chercher le 1ème minimum, Ak , de {Ai+1,…,An} (K est l’indice de
min{Ai+1,…,An} dans le tableauA)
- échanger Ai etAk
L’algorithme fonctionne selon le schéma suivant:

Tri par minimum successif
➢ Principe:
Le tri par minimum successif nommé tri par sélection et
permutation: pour une place donné, on sélectionne l’élément qui
doit y être positionné.
Si on parcourt le tableau de gauche à droite, on positionne à

chaque fois le plus petit élément qui se trouve dans le sous tableau
droite.
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]
Tri par sélection:
minimum successif
Il consiste à trouver dans le tableau le numéro de l’élément le plus petit, c’est-à-
dire l’entier min tel que tab[k] >= tab[min] pour tout k. Une fois ce
numéro trouvé, les éléments tab[1] et tab[min] sont échangés – cet
échange nécessite une variable temporaire de type entier – puis la même
procédure est appliquée sur la suite d’éléments tab[2], ..., tab[N].
Tri par minimum
successif
 Algorithme:
Tri_selection(A,n)
début
pour i := 1 à n-1 faire
//Recherche de min{Ai, …, An} = Ak
k := i;
pour j:=i+1 à n faire
si A[j] < A[k] alors
k:=j;
fsi;
fpour
// échange de Ak et Ai
temp := A[k];
A[k] := A[i];
A[i] := temp;
fpour
itératifs: Tri rapide
6
Soit à trier le tableau T[g..d] (au départ g=1 et d=n)

Le principe de l’algorithme réside dans une procédure,
appelée partition, qui réorganise les éléments de T autour
d’un pivot (élément du tableau choisi au hasard) de sorte
que :
1) Il existe un indice p (g≤ p ≤d) tel que p est la position

définitive du pivot (T[p] = pivot).
2) tous les éléments T[g], …, T[p-1] sont inférieurs ou
égaux à T[p].
3) tous les éléments T[p+1], …T[d] sont supérieurs ou
égaux à T[p].
6
La fonction partition, appliquée à un tableau T, produit

trois sous-tableaux:
• Un sous-tableau réduit à un seul élément T[p] qui garde
sa place définitive dans le tri de T, et
• Deux sous-tableaux T[g .. p-1], T[p+1 .. d].
• Pour trier T, il suffit d’appliquer récursivement le même
algorithme sur les deux sous-tableaux.
6
itératifs: Tri à bulles
9
 L’algorithme consiste à parcourir le tableau à trier en

examinant si chaque couple d’éléments consécutifs (ai, ai+1)
est dans le bon ordre ou non, si ce couple n’est pas dans le
bon ordre on échange seséléments et ce processus est répété
tant qu’il reste des inversionsà faire.
 On dit qu’on a une inversion s’il existe (i,j) tels que i<j et
ai > aj
 (a1,…,ai , ai+1,…,an) (a1,…,ai+1,ai,…,an)
 Untableau est trié s’il n’a aucuneinversion.
9
9
itératifs: Tri par insertion
 On remarque que les transpositions successives font pousser le

maximum à la dernière position du tableau si on fait un balayage
de gauche à droite et le minimum à la 1ère position si on fait un
balayage de droite à gauche.
Complexité
⚫L’exécution d’un algorithme sur un ordinateur consomme des
ressources:
•en temps de calcul : complexité temporelle
•en espace-mémoire occupé : complexité en espace
⚫Seule la complexité temporelle sera considérée pour évaluer
l’efficacité et la performance de nos programmes.
▪ Comment choisir entre différents algorithmes pour résoudre
un même problème?
Plusieurs critères de choix :
➢ Exactitude
➢ Simplicité
➢ Efficacité (but de ce chapitre)
Complexité
L’analyse de la complexité consiste à mesurer ces deux grandeurs pour
choisir l’algorithme le mieux adapté pour résoudre un problème.(le
plusrapide, le moins gourment enplace mémoire)
On ne s’intéresse, ici, qu’à la complexité temporelle c.à d. qu’au temps de calcul

(par opposition à la complexité spatiale)
⚫Le temps d’exécution dépend de plusieurs facteurs :
•nombres).
Les données (trier 4 nombres ne peut être comparé au trie de 1000
•Le code généré par le compilateur (interpréteur).
•La nature de la machine utilisée (mémoire, cache,multi-treading,…)
•La complexité de l’algorithme.
⚫La complexité d’un algorithme permet de qualifier sa performance par
rapport aux autres algorithmes.
Complexité
5
T(n) dénote le temps d’exécution d’un programme sur un

⚫Si
ensemble de données de taille n alors :
⚫T(n)=c.n2 (cest une constante) signifie que l’on estime à c.n2

le nombre d’unités de temps nécessaires à un ordinateur pour
exécuter le programme.
exemple: jeu d’échec par recherche exhaustive de tous les

coups possibles
1019 possibilités, 1 msec/poss. = 300 millions
d’années
Complexité
 La complexité dépend de la taille des données de

l’algorithme.
▪ Exemples :
➢ Recherche d’une valeur dans un tableau
→ taille (= nombre d’éléments du tableau)

➢ Produit de deux matrices
→ dimension desmatrices
➢ Recherche d’un mot dans un texte
→ longueur du mot et celle du texte
On note généralement:
n la taille de données, T(n) le temps (ou le cout) de
l’algorithme.
Complexité
7
 Dans certains cas, la complexité ne dépend

pas seulement de la taille de la donnée du
problème mais aussi de la donnée elle-
même.
Toutes les données de même taille ne
génèrent pas nécessairement le même temps
d’exécution.
→ (Ex. la recherche d’une valeur dans un
tableau dépend de la position de cette
valeur dans le tableau)
Complexité: Exemple
7
⚫ Écrire une fonction qui permet de retourner le plus grand diviseur d’un entier.
Fonction PGD1( n: entier) : entier Fonction PGD2( n: entier) : entier
Variables i :entier Variables i :entier
Debut Debut
i  n-1 ; i  2;
Tantque (n%i !=0) Tantque ((i<sqrt(n))&&(n%i !=0))
i  i-1; i  i+1;
finTantque finTantque
Retourner( i) si(n%i == 0) alors retourner (n/i)
sinon retourner (1)
finsi
Fin Fin
Pour un ordinateur qui effectue 106 tests par seconde et n=1010 alors le temps
requis par PGD1 est d’ordre 3 heures alors que celui requis par PGD2 est d’ordre
0.1 seconde
Complexité
 Une donnée particulière d’un algorithme est appelée

instance du problème.
 On distingue trois mesures de complexité:

1. Complexité dans le meilleur cas: c'est la situation la
plus favorable, qui correspond par exemple à la
recherche d'un élément situé à la première position
d’un tableau, ou encore au tri d’un tableau déjà trié.
TMin (n) = min {T(d) ; d une donnée de taille n}

Complexité
2. Complexité dans le pire cas: c'est la situation la plus défavorable,

qui correspond par exemple à la recherche d'un élément dans un
tableau alors qu'il n'y figure pas, ou encore au tri par ordre
croissant d’un tableau trié par ordre décroissant.
TMx (n) = max {T(d) ; d une donnée de taille n }
3. dans le cas moyen: on suppose là que les données sont réparties

selon une certaine loi de probabilités.
TMOY (n) =  p(d).T (d)
d de taille n
p(d) : probabilité d'avoir la donnée d
TMIN (n)  TMOY (n)  TMAX (n)

Complexité: notation O
7
⚫La complexité est souvent définie en se basant sur le pire des cas ou sur la
complexité moyenne. Cependant, cette dernière est plus délicate à calculer
que celle dans le pire des cas.
⚫De façon général, on dit que T(n) est O(f(n)) si  c et n0 telles que  n≥n0,
T(n) ≤ c.f(n).
⚫L’algorithme ayant T(n) comme temps d’exécution a une complexité d’ordre
O(f(n))
⚫La complexité croit en fonction de la taille du problème
•L’ordre utilisé est l’ordre de grandeur asymptotique.

•Les complexités n et 2n+5 sont du même ordre de grandeur.
•n et n2 sont d’ordres différents.
Complexité: régles
7
⚫1- Dans un polynôme, seul le terme de plus haut degré compte.
•Exemple : n3+1006n2+555n est O(n3)

⚫2- Une exponentielle l’emporte sur une puissance, et cette dernière sur un
log.
Exemple: 2n+n100 est O(2n) et 300 log(n)+2n est O(n)
⚫3- Si T1(n) est O(f(n)) et T2(n) est O(g(n)) alors T1(n)+T2(n) est
O(Max(f(n),g(n))) et T1(n).T2(n) est O(f(n).g(n))
⚫Les ordres de grandeur les plus utilisées :
•O(log n), O(n), O(n log n), O(nk), O(2n)

Complexité
 Ordre de grandeur courant
▪ O(1) : complexité constante

▪ O(log(n)) : complexité logarithmique
▪ O(n) : complexité linéaire
▪ O(n2) : complexité quadratique
▪ O(n3) : complexité cubique
▪ O(2n) : complexité exponentielle
Calcul de la complexité:
règles pratiques
Evaluation de T (n) (séquence)
La complexité d’une suite d’instructions est la somme des
complexitésde chacuned’elles.
Somme des coûts.
Traitement1 T1 ( n)
T (n) = T 1 (n) + T 2 (n)
Traitement2 T2 ( n)
Les opérations élémentaires telle que l’affectation, test, accès à un

tableau, opérations logiques et arithmétiques, lecture ouécriture d’une
variable simple...etc, sonten O(1).
règles pratiques
Evaluation de T (n) (branchement)
Max des coûts.
Si < condit ion T1 (n) > alors

Traitement1 T2 (n)
max(T 1(n), max(T 2(n), T 3 (n)))
sinon
Traitement2 T3 ( n)
règles pratiques
Evaluation de T (n) (boucle Tant que)
La difficulté, pour la boucle tantque, est de déterminer le nombre
d’itération Nb_iter (ou donneruneborne supérieurede ce nombre)
T( tantque C faire A ftantque) =O(Nb_iter x (T(C) + T(A))
Somme des coûts des passages successifs
tant que < condition > faire

k
Σ T i (n)
i= 1
Traitement T i(n)
fin tq
règles pratiques
Evaluation de T (n) (boucle Pour)
Somme des coûts des passages successifs

Pour i := e1 à e2 faire
Traitement Ai(n)
fin pour
• si Ai ne contient pas de boucle dépendante de i et si Ai

est de complexité O(m) alors la complexité de cette boucle
« pour » est O((e2 – e1 + 1) m)
Méthode itérative [rappel sommations]
Complexité
 Exemples
1. Calcul de la somme1+2+…+n
S:=0; //O( 1)
Pour i:=1 à n faire
s:= s+ i; / / O(1)
O(1) + O(n) = O(n)
O(n)
fpour;
T(n) = O(n)
Complexité
2. Calcul de :
pour i := 1 à n faire
s:= 0; / / O(1)
pour j := 1 à i faire
s:= s+ j; / / O(1) O(i) O(1)+O(i)+O(1)=O(i)
fpour; = O(n2)
T[i] := s; //O(1)
fpour;
T(n) = O(n2)
Tableaux : recherche d’un
élément
7
⚫Pour effectuer la recherche d’un élément dans un tableau,

deux méthodes de recherche sont considérées selon que le
tableau est trié ou non :
•La recherche séquentielle pour un tableau non trié
•La recherche dichotomique pour un tableau trié
Méthode séquentielle
•Consiste à parcourir un tableau non trié à partir du

début et s’arrêter dés qu’une première occurrence
de l’élément sera trouvée.
•Le tableau sera parcouru du début à la fin si
l’élément n’y figure pas.
Recherche séquentielle :
algorithme
7
⚫Recherche de la valeur x dans un tableau T de N éléments :
Variables i: entier, Trouve : booléen

…
i←0 ; Trouve ← Faux;
TantQue (i < N) ET (non Trouve)
Si (T[i]=x) alors Trouve ← Vrai;
Sinon i←i+1;
FinSi
FinTantQue
Si Trouve alors // c'est équivalent à écrire Si Trouve=Vrai alors

écrire ("x est situé dans la "+i+ "eme position du tableau ");
Sinon écrire ("x n'appartient pas au tableau");
FinSi
Recherche séquentielle :
complexité
⚫Dans le pire des cas, on doit parcourir tout le
tableau. Ainsi, la complexité est de l’ordre de
O(n).
⚫Si le tableau est trié, la recherche
séquentielle peut s’arrêter dés qu’on
rencontre un élément du tableau strictement
supérieur à l’élément recherché.
⚫Si tous les éléments sont plus petits que
l’élément recherché, l’ensemble du tableau
est parcouru. Ainsi la complexité reste
d’ordre O(n).
Recherche dichotomique
⚫Dans le cas où le tableau est trié (ordonné), on peut

améliorer l'efficacité de la recherche en utilisant la méthode
de recherche dichotomique (diviser pour régner).
⚫Principe : diviser par 2 le nombre d'éléments dans

lesquels on cherche la valeur x à chaque étape de la
recherche. Pour cela on compare x avec T[milieu] :
•Si x < T[milieu], il suffit de chercher x dans la 1ère moitié du
tableau entre (T[0] et T[milieu-1])
•Si x > T[milieu], il suffit de chercher x dans la 2ème

•On continue le découpage jusqu’à un sous tableau de taille
⚫On utilise l’ordre pour
•anticiper l’abandon dans une recherche linéaire,

•guider la recherche : recherche par dichotomie
inf←0 ; sup←N-1;Trouve ← Faux;
TantQue (inf <=sup) ET (not Trouve)

milieu←(inf+sup) div 2;
Si (x<T[milieu]) alors sup←milieu-1;

Sinon Si (x>T[milieu]) alors inf←milieu+1;
Sinon Trouve ← Vrai;
FinSi
FinSi
FinTantQue
Si Trouve alors écrire ("x appartient au tableau");
Sinon écrire ("x n'appartient pas au tableau");
FinSi
Recherche dichotomique:
complexité
⚫Achaque itération, on divise les indices en 3 intervalles :
•[inf, milieu-1] : Cas 1
•Milieu : Cas 2
•[milieu+1, sup] : Cas 3
Cas 1 : milieu-inf ≤ (inf+sup)/2 - inf ≤ (sup-inf)/2
Cas 2 : =(sup-inf)/2
Cas 3 : sup-milieu ≤ sup -(inf+sup)/2 ≤ (sup-inf)/2
⚫Onpasse dans successivement à un intervalle dont le
nombre d’éléments ≤ n/2, puis n/4, puis n/8, …
⚫A la fin, on obtient un intervalle réduit à 1 ou 2 éléments

Recherche dichotomique:
complexité
⚫Le nombre d’éléments à la k ième itération est :
(½)k-1n >=2;
k vérifie: 2k ≤ n < 2k+1
k ≤ log2(n)< p+1 -> p=E(log2n)
⚫Donc 2k ≤n soit k ≤log2n
⚫Il
y a au plus log2n itérations comportant 3
comparaisons chacune.
⚫La recherche dichotomique dans un tableau trié est d’ordre
O(log2n).
⚫T(n) = T(n/2) + O(1) donc T(n) = O(log n)

Tri par sélection-échange
: complexité
⚫ Exemple :
•Étape 1: on cherche le plus petit parmi les 5 éléments du tableau. On l’identifie en

troisième position, et on l’échange alors avec l’élément 1 :
•Étape 2: on cherche le plus petit élément, mais cette fois à partir du deuxième
élément. On le trouve en dernière position, on l'échange avec le deuxième:
•Étape 3:
Tri par sélection-échange
: complexité
⚫ Supposons que le tableau est noté T  La boucle j détermine le iè minimum;
et sa taille N elle tourne n-i fois (au maximum) pour
faire (n-i) tests d’éléments.
Pour i 0 à N-2  Leséchanges de A[indice-
indice_ppe ← i; ppe] et A[i] demandent 3
Pour j  i + 1 à N-1 opérations.
Si T[j] <T[indice_ppe]  La complexité du corps de la boucle j
est donc en O(n-i) ( i=1, …, n-1).
alors
 La complexité de l’algorithme est de
indice_ppe ← j; l’ordre de:
Finsi
FinPour
temp ← T[indice_ppe];
T[indice_ppe] ← T[i];
T[i] ← temp;
FinPour T(n) = O(n2)
Tri en complexité quadratique.
Tri par insertion
: complexité
⚫ Exemple :
•Étape 1: on commence à partir du 2 ième élément du tableau (élément 4). On

cherche à l’insérer à la bonne position par rapport au sous tableau déjà trié
(formé de l’élément 9) :
•Étape 2: on considère l’élément suivant (1) et on cherche à l’insérer dans une

bonne position par rapport au sous tableau trié jusqu’à ici (formé de 4 et 9):
•Étape 3:
•Étape 4:
Tri par insertion
: complexité

 La boucle j tourne, dans le pire
Algorithme: des cas, (i-1) fois
Tri_Insersion(A,n) (i-1 comparaisons et i-1
début décalages)
pouri := 2 à n faire  La complexité du corps de la
cle := A[i]; boucle i est de la forme
j := i-1; a(i-1)+b, pour i=2,…,n.
Tantque (j>1) et (cle<A[j]) faire  La complexité de l’algorithme:
A[j+1] := A[j];
j := j-1;
ftantque
A[j+1] = cle;
fpour
fin T(n) = O(n2)
Tri en complexité quadratique.
Enregistrement
⚫Les langages de programmation offrent d’autres types de données

appelés enregistrements.
⚫Un enregistrement est un regroupement de données qui doivent être

considérés ensemble.
⚫Exemple: les fiches d’étudiants. Chaque fiche est caractérisée par :

un nom et prénom, numéro d’inscription, ensemble de notes…
⚫En pseudo-code : enregistrement FicheEtudiant
Debut
nom, prenom : chaine de caractères
numero : entier
tableau notes[10] : réel
Fin
Enregistrement
⚫Un enregistrement est un type comme les autres types.
⚫Ainsi la déclaration suivante :
f, g : FicheEtudiant
définit deux variables f et g enregistrements de type
FicheEtudiant
⚫L’enregistrementFicheEtudiant contient plusieurs parties

(champs), on y accède par leur nom précédé d’un point "." :
⚫f.nom désigne le champ (de type chaine) nom de la fiche f.
⚫f.notes[i] désigne le champ (de type réel) notes[i] de la fiche f.
Enregistrement
⚫Pour définir les champs d’un enregistrement, on écrit :

f: FicheEtudiant;
f.nom ← "XXXXX";
f.prenom ← "YYYYY" ;
f.numero ← 1256;
f.notes[2] ← 12.5;
⚫Lesaffectations entre enregistrement se font champ par

champ.
Enregistrement:
remarques
⚫Un champ peut être de type élémentaire ou de type
enregistrement.
⚫Ilest possible d'imbriquer sans limitation des enregistrements les
uns dans les autres.
Exemple :
Enregistrement Adresse
numero: Entier;
codePostal: Entier;
rue,ville: ChaîneDeCharactères;
Fin;
Enregistrement Personne
nom,prenom: ChaîneDeCharactères;
age : Entier ;
adresse : Adresse;
Fin;
Utilisation des
enregistrements
Procedure affiche(FicheEtudiant v)
debut
ecrire("No:",v.numero, "-",v.prenom)
Pour i allant de 0 à v.notes.taille()
écrire(v.notes[i], " ")
FinPour
finProcedure
Utilisation des
enregistrements
Fonction add( z1, z2 :Complexe par valeur) : Complexe
Début
Variable z: Complexe // l’enregistrement Complexe
z.re=z1.re+z2.re; ⚫ Enregistrement Complexe
z.im=z1.im+z2.im; re : réel
retourne(z)
FinFonction im: réel
Programme principale
Variables u, v, w: Complexe Fin
a, b, c, d : réel
Début
ecrire("Entrez 4 valeurs réelles :");
lire(a,b,c,d);
u.re ← a; u.im ← b; v.re ← c; v.im ← d;
w ← add(u,v);
ecrire("Somme( ,) = :", w.re,w.im);
fin

Cours Complet Algorithmique II

Transféré par

Droits d'auteur :

Formats disponibles

Cours Complet Algorithmique II

Transféré par

Informations du document

Description originale:

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

Cours Complet Algorithmique II

Transféré par

Droits d'auteur :

Formats disponibles

ALGORITHMIQUE II

 ALGORITHMES ITERATIFS DE TRIS

 COMPLEXITE ET PREUVE D’ALGORITHMES

Structure d’un algorithme

Algorithme : Nom d’Algorithme

Données : Les entrées de l’algorithme

 Une variable possède :

 Un type est un ensemble de valeurs sur lesquelles on définit

▪Un algorithme peut avoir des interactions avec l’utilisateur

▪Il peut demander à l’utilisateur de saisir une information afin

Instruction d'écriture (Sortie)

Syntaxe : écrire(liste d'expressions)

▪Cette instruction réalise simplement l'affichage des valeurs des

Instruction lecture (Entrée)

Syntaxe : lire(liste de variables)

▪L'exécution de cette instruction consiste à affecter une valeur à la

Algorithme : Affichage incrément

La deuxième partie de l’instruction est optionnelle, on peut avoir :

Structure de choix multiple

si abréviation = "Mme" alors

Structure de choix multiple

Structure de choix multiple

selon abréviation faire

▪Dans certain cas, Il est impossible de savoir à l'avance combien de fois

▪Deux formes existent : la première, si le nombre de répétitions est connu avant

• La valeur utilisée pour énumérer les itérations est appelée valeur

Remarque: la boucle pour affecte la valeur de initiale à variable et compare

 Exemple: calcul de 1+2+…+n (n entier 1 fixé)

▪Dans ce cas, on a deux possibilités :

Boucle Tant que

Boucle Tant que

Ecrire ("La saisie est valable ");

Boucle Répéter jusqu'à

La séquence d'instructions est exécutée au moins une fois et jusqu'à ce que

Boucle Répéter jusqu'à

Les boucles Tant que et Répéter jusqu’à

• Différences entre les boucles TantQue et Répéter jusqu’à :

- La séquence d'instructions est exécutée au moins une fois dans la

- Dans les deux cas, la séquence d'instructions est exécutée si la

- Dans les deux cas, la séquence d'instructions doit nécessairement faire

• Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui

• Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui

Écrivez un algorithme qui demande à l’utilisateur le nombre de CDs à acheter, qui

• Calcul de x à la puissance n où x est un réel non nul et n un entier positif ou

Exemple 1: lecture et écriture

Écrire un algorithme qui demande un nombre entier à

Algorithme Calcul_du_Carre Rôle : calcul du carre

Exemple 2: lecture et écriture

Écrire un algorithme qui permet d’effectuer la saisie d’un nom,

Exemple 4: tests imbriqués

⚫ Leprix de disques compacts (CDs) Variables unites : entier

Exemple 5: boucle Pour

⚫Jusqu’à présent, le seul moyen pour le faire, c’est de déclarer 20

•La saisie de ces notes nécessite 20 instructions lire(Ni).

cette façon n’est pas très pratique

⚫C’est pourquoi, les langages de programmation offrent la possibilité de

⚫Un tableau est un ensemble d'éléments de même type désignés par un

⚫Une variable entière nommée indice permet d'indiquer la position d'un

⚫La déclaration d'un tableau s'effectue en précisant le type de ses