Algorithmique 2

FPSB
Prof A. Bessate
bessate@gmail.com

1
 DESCRIPTIF DU MODULE ALGORITMIQUEII

• Chapitre 1: Fonctions et procédures.

• Chapitre 2: La récursivité.
• Chapitre 3: Enregistrements et fichiers.
• Chapitre 4: La complexité.
• Chapitre 5: Preuves d’algorithmes.
VOLUME HORAIRE
 COURS: 30H
 TD: 18H
 Evaluation: 2H

2
Rappel : Algorithmique 1

3
 Qu’est ce qu’ un algorithme ?

Un algorithme est une suite finie

d’instructions à appliquer dans un ordre
déterminé à un nombre fini de données
pour arriver, en un nombre fini d'étapes,
à un certain résultat, et cela
indépendamment des données

4
 Pourquoi utiliser un algorithme ?

Un algorithme décrit ce qui doit faire

l’ordinateur pour arriver un but bien
précis. Ce sont les instructions qu’on
doit lui donner. Donc l’algorithme est un
moyen pour le programmeur de
présenter son approche d’un problème
donné à d’autres personnes, dans un
langage clair et compréhensible par l’être
humain.

5
 Définition d’un algorithme

C’est un pseudo-langage qui est

conçu pour résoudre les problèmes et
applications sans aucune contrainte due
aux langages de programmation et aux
spécificités de la machine. Ce pseudo-
langage sera ensuite traduit et codé dans
le langage de programmation désiré.

6
 Structure générale d’un algorithme

 Titre du Problème

 Déclaration des Objets

déclarations des constantes
déclarations des variables
déclaration des tableaux
déclaration des procédures et fonctions

 Manipulation Début

Actions

FIN

7
 Conception d’un algorithme
• Les étapes de conception d’un algorithme :

 Comprendre le problème;
 Identifier les données du départ(entrées) et celle(s)
qu’il faut obtenir(sorties);
 Structurer les données (variables ou constantes,
type...);
 Déterminer les transformations nécessaires à faire
pour obtenir les résultats
(traitements/développements);
 Présenter les résultats.

8
 Caractéristiques d’un algorithme

Un bon algorithme doit être

Lisibles(Compréhensible).
De haut niveau(être traduit en un
langage).
Précis(Pas de confusion).
Concis(ne doit pas dépasser une page).
Structuré(Parties facilement
identifiables).

9
 L’algorithme sous forme de texte
Algorithme Nom_de_algorithme
Variable /* Déclaration des variables */
• DEBUT
– Instruction 1
– Instruction 2
– …….
– …….
– Instruction n
• FIN
10
 Déclaration des variables
Pour exister une variable doit être déclarée,
c’est –à-dire que vous devez indiquer au
début de l’algorithme comment elle s’appelle
et ce qu’elle doit contenir. Les variables se
déclarent au début de l’algorithme, avant le
programme lui-même mais après le mot
« variables »
Variable
Variable1 :type
variable2,variable3,… :type

11
 Les types
• Les constantes: désignent des références à des
valeurs invariantes dans le programme
• Les entiers: nombres sans virgule, négatifs ou
positifs.
• Les réels: nombres à virgule, positifs ou négatifs.
• Les booléens: Pour déterminer si une affirmation
vraie ou fausse
• Les caractères: pour représenter un seul caractère.
• Les chaînes: ce sont une suite de caractères.
• Les tableaux: permettent de représenter un
ensemble de valeurs appartenant toutes au même
type.

12
13
14
15
 Opérateurs et calculs

Symbole d’affectation

Pour affecter une valeur à une variable, on écrit:

Variable Valeur

16
17
18
19
20
 Tests et conditions
• Algorithme Structure_Alrenative_1
• Variable x : entier
• Début
– Afficher("Saisir un entier x")
– Lire(x)
– Si(x > 0) alors
– Afficher("x est un nombre positif ")
– Finsi
• Fin

21
 Tests et conditions

• Algorithme Structure_Alrenative_2
• Variable x : Entier
• Début
– Afficher("Saisir un entier x ")
– Lire(x)
– Si(x > 0) alors
• Afficher("x est un nombre positif ")
– Sinon
• Afficher("x est un nombre négatif ou nul")
– Finsi
• Fin

22
 Tests et conditions
• Algorithme Maximum
• Variable
a ,b, max : Entier
• Début
– Afficher("Saisir deux entiers a et b")
– Lire(a, b)
– Si(a > b) alors
• max a
– Sinon
• max b
– Finsi
– Afficher ("le maximum de ",a , "et de ",b, "est : ", max)
• Fin

23
 Choix multiples

• Suivant Cas variable Faire

• Cas Valeur 1 : Actions 1; sortir
• Cas Valeur 2:Action 2; sortir
• …
• …
• Autre :Action par défaut
• Fin Suivant

24
 Les boucles

L’instruction pour:

<Initialisation>

Pour variable allant de valeur1 àvaleur2 faire

Bloc d’instructions

Fin Pour

25
 Les boucles
• Algorithme Factoriel
• Variable
N, i, Fact : Entier
• Début
• Afficher("Saisir une valeur entière N>0:")
• Lire(N)
Fact 1
Pour i allant de 1 à N Faire
Fact Fact*i
FinPour
• Afficher("Le factoriel de", N, "est :", Fact)
• Fin

26
 Les boucles

L’instruction Tant que:

<Initialisation>

Tant que Condition faire

Bloc d’instructions
actions
Bloc de contrôle

Fin Tant que

27
 Les boucles

• Variable
• i : Entier
• Début
• i 0 //Initialisation
• Tant que (i < 300) Faire
• Afficher("Bonjour tout le monde")
• i i+1
• Fin tant que
• Fin

28
 Les boucles

L’instruction faire jusqu’à:

<Initialisation>

Faire
Bloc d’instructions

Jusqu’à Condition

29
 Les boucles
Algorithme :Boucle3
Variable
i , y : Entier
Début
i 2
y 0
Faire
i i+1
y y+i
Afficher ("y = ", y)
Jusqu’à (i = 7)
Fin

30
 Les boucles
Algorithme: somme
Variable
N, S, i: Entier
Début
Afficher("Saisir une valeur entière positive:")
Lire(N)
S 0
i 0
Faire
i i+1
S S+i
jusqu’à(i>=N)
Afficher("La somme: S=", S)
FIN
31
 Tableaux : introduction
 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
32
 Tableaux

• 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.

33
 Tableaux
• 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)

• En pseudo code :
variable identificateur tableau[dimension] : type;

• Exemple :
variable notes tableau[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, …

34
 Tableaux
• Les tableaux à une dimension ou vecteurs :
variable tab tableau[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, car il contient 10

emplacements.
• 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]

35
 Tableaux

• Pour accéder au ième élément, on écrit tab[i-

1] (avec 0<=i<10)

• Selon les 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.
36
 Tableaux: remarques
• Il est possible de déclarer un tableau sans préciser au
départ sa dimension. Cette précision est faite
ultérieurement.
– Par exemple, quand on déclare un tableau comme
paramètre d'une procédure, on peut ne préciser sa
dimension qu'au moment de l'appel.
– En tous cas, un tableau est inutilisable tant qu’on n’a
pas précisé le nombre de ses éléments
• Un grand 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.

37
 Tableaux: accès et modification

• Les instructions 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).

38
Tableaux: Relation entre tableaux et boucles

• Les boucles sont extrêmement utiles pour

les algorithmes associés aux tableaux.
• Pour parcourir 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.
39
 Tableaux: exemple 1
• 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
notes tableau[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

40
 Tableaux: exemple 2
Le programme suivant comporte la déclaration d’un tableau de 20 réels (les notes
d’une classe), on commence par effectuer la saisie des notes, et en suite on calcul
la moyenne des 20 notes et on affiche la moyenne :
…
Constante Max =20 : entier
variables Notes tableau[Max], i, somme, n : entier
moyenne : réel
Début
écrire("entrer le nombre de notes :");
lire(n); /* saisir les notes */
pour i 0 à n-1 faire
écrire("entrer une note :");
lire(Notes[i]);
finpour
/* calculer la moyenne des notes */
somme 0;
pour i 0 à n-1 faire
somme somme + Notes[i] ;
finPour
moyenne = somme / n; /* affichage de la moyenne */
écrire("la moyenne des notes est :",moyenne)
Fin

41
 Tableaux: saisie et affichage
• Saisie et affichage des éléments d'un tableau :
Constante Max=200 : entier
variables i, n : entier
Notes tableau[max] : réel
début
écrire("entrer la taille du tableau :") ;
lire(n); /* saisie */
Pour i 0 à n-1 faire
écrire ("Saisie de l'élément ", i + 1);
lire (T[i] );
FinPour
/* affichage */
Pour i 0 à n-1 faire
écrire ("T[",i, "] =", T[i]);
FinPour
fin 42
 Tableaux: Initialisation
Le bloc d’instructions suivant initialise un à un
tous les éléments d'un tableau de n éléments :
InitTableau
début
pour i ← 0 à n-1 faire
tab[i] ← 0;
fpour
fin

43
Les fonctions

44
 Les fonctions
• Problème:
Dès qu’on commence à écrire des programmes, il
devient difficile d’avoir une vision globale sur son
fonctionnement.
 Difficulté de trouver des erreurs.
 Redondance
 ….
• Solution: Décomposer le problème en sous
problèmes

45
 Les fonctions

Fonction Maximum2(x : Réel, y : Réel) : Réel

Variable
max2 : Réel
DébutFonction
Si(x > y) alors
max2 x
Sinon
max2 y
Finsi
Retourne max2
FinFonction

46
 Les fonctions

Algorithme Maximum_de_trois_variable_1
Variable
a, b, c: Réel
max2, max3: Réel
Début
Afficher("Saisir3nombreréels:")
Lire(a, b, c)
max2 Maximum2(a, b)
max3 Maximum2(max2, c)
Afficher("Le maximum est = ", max3)
FIN

47
 Les fonctions

Fonction Maximum3(x : Réel, y : Réel, z: Réel) : Réel

Variable
max3 : Réel
DébutFonction
max3 Maximum2(Maximum2(x, y), z)
Retourne max3
FinFonction

48
Les fonctions

49
 Les fonctions

Une fonction est un sous programme particulier,

accomplissant une tâche particulière et qui ne
renvoie, dans l’algorithme principal, qu’un et un
seul résultat.

Pourquoi on l’utilise :

 Décomposer l’algorithme en de parties

appelées par le programme principal.

 Eviter la répétition inutile les mêmes

instructions plusieurs fois.
50
 Les fonctions

Une fonction est un sous-programme qui :

A un nom.
 Peut avoir des paramètres ou arguments.
 Retourne une valeur d’un certain type.
 Peut avoir besoin de variables.
 Est composé d’instructions.

Remarque :une fonction peut ne pas avoir de

paramètres.

51
Les fonctions

52
Les fonctions

53
Variables locales

54
Variables globales

55
 Appel d’une fonction

• L’appel: c’est l’utilisation d’une fonction

à l’intérieur d’une autre fonction ou de
l’algorithme principal.

Voici deux exemples :

var Nom_de_fonction(var1, var2, …..)

Afficher (Nom_de_fonction(var1, var2, …..))

56
 Arguments d’une fonction

•Les arguments servent à échanger des données

entre l’algorithme principal et les fonctions.
•Les arguments placés dans la déclaration d’une
fonction sont des variables locales du sous-
programme.
•Les arguments, placés dans l’appel d’une
fonction, contiennent les valeurs pour effectuer le
traitement.
•Le nombre d’arguments dans l’appel d’une
fonction doit être égal au nombre d’arguments
d’entrée. L’ordre et le type des arguments
doivent correspondre.
57
 Fonctions : cas des tableaux

•On propose d’écrire une fonction qui renvoie

l’indice de la valeur maximale d’un tableau.

•Écrire une fonction qui prend en argument un

tableau et permet le trier par ordre décroissant.

•Écrire l’algorithme principal.

58
 Fonctions : cas des tableaux
Fonction indice_val_max(T: tableau[ ]d’entiers, taille: Entier, k: Entier): Entier
Variable
i, imax, max2 : Entier
DébutFonction
max2 T[k]
imax k
Pour i allant de k+1 à taille-1 Faire
Si ( T[i]>max2) Alors
max2 T[i]
imax i
FinSi
FinPour
Retourne imax
FinFonction

59
Fonctions : cas des tableaux

60
Fonctions : cas des tableaux

61
 Procédure

• Dans certains cas, on peut avoir besoin de

répéter une tâche dans plusieurs endroits,
mais que dans cette tâche on ne calcule pas
de résultats ou qu’on calcule plusieurs
résultats à la fois. Dans ce cas on ne peut
pas utiliser une fonction, on utilise une
procédure.
• Une procédure est un sous programme
semblable à une fonction mais qui retourne
rien.

62
Procédure

63
Exemple de déclaration de procédure...

64
 exemple de programme...
Programme exemple3
variables entier1,entier2,entier3,min,max : Entier
fonction minimum2 (a,b : Entier) : Entier
fonction minimum3 (a,b,c : Entier) : Entier
procédure calculerMinMax3(E a,b,c: Entier; S min3,max3:Entier )
début
min3 ← minimum3(a,b,c)
max3 ← maximum3(a,b,c)
fin
début
écrire("Entrez trois entiers :");
lire(entier1) ; lire(entier2) ; lire(entier3);
calculerMinMax3(entier1, entier2, entier3, min, max)
écrire("la valeur la plus petite est ",min," et la plus grande est
",max)
fin
65
 La récursivité

Un sous-programme récursif est un sous-

programme qui peut s’appeler lui-même.
Il existe deux types de récursivité :
 Directe ou simple: le sous-programme
s’appelle lui-même.
 Indirecte ou croisée: deux sous-programmes
s’appellent l’un l’autre: le premier appelle le
second, qui appelle le premier, etc.

66
La récursivité

67
La récursivité

68
 La récursivité

 Une fonction récursive contient un ou

plusieurs paramètres qui évoluent lorsqu’ on
appelle la fonction jusqu’à satisfaire un test
qui nous permettra de sortir de la fonction.
 La récursivité solutionne un problème en
résolvant le même problème mais donne
une solution plus simple.
 Le processus de simplification se poursuit
jusqu’à l’atteinte d’un cas où la solution est
connue.

69
La récursivité

70
La récursivité

71
La récursivité

72
La récursivité

73
La récursivité

74
La récursivité

75
 La récursivité: Exemple

• Produit des éléments d’un tableau T.

• La taille du problème est liée à la taille du
tableau : n.
• Multiplier les éléments d’un tableau de
taille n revient à multiplier T[ind_initial]
avec le produit du reste (tableau de taille
n-1.
• Le produit s’arrête si on vérifie que
ind_initial=ind_final

76
La récursivité: Exemple

77
 La récursivité

Recherche dichotomique:
On suppose qu’on dispose d’un tableau
et on se donne un élément quelconque
et on cherche si cet élément est dans
le tableau ou non.

Attention: uniquement si le tableau est

déjà trié.

78
 La récursivité

A chaque étape :
• Tester si le tableau est vide (Arrêt des appels récursifs
avec échec)
• Calculer l’indice moyen (indice_max+indice_min)/2
• Comparer la valeur présente à l’indice moyen avec
l’élément recherché :
1) Si l’élément recherché est à l’indice moyen
(arrêt succès).
2) Si l’élément est supérieur à la valeur
tableau[indice_moyen] relancer la recherche
avec le tableau supérieur.
3) Sinon relancer la recherche avec le tableau
inférieur.

79
 La récursivité

Fonction Recherche_Dicho (T : tableau[ ] d’entiers, taille : Entier, x: Entier) : booléen

Variable
ind_min, ind_max, ind_moyen : Entier
trouvé : Booléen
• DébutFonction
• ind_min 0
• ind_max taille-1
• trouvé Faux
• Tant que (ind_min<ind_max) et (trouvé= Faux) Faire
• ind_moyen (ind_min+ind_max) div 2
• Si ( T[ind_moyen]=x) Alors
• trouvé Vrai
• Sinon
• Si ( T[ind_moyen]>x) Alors
• ind_max=ind_moyen-1
• Sinon
• ind_min=ind_moyen+1
• Finsi
• Finsi
• FinTantque
• Retourne trouvé
• FinFonction
80
La récursivité

81
 La récursivité

Fonction Recherche_Dicho(T: tableau[ ] d’entiers, ind_min: Entier, ind_max: Enteier ,x: Entier) :
booléen
Variable
ind_moyen : Entier
• DébutFonction
• Si (ind_min<=ind_max) alors
• ind_moyen (ind_min+ind_max) div 2
• Si ( T[ind_moyen]=x) Alors
• retourne Vrai
• Sinon
• Si ( T[ind_moyen]>x) Alors
• retourne Recherche_Dicho(T,ind_min,ind_moy-1,x)
• Sinon
• retourne Recherche_Dicho(T,ind_moy+1,ind_max,x)
• Finsi
• Finsi
• Sinon
• retourne Faux
• Finsi
• FinFonction

82
La récursivité

83
La récursivité: Exercices

84
La récursivité: Exercices

85
 La récursivité: Exercices
Fonction Différence(A,B,C : tableau[ ] d’entiers, a,b,n,m: Entier) : tableau d’entiers
/* n la taille de A et m la taille de B*. Cas des tableaux triés /
DébutFonction
Si a>=n Alors
retourne C
Finsi
Si A[a]=B[b] Alors
retourne Différence(A,B,C,a+1,b+1,n,m)
Sinon
Si A[a]<B[b] Alors
Taille(C) Taille(C)+1
C[Taille(C)-1] A[a]
Retourne Différence(A,B,C,a+1,b,n,m)
Sinon
Retourne Différence(A,B,C,a,b+1,n,m)
Finsi
Finsi
FinFonction
Remarque: L'appel initial est Différence(A,B,C,0,0,n,m) où C est un tableau ne
contenant initialement aucun élément (taille(C)=0).

86
 La récursivité Terminale : Exemple 1
Fonction Fact_T( n : Entier, k : Entier ) : Entier
/* le nombre kest un accumulateur */
DébutFonction
Si( n = 0) Alors
Retourne k
Sinon
Fact_T( n-1, n*k)
Finsi
FinFonction

/* Appel initial est Fac_T(n,1) */

87
La récursivité Terminale : Exemple 2

88
 Structures et enregistrements

La faculté poly disciplinaire Sidi Bennour organise les

informations concernant la filière IMA-S3 dans une liste
identique à la suivante :

89
 Structures et enregistrements

Problème: Le chef de filière veut créer un

programme permettant la saisie et le
traitement de cette liste sachant qu’elle
comporte au maximum 100 étudiants.
 Donnez la structure de données nécessaire
pour les objets à utiliser.
 Donnez une déclaration algorithmique de ces
objets.

90
Structures et enregistrements

91
Structures et enregistrements

92
Structures et enregistrements

93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
Les fichiers

137
138
139
140
141
 La complexité

Le temps d’exécution dépend de

 Le problème à résoudre
 La taille des données
 L’algorithme de résolution
 L’expertise du programmeur
 L’habilité du programmeur
 La rapidité de la machine
 Le langage de programmation
 Le compilateur

142
 La complexité

 Dans ce cours nous intéressons au coût des

actions résultant de l’exécution d’un algorithme, en
fonction de la taille des données traitées.
 Ceci nous permet de comparer des algorithmes
traitant le même algorithme.
Définition (Complexité)
 La complexité d’un algorithme désigne le nombre
d’opérations fondamentales ( affectation,
comparaison, opérations arithmétiques, …).
 La complexité s’exprime en fonction de la taille n
des données.

143
144
145
 La complexité

Mesure de la complexité
• Le choix de l’unité de mesure ne dépend pas de la nature
précise des données mais de leur taille n.
• On désigne par C(n) le nombre d’opérations effectuées pour
exécuter un algorithme donné dont la taille de données est n.
• C(n)=O(f(n)) : " Complexité en f(n)"
Généralement la fonction f est une combinaison de polynômes,
logarithmes, ou exponentielle
• C(n)=O(f(n)) : " Complexité en f(n)" signifie que le nombre
d’opérations effectuées est borné K*f(n) lorsque n tend
vers l’infini, c’est-à-dire, Il existe K>0 et n0 telles que pour tout n0
n > n0, C(n)<K*f(n).

146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171