You are on page 1of 50

Hind ELOUEDI

1
Plan
 Introduction
 Eléments de base d’un algorithme
 Structures alternatives et itératives
 Types de données composés
 Constructions modulaires: Procédures et fonctions
 Récursivité
 Conclusion

2
Introduction
 Définitions
 Algorithme: Un algorithme est une succession d'opérations ou d'actions qui, exécutée
sous un ordre défini à l'avance, résout une classe donnée de problèmes. Ces actions ou
opérations sont appelées aussi instructions.
 Algorithmique: C'est l'art de spécification, d'analyse et de conception des actions d'une
solution, suivies de l'écriture proprement dite de l'algorithme.
 Programme: C’est une succession ordonnée d’instructions, codées en un langage
compréhensible par la machine afin d’aboutir aux résultats recherchés.
 Types de traitement: Trois types d’actions:
 Actions simples: Lecture, écriture, affectation
 Actions décisionnelles: Permettent de définir les structures alternatives.
 Actions itératives: Permettent de définir les actions répétitives.
 Données: Les traitements s’appliquent à un ensemble de données qui peuvent être de
types différents (numériques, ensemble, caractères, logiques, ou autres types
structurés,…), de natures différentes (variables ou constantes). L’application des
traitements sur les données aboutira aux résultats attendus. 3
Introduction (2)
 Structure générale d’un algorithme

-- Auteur : Nom de l’auteur


-- Date d’écriture : Date d’écriture de l’algorithme
-- Fonction : Ce que doit faire l’algorithme En-tête
Algorithme Nom_algorithme
Constante
Liste des constantes avec leurs valeurs
Type
Partie
Liste des types personnalisés (tableau, structure…)
Déclarative
Variable
Liste des variables avec leurs types
Debut
Instruction 1
Instruction 2
Corps de
...
l’algorithme
Instruction n
Fin
4
Eléments de base
 Déclarations
 Constantes  Type: Zone de déclaration des types
Constante personnalisés:
identificateur = valeur
Exemple Type
Constante Nom_Type = Définition de type
a=5 Exemple
b = 2.5 Type
Tab = Tableau [1..10] de Entier -- Type tableau d'entiers
 Variables
Indice = 1..10 -- Type intervalle
Variable Etudiant = Enregistrement -- Type enregistrement
identificateur : Nom_Type -- NCE : Entier
Commentaire Nom : Chaîne[15] --Chaîne de caractères
Exemples Prénom : Chaîne[15]
Variable
Fin Enregistrement
a, b: Réel -- Coefficients de l’équation
x : Réel -- Solution de l’équation
age : Entier -- Age d’une personne
5
Eléments de base (2)
 Types de données simples
 Types numériques: Représentent l’ensemble des entiers (Z) et des réels (R).
 Notation: Entier, Réel
 Opérations arithmétiques: +, -, *, / (division réelle), Div (division entière), Mod (reste de division)
 Opérations de comparaison: , =, <, >, , 
 Type caractère: C’est l’ensemble des caractères imprimables et non imprimables
représentés entre deux apostrophes. On distingue plusieurs types de caractères :
 Les lettres alphabétiques (minuscules 'a'..'z' et majuscules 'A'..'Z').
 Les chiffres ('0'..'9').

 Les signes de ponctuation et les symboles ('.', ':', '!', '&', '@', '[', etc.).

 Les caractères nom imprimables (Escape, Return, Back Space, etc.).

Tous ces caractères sont ordonnés selon leurs codes ASCII (Americain Standard Code for Information
Interchange) variant de 0 à 255.
 Notation: Caractère

6
Eléments de base (3)
 Types de données simples (2)
 Type logique ou booléen: C’est une information qui peut avoir que la valeur Vrai ou
Faux. Les opérateurs booléens sont :
 Négation: notée Non (opérateur unaire).
 Conjonction: notée ET (opérateur binaire).
 Disjonction: notée OU (opérateur binaire).
 Notation: Booléen
 Propriétés:
 Commutativité : P et Q deux variables logiques, on a : P et Q = Q et P ainsi que: P ou Q = Q ou P
 Associativité : P, Q et R trois variables booléennes, on a :
 P et (Q ou R) = (P et Q) ou (P et R)
 P ou (Q et R) = (P ou Q) et (P ou R)
 Théorème de Morgan : P et Q deux variables logiques, on a :
 Non (P et Q) = Non P ou Non Q
 Non (P ou Q) = Non P et Non Q
7
Eléments de base (4)
 Types de données simples (3)
 Type scalaire énuméré: définit un ensemble ordonné de valeurs désignées par des
identificateurs. Ce genre de type doit être défini dans partie déclarative Type.
 Exemples: Jours de la semaine
Type Semaine = {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche}
Variable jour: Semaine
NB: Une variable jour de type Semaine peut prendre comme valeur : lundi, mardi, mercredi,
jeudi, vendredi, samedi ou dimanche
 Opérateurs: Les opérateurs applicables aux variables de ce type sont : les opérateurs de relations
et les opérateurs PRED, SUCC et ORD.
 Type intervalle: Ce type possède les propriétés d’un type scalaire discret ordonné (Entier,
Caractère et Scalaire énuméré). La définition d’un intervalle est décrite par deux
constantes Borne Inférieure et Borne Supérieure appartenant à un type scalaire discret
ordonné et tel que Borne Inférieure ≤ Borne Supérieure.
Exemples:
• Type mois = 1..12 -- cette déclaration est beaucoup plus précise que mois : Entier
• Jour_Ouvrable = lundi..samedi 8
Eléments de base (5)
 Actions (instructions) simples
 Affectation: Après avoir déclaré une variable, il faut pouvoir y ranger une valeur : C'est
l'action d'affectation notée par : "". Deux notions s'avèrent importantes à définir à ce
niveau et qui sont les notions de valeur et de variable.

nom_variable  expression
le nom d'une variable
destinée à recevoir une valeur Valeur à affecter à la variable
Symbole d'affectation

 Exemples
 A3 -- Initialisation de A (qui est déjà déclarée)
 B4 -- Initialisation de B
 CA*3+4–B -- Affectation de la valeur de l’expression après son évaluation à C

9
Eléments de base (6)
 Actions (instructions) simples (2)
 Ecriture: Nommée aussi Sortie ou Affichage, elle permet de communiquer ou visualiser
les résultats. La forme générale de cette instruction est la suivante :

Ecrire (expression_1, expression_2, ..., expression_n)

Ce sont des noms de données sous formes de variables, constantes ou d'expressions


On peut aussi afficher des messages qui seront représentés entre guillemets.

 Exemple: xa -- affecter à x la valeur de la constante a


Algorithme Ecriture y  15 -- affecter à y la valeur 15
Constante z  x + y -- affecter à z la somme de x et y
a=3 -- constante entière de valeur 3 Ecrire (x, y) -- affichage des valeurs de x et y
Variable Ecrire ("la valeur de z est : ", z)
x, y, z : Entier -- trois variables de type Entier -- affichage d’un message et de la valeur de z
Début Fin

Cet algorithme (Ecriture) fournira ces résultats : 3 15


la valeur de z est : 18 10
Eléments de base (7)
 Actions (instructions) simples (3)
 Lecture: nommée aussi instruction d’Entrée ou de Saisie, permet d'introduire une donnée
à partir d'un périphérique d'entrée (le clavier par exemple) et de la mettre dans la variable
cible. La forme générale de l'instruction de lecture est la suivante :
Lire (nom_variable_1, nom_variable_2, ..., nom_variable_n)

Les noms des variables destinées à ranger les valeurs prises sur le périphérique d'entrée

 Exemple: Algorithme permettant de lire un nombre, puis de calculer et d'écrire son carré.
Algorithme Carré
Variable
nombre, carre : Entier
Début
Ecrire ("Donner un entier:")
Lire (nombre)
carre  nombre * nombre
Ecrire ("Le carré de ", nombre, " est : ", carre)
Fin 11
Structures alternatives et itératives
 Structures alternatives
 Situation: On a besoin parfois de choisir entre deux ou plusieurs traitements selon la
réalisation ou non d'une certaine condition, d'où la notion de traitement conditionnel ou
alternatif (ou aussi décisionnel).
 Structure alternative à un choix:

Si (expression_logique) Alors
Instruction 1
...
Instruction n
FinSi

 Structure alternative à deux choix:

Si (expression_logique) -- Si l’expression logique a la valeur Vrai,


Alors bloc d'instructions1 -- le bloc d’instructions 1 est exécuté
Sinon bloc d'instructions2 -- dans le cas contraire, le bloc d’instructions 2 est exécuté
FinSi
12
Structures alternatives et itératives (2)
 Structures alternatives (2)
 Exemple: L’algorithme suivant permet de lire un nombre entier, puis de vérifier s'il est
pair ou impair.

Algorithme Pair_Impair
Variable
nombre : Entier
Début
Ecrire ("Donnez un nombre entier : ")
Lire (nombre)
Si (nombre Mod 2 = 0)
Alors Ecrire ("Le nombre ", nombre, " est pair")
Sinon Ecrire ("Le nombre ", nombre, " est impair")
FinSi
Fin

13
Structures alternatives et itératives (3)
 Structures alternatives (3)
 Structures alternatives imbriquées: (à plusieurs choix)

Si (expression_logique1)
Alors bloc d'instructions 1
Sinon
Si (expression_logique2)
Alors bloc d'instructions 2
Sinon
Si ...
FinSi

FinSi

14
Structures alternatives et itératives (4)
 Structures alternatives (4)
 Exemple: Calcul de remise: A partir d'un montant lu en donnée, on détermine un montant
net par application d'une remise de :
 5% si le montant est compris entre 2000 DT et 5000 DT.
 10% si le montant est supérieur à 5000 DT.
Algorithme Calcul_Remise
Variable
Montant, Remise : Réel Taux : Entier
Début
Ecrire ("Montant ? (en Dinars) :") Lire (Montant)
Si (Montant  2000)
Alors Taux  0
Sinon Si (Montant = 5000)
Alors Taux  5
Sinon Taux  10
FinSi
FinSi
Remise  Montant * Taux / 100
Montant  Montant – Remise
Ecrire ("Montant Net :", Montant)
Fin 15
Structures alternatives et itératives (5)
 Structures alternatives (5)
 Structure alternative Selon: (à plusieurs choix): Cette structure est utilisée pour
sélectionner une séquence possible d'instructions parmi plusieurs. Elle ressemble à la
structure Si...Alors...Sinon, mais elle est plus efficace lorsqu'il s'agit de tester la même
variable plusieurs fois pour des valeurs fixes. Sa forme se présente de la manière suivante:

Selon Sélecteur Faire


Liste_valeurs1 : instructions exécutées si Sélecteur est inclus dans Liste_valeurs1
Liste_valeurs2 : instructions exécutées si Sélecteur est inclus dans Liste_valeurs2
...
Liste_valeursN : instructions exécutées si Sélecteur est inclus dans Liste_valeursN
[Sinon : instructions à exécuter si rien ne correspond]
FinSelon

 Sélecteur : est un identificateur de variable ou une expression de type scalaire.


 Liste_valeurs1..Liste_valeursN : ce sont des valeurs servant aux tests. Elles peuvent être données sous forme de
constantes et/ou d'intervalles constants de type compatible avec le sélecteur.
 Liste_Valeurs1 (exemple 1 : 1..10 / exemple 2 : 1,3,5,7,9 / exemple 3 : 1..10, 20..30).
 [...] : bloc facultatif.
16
Structures alternatives et itératives (6)
 Structures alternatives (6)
 Exemple: Cet algorithme permet de saisir une date sous la forme jj, mm, aa et d'afficher le
nombre de jours du mois mm et le nombre de jours qui restent pour la fin de ce mois.
Algorithme Jour_Mois
Variable
jj, mm, aa, jtot, jreste : Entier
Début
Ecrire ("Donnez la date sous la forme JJ MM AA : ")
Lire (jj, mm, aa) -- on suppose que la date saisie par l'utilisateur est valide
Selon mm Faire
1, 3, 5, 7, 8, 10, 12 : jtot  31 -- Janvier, Mars, Mai, Juillet, Août, Oct., Déc.
4, 6, 9, 11 : jtot  30 -- Avril, Juin, Sept. et Nov.
Sinon : Si (aa Mod 4 = 0) -- mois de Février, année bissextile (février a 29 jours)
Alors jtot  29
Sinon jtot  28
FinSi
FinSelon
jreste  jtot - jj
Ecrire ("Le mois ", mm, " a ", jtot, " jours et il reste encore ", jreste, " jours pour sa fin")
Fin 17
Structures alternatives et itératives (7)
 Structures itératives
 Définition: Ces structures sont utilisées pour décrire les répétitions d'une action ou d'un
groupe d'actions. Toute répétition d'actions doit être finie. Ceci sera contrôlé à l'aide d'une
expression logique ou condition dont le changement de valeur provoque l'arrêt de la
répétition. Cette condition est dite condition de sortie ou d’arrêt du traitement itératif.
 Structure itérative : Répéter .. Jusqu’à

Répéter
Instruction 1
...
Instruction n
Jusqu'à (expression_logique)

 L'expression logique est testée après chaque exécution du traitement, si elle n'est pas vérifiée la boucle s'arrête.
 Si l'expression logique n'a pas été modifiée, on aura dans ce cas une boucle infinie.
 La séquence d'instructions est exécutée au moins 1 fois.
 Le nombre de répétitions dans la boucle n'est pas connu à l'avance.
18
Structures alternatives et itératives (8)
 Structures itératives (2)
 Exemple: On veut lire une note comprise entre 0 et 20. On pose la question suivante
"Donnez une note dans l'intervalle 0..20" jusqu'à ce que la réponse de l'utilisateur convienne.
Algorithme Saisie_Note
Variable
N : Entier
Début
Répéter
Ecrire ("Donnez une note dans l'intervalle 0..20 :") (1)
Lire(N) (2)
Jusqu'à (N  0 et N  20)
Fin
 Les mots Répéter et Jusqu'à encadrent les deux instructions (1) et (2) : ça signifie que ces deux instructions doivent
être répétées autant de fois qu'il est nécessaire, et ceci jusqu'à ce que la variable N prenne une valeur comprise entre 0
et 20.
 Notez bien que le nombre de répétition de ces deux instructions n'est pas indiqué explicitement. Il dépendra ici de la
valeur de N.

19
Structures alternatives et itératives (9)
 Structures itératives (3)
 Structure itérative : Tant Que .. faire

Tant Que (expression_logique) Faire


Instruction 1
Instruction 2
...
Instruction n
FinTantQue

 L'expression logique est testée avant chaque exécution du traitement itératif, si elle n'est pas vérifiée la boucle
s'arrête.
 Notez bien que si l'expression logique est fausse au départ, alors la boucle n'est jamais exécutée. Ce schéma
itératif pourra alors s’exécuter 0 fois.
 Le nombre de répétitions peut ne pas être connu à l'avance.

20
Structures alternatives et itératives (10)
 Structures itératives (4)
 Exemple: On veut afficher les multiple de 2 entre 10 et 77.

Algorithme Multiple2
Variable
i : Entier
Début
i  10
Ecrire ("Les multiples de 2 entre 10 et 77 sont : " )
Tant Que (i  77) Faire
Ecrire (i, " " )
ii+2 -- incrémentation du compteur i de 2
FinTantQue
Fin

21
Structures alternatives et itératives (11)
 Structures itératives (5)
 Structure itérative : Pour .. Faire

Pour Compteur de Deb à Fin [Pas Incrément] Faire


Instruction 1
...
Instruction n
FinPour

 Incrément : Valeur d'incrémentation de Compteur après chaque exécution de la boucle. Si aucune valeur n'est
indiquée, l'argument Pas prend par défaut la valeur 1 comme valeur d'augmentation.
 Le nombre de répétitions dans la boucle Pour .. Faire peut être calculé en faisant la différence entre la valeur initiale
et la valeur finale à laquelle on ajoute la valeur 1.

22
Structures alternatives et itératives (12)
 Structures itératives (6)
 Exemple: Supposons que l'on souhaite répéter 10 fois les instructions permettant de lire un
nombre entier et d'en écrire le carré.

Algorithme Carré
Variable
nombre, carre, cpt : Entier
Début
Pour cpt de 1 à 10 Faire
Ecrire ("Donner un entier:")
Lire (nombre)
carre  nombre * nombre
Ecrire ("Le carré de ", nombre, " est : ", carre)
FinPour
Ecrire ("Fin du programme")
Fin

23
Types de données composés
 Le type Tableau
 Définition: C’une structure de données composée, constituée d’éléments qui ont le même
type, appelé type de base. Le nom d'un composant du tableau utilise une ou plusieurs
valeurs d'indices appartenant à des types discrets spécifiés (Le type Entier en général). Un
objet tableau est caractérisé par le nombre d'indices, appelé dimension du tableau, les
bornes inférieure et supérieure de chaque indice, et le type des composants.
 Tableau unidimensionnel ou vecteur: (une seule dimension)

Constante
Binf = … --borne inférieure
Bsup = … --borne Supérieure
Type
Dimension = … --intervalle
Nom_Type1 = Tableau [Binf..Bsup] de Type_Base
Nom_Type2 = Tableau [Dimension] de Type_Base
Variable

T : Nom_Type1 --déclaration d’une variable T de type Nom_Type1


24
Types de données composés (2)
 Le type Tableau (2)
 Exemple: On veut saisir 30 moyennes comprises entre 0 et 20 et les stocker dans un
vecteur de Réel nommé Moy, puis afficher son contenu à l'écran, enfin calculer et afficher
la moyenne générale de ces moyennes.
Algorithme Moy_Générale
Constante
BSup = 30 Total  Total + Moy[i]
Type FinPour
Moyennes = Tableau [1..BSup] de Réel Ecrire("Voici les moyennes saisies : ")
Variable Pour i de 1 à Bsup Faire
Moy : Moyennes Ecrire (Moy[i])
i : Entier FinPour
Total, MoyG : Réel MoyG  Total/Bsup
Début Ecrire ("La moyenne générale est : ", MoyG)
Total  0 Fin
Pour i de 1 à Bsup Faire
Ecrire ("Saisir la moyenne N° : ", i)
Répéter
Lire (Moy[i])
Jusqu’à (Moy[i]  0 Et Moy[i]  20)
25
Types de données composés (3)
 Le type Tableau (3)
 Tableau bidimensionnel ou matrice: (deux dimensions)
Type
Dim1 = … -- type intervalle
Dim2 = … -- type intervalle
Nom_Type = Tableau [Dim1, Dim2] de Type_Base
Variable
T : Nom_Type -- déclaration d’une variable T de type Nom_Type

 Exemple: Comme le montre la figure suivante, la 1ère dimension, horizontale, représente


les lignes du tableau, et la seconde dimension, verticale, représente les colonnes.
Tableau à deux dimensions (30,5) nommé Note 2ème dimension
1ère dimension
1 2 3 4 5
1 10 12 11 15 9
2 8 13 12,5 12 10
3 15 12 13 10 17
… … … … … …
30 10,5 8,5 9 10 11,5
26
Types de données composés (4)
 Le type Tableau (4)
 Suite de l’exemple: Remplissage du tableau bidimensionnel Notes.
Algorithme Matrice_Notes
Constante
Etudiants = 30 Matieres = 5
Type
Tab_Notes = Tableau [1..Etudiants, 1..Matières] de Réel
Variable
Notes : Tab_Notes NumEtud, NumMat : Entier
Début
Pour NumEtud de 1 à Etudiants Faire
Ecrire ("Pour l'étudiant : ", NumEtud)
Pour NumMat de 1 à Matières Faire
Ecrire ("Saisir la note : ", NumMat)
Répéter
Lire (Notes[NumEtud,NumMat])
Jusqu’à (Notes[NumEtud,NumMat]  0 Et Notes[NumEtud,NumMat]  20)
FinPour
FinPour
Fin 27
Types de données composés (5)
 Le type Chaîne de caractères
 Définition: C’est une structure de données permettant de représenter toute séquence de
caractères :
 La longueur maximale que la chaîne est susceptible d'atteindre est de 255 caractères.
 Une chaîne est toujours entourée de guillemets ("chaîne").
 On peut avoir une chaîne de caractères vide ("") ayant une longueur égale 0.

Variable
Nom : Chaîne -- Nom est une variable de type chaîne de taille indéfinie
Adresse : Chaîne[50] -- Adresse est une variable de type chaîne de taille 50

 Remarques:
 La lecture, l'écriture et l'affectation sont des opérations applicables sur les variables de type Chaîne.
 Les opérateurs relationnels (=, , , , , ) s'appliquent aux chaînes de caractères. On peut, par exemple,
tester l'égalité ou l'inégalité de 2 chaînes de même longueur.
 Long (ch), est une fonction prédéfinie permettant de déterminer la longueur effective d’une chaîne.
 ch[i] permet d'accéder au ième caractère de la chaîne ch (avec i  [1, Long(ch)]).
28
Types de données composés (6)
 Le type Enregistrement
 Définition: Nommé aussi Article, c’est une structure de données constituée d’un nombre
fixe de composants nommés Champs qui peuvent être de types différents. La valeur d'un
objet article est une valeur composée, constituée des valeurs de ses composants. Chaque
champ a un nom et un type.

Type
Type_Article = Enregistrement
Champ1 : Type_Champ1
Champ2 : Type_Champ2

ChampN : Type_ChampN
FinEnregistrement
Variable
Art : Type_Article -- déclaration d’une variable Art de type Type_Article

 Remarque: L’accès à un champ se fait par l'identificateur de la variable article suivi d'un
point (.) puis l'identificateur du champ. Dans cet exemple, on fait : Art.Champ2 pour
accéder au champ2. 29
Types de données composés (7)
 Le type Enregistrement (2)
 Exemple: On veut saisir les données relatives à 30 étudiants (une classe), dont la structure
est représentée par les champs suivants:
 Nce : Numéro de la carte d’étudiant de type Entier (ou Chaîne[8]).
 NP : Nom et Prénom de l’étudiant de type Chaîne[25].
 DatNais : Date de naissance de l’étudiant de type Date qui est composée de :
 Jour : De type intervalle d’entier compris entre 1 et 31.
 Mois : De type intervalle d’entier compris entre 1 et 12.
 An : de type Entier.
 LieuNais : Lieu de naissance de l’étudiant de type Chaîne[15].
 Adr : Adresse de l’étudiant de type Chaîne[50].

30
Types de données composés (8)
 Le type Enregistrement (3)
 Suite de l’exemple:
Algorithme Infos_Etudiant
Constante Début
Taille = 30 Ecrire ("Saisie des informations relatives aux étudiants : ")
Type Pour i de 1 à Taille Faire
Date = Enregistrement Ecrire ("Etudiuant :", i)
Jour: 1..31 Ecrire ("Nce : ")
Mois: 1..12 Lire (T[i].Nce)
An: Entier Ecrire ("Nom et Prénom: ")
FinEnregistrement Lire (T[i].NP)
Etudiant = Enregistrement Ecrire ("Date de Naissance : ")
Nce : Entier -- ou bien Chaîne[8] Lire (T[i].DatNais.jour)
NP : Chaîne[25] Lire (T[i].DatNais.mois)
DatNais : Date Lire (T[i].DatNais.an)
LieuNais : Chaîne[15] Ecrire ("Lieu de Naissance : ")
Adr : Chaîne[30] Lire (T[i].LieuNais)
FinEnregistrement Ecrire ("Adresse : ")
Tab_Etudiant = Tableau[1..Taille] de Etudiant Lire (T[i].Adr)
Variable FinPour
T : Tab_Etudiant -- T est un tableau d'étudiants Fin
i : Entier -- compteur pour le nombre d’étudiants -- Il faut ajouter à cet algorithme tous les contrôles de saisie.
31
Constructions modulaires: Procédures et fonctions
 Notion de module
 La conception d'un algorithme procède en général par des affinements successifs : On
décompose le problème à résoudre en sous-problèmes, puis ces derniers à leur tour,
jusqu'à obtenir des problèmes "faciles à résoudre". Pour chaque sous-problème, on écrira
un module.
 La résolution du problème sera composée d'un algorithme principal et d'un certain
nombre de modules. L'algorithme principal a pour but d'organiser l'enchaînement des
modules.
 Un module est une unité fonctionnelle formée d'un bloc d'instructions, nommée et
éventuellement paramétrée, que l'on déclare afin de pouvoir l'appeler par son nom en
affectant s'il y a lieu des valeurs à ses paramètres. Les données fournies au module et les
résultats produits par ce dernier sont appelés des arguments ou des paramètres. Un
module peut être une procédure ou une fonction.

32
Constructions modulaires: Procédures et fonctions (2)
 Notions complémentaires
 Appel ou invocation: Il s'opère lorsqu'un module a besoin des services d'un autre. Il faut
distinguer alors entre le module appelant ou englobant (celui qui fait l'appel) et le
module appelé ou englobé (celui qui subit l'appel).
 Retour: Lorsque l'exécution du module appelé s'achève, on revient au module appelant
qui poursuivra son exécution à l'action qui se trouve juste après l'action d'appel : On dit
que le module appelé effectue un retour.
 Communication de données: À l'appel, des données sont communiquées de l'appelant à
l'appelé. Au retour, c'est l'inverse qui se produit : Les résultats passent de l'appelé à
l'appelant.
 Variables locales et variables globales: Tout module peut manipuler outre ses
paramètres, des variables intermédiaires nécessaires aux traitements : Ce sont les
variables locales qui ne seront pas accessibles en dehors du module où elles sont
déclarées, contrairement aux variables globales qui sont déclarées au niveau général et
qui sont accessibles à tous les modules appelés.
33
Constructions modulaires: Procédures et fonctions (3)
 Les procédures
 Définition: Une procédure est un module réalisant une action sur une partie des données
de l'algorithme. La structure d'une procédure est identique à celle d'un algorithme. Elle
est constituée d'un en-tête, d'une partie déclarative et d'un corps (instructions).
Procédure Nom_Procédure [(paramètres)]
-- Partie des déclarations
Début
--corps de la procédure
Fin

 Notion de paramètre:
 Les procédures appelante et appelée peuvent avoir besoin de se communiquer des informations. Cette
communication est établie à l’aide de paramètres qui vont apparaître à la fois dans l’instruction d’appel et
dans l’en-tête de la procédure appelée.
 Lorsque l’en-tête de la procédure contient des paramètres, ceux-ci portent le nom de paramètres formels (ou
paramètres fictifs). Ils sont représentés par des identificateurs sur lesquels la procédure va travailler et qui
sont locaux à la procédure.
 Lorsque l’instruction d’appel contient des paramètres, ceux-ci portent le nom de paramètres réels (ou
paramètres effectifs). Ils communiquent des informations à la procédure appelée, dans laquelle ils viennent se
substituer aux paramètres formels. 34
Constructions modulaires: Procédures et fonctions (4)
 Les procédures (2)
 Passage de paramètres: Dans un algorithme, les procédures paramétrées peuvent mettre
en œuvre deux modes de passage de paramètres formels:
 Paramètres par valeur (Call by Value) : Le paramètre effectif est une expression qui est évaluée
dans la procédure appelante. L’instruction d’appel donne au paramètre effectif la valeur résultant
de cette évaluation ; cette valeur est transmise à la procédure appelée dans laquelle elle prend la
place du paramètre formel. Le paramètre formel est toujours une variable locale à la procédure
appelée. Dans la structure de l’en-tête de la procédure appelée, le mot réservé Don précède les
paramètres formels.
 Paramètres par variable ou par référence ou par adresse (Call by Reference) : Le paramètre
effectif est ici une variable et non plus une expression. L’instruction d’appel mentionne les
variables transmises à la procédure appelée, dans laquelle elles sont repérées par les paramètres
formels. La procédure appelée travaille sur des variables formelles ayant les mêmes adresses que
les variables effectives. Dans la structure de l’en-tête de la procédure appelée, le mot réservé Var
(DonRes) précèdent les paramètres formels.

35
Constructions modulaires: Procédures et fonctions (5)
 Les procédures (3)
 Exemple: L’objectif de l’algorithme suivant est d’utiliser un paramètre par valeur, pour
doubler une valeur, puis d’utiliser un paramètre par adresse pour tripler une variable, et
enfin d’observer les résultats.
Algorithme DoubleTriple Procédure Triple (Var C : Entier)
Variable Début
A : Entier C3*C
Début Ecrire ("Variable triplée = ", C)
Ecrire ("Saisir un nombre entier:") Fin
Lire (A)
Ecrire ("Nombre = ", A)  Exécution:
Double (A) -- Appel de la procédure Double Saisir un nombre entier: 10
Ecrire ("Nombre = ", A) Nombre = 10
Triple (A) -- Appel de la procédure Triple Valeur doublée = 20
Ecrire ("Nombre = ", A) Nombre = 10 -- après l’appel valeur inchangée
Fin Valeur triplée = 30
Procédure Double (Don B : Entier) Nombre = 30 -- après appel la valeur a changé
Début
B2*B
Ecrire ("Valeur doublée = ", B)
Fin
36
Constructions modulaires: Procédures et fonctions (6)
 Les fonctions
 Définition: C’est un module chargé de calculer une valeur à partir d'une partie des
données ou des paramètres. Contrairement à la procédure qui est appelée de l'algorithme
principal à travers une instruction, la fonction est appelée à partir d'une expression de
l'algorithme principal, dans laquelle elle retourne une valeur d'un type précisé dans l'en-
tête du module appelé.

Fonction Nom_Fonction [(Paramètres)] : Type_Résultat


-- Partie déclarative
Début

Nom_Fonction  … -- (a)

Fin

37
Constructions modulaires: Procédures et fonctions (7)
 Les fonctions (2)
 Exemple 1: Calcul de la surface d’un cercle à travers une fonction.
Algorithme Calcul_Surface
Variable
Rayon, S : Réel
Début
Ecrire ("Saisir le rayon du cercle: ")
Lire (Rayon)
S  Surface (Rayon)
Ecrire ("Surface = ", S)
-- on peut utiliser directement appeler la fonction Surface
Ecrire ("Surface = ", Surface(Rayon))
Fin
Fonction Surface (Don R : Réel) : Réel
Constante
Pi = 3.14159
Début
Surface  Pi * R* R -- ou Retourner (PI * R * R)
Fin
38
Constructions modulaires: Procédures et fonctions (8)
 Les fonctions (3)
 Exemple 2: Déterminer le maximum dans une série de n nombres positifs, saisis par
l'utilisateur, en mettant en œuvre une fonction de calcul du maximum de 2 nombres réels.
Algorithme Maximum
Variable
i, n : Entier Fonction PlusGrand (Don X, Y : Réel) : Réel
Max, nb : Réel Début
Début Si (X  Y)
Max  0 Alors
Répéter PlusGrand  X
Ecrire ("Saisir le nombre d'éléments : ") Sinon
Lire (n) PlusGrand  Y
Jusqu’à (n >0) FinSi
Pour i de 1 à n Faire Fin
Répéter
Ecrire ("Saisir l'élément numéro ", i)
Lire (nb)
Jusqu’à (nb > 0)
Max  PlusGrand (Max, nb)
FinPour
Ecrire ("Maximum : ", Max)
Fin 39
Récursivité
 Définition: C’est un concept très puissant si on arrive à décomposer un
problème en un ou plusieurs sous-problèmes qui sont de même nature. Il
est de même quand on décompose un objet en groupes de composants qui
présentent les mêmes propriétés et qui ne contiennent qu'un sous-
ensemble de l'objet. Une notion est dite récursive si elle, entre, elle même
dans sa composition ou dans sa définition.
 Exemples:
 Les entiers naturels sont définis d’une manière récursive par deux règles:
 0 est un entier naturel.
 Le successeur d'un entier naturel est un entier naturel.
 La définition récurrente des suites mathématiques:
 U0 = 1
 Un = aUn-1 + b
 Les chaînes de caractères sont définies récursivement -Une chaîne de caractères est soit:
 Une chaîne vide, soit,
 Un caractère suivi d'une chaîne. 40
Récursivité (2)
 Exemple: La fonction factorielle définie par:
 0! = 1! = 1
 n! = n * (n – 1)!
 Explication: Cette expression ne fait que déplacer le problème de l’ordre n à l’ordre n-1,
sans le résoudre. Par bonheur, en faisant ainsi décroître l’ordre, on parvient à une relation
sans indétermination : 1! = 1 (ou éventuellement (0 ! = 1). Grâce à cette propriété, le
traitement récursif de la factorielle n’est pas un cercle vicieux. Son algorithme s’écrit:
-- Version récursive -- Version itérative
Fonction Factorielle (Don n : Entier) : Entier Fonction Factorielle (Don n : Entier) : Entier
-- Précond : n 0 -- Précond : n 0
Début Variable
Si (n  1) Resultat, i : Entier
Alors Début
Factorielle  1 Resultat  1
Sinon Pour i de 1 à n Faire
Factorielle  n * Factorielle (n-1) Resultat  Resultat * i
FinSi FinPour
Fin Factorielle  Résultat
Fin
41
Récursivité (3)

 Notions de base:
 Notion d’environnement:
 Il est formé par l'ensemble de données (variables et paramètres) utilisées par un module lors d'une exécution. Chaque
fois que le module est appelé récursivement, un nouvel environnement est généré, un nouvel ensemble de variables
locales et de paramètres est créé. Bien qu'elles portent le même nom que celles créées à l'appel précédent, leurs
valeurs sont différentes et on utilise toujours le dernier jeu de variables créé. Cet environnement est détruit lorsque
l'exécution prend fin.
 Si un module appelle un autre module sans que son exécution ne soit terminée, l'environnement du premier est
suspendu et il sera réactivé lorsque l'exécution du second sera terminée. L’ensemble des environnements existant
pour une exécution (suspendus ou actif) forme ce qu’on appelle une pile d’environnements.
 Exemple: L’appel de Factorielle (3) (n = 3), génère la pile d’environnements suivante:

n=1
n=2 n=2 n=2
n=3 n=3 n=3 n=3 n=3
Etat initial (a) (b) (c) (d) (e) Etat final

42
Récursivité (4)

 Notions de base (2):


 Terminaison: Les traitements engendrés par une définition récursive doivent être finis
pour que le calcul puisse se terminer. Tout appel récursif doit donc contenir une clause
conditionnelle telle que l'évaluation puisse dans certains cas se faire sans récursivité. Dans
le cas de la fonction Factorielle(n), la condition d’arrêt est : n ≤ 1.
 Valeur d’arrêt: C'est la valeur pour laquelle les appels récursifs s'arrêtent. Pour le cas de
Factorielle (n), la valeur d'arrêt est n = 1 (ou éventuellement n = 0).
 Profondeur:
 Dans la plupart des cas, la récursivité est appliquée à une valeur entière qui diminue d'une unité à chaque exécution.
Dans ce cas, si on considère fi cette valeur lors du premier appel et ft cette même valeur à la terminaison, on dit que la
récursivité est de profondeur (fi – ft).
 La profondeur indique le nombre de niveaux de récursivité, c’est à dire le nombre d’environnements qui peuvent être
suspendus en même temps. Par exemple, pour la fonction Factorielle (3), la profondeur est égale à 2.

43
Récursivité (5)
 Exemples de problèmes récursifs:
 Exemple 1: Suite de Fibonacci Fibo définie par:
 Fibo(0) = 0 et Fibo(1) = 1
 Fibo(n) = Fibo(n-2) + Fibo(n-1) pour n > 1
 Pour n = 4, on a l’exécution suivante: La valeur finale de retour est: 3

44
Récursivité (6)
 Exemples de problèmes récursifs (2):
 Suite de l’exemple 1: On remarque qu’il y a une redondance d’appels (de traitement), on
préfèrera alors la version itérative. Voici les deux versions:
-- Version itérative
Fonction Fibo (Don n : Entier) : Entier
Variable
-- Version récursive x, y, z, i : Entier
Fonction Fibo (Don n : Entier) : Entier Début
Début Si (n = 0 Ou n = 1)
Si (n = 0 Ou n = 1) Alors Fibo  n
Alors Sinon
Fibo  n x0 y1 i2
Sinon Tant Que (i  n) Faire
Fibo  Fibo (n – 1) + Fibo (n – 2) zx+y
FinSi xy
Fin yz
ii+1
FinTantQue
Fibo  z
FinSi
Fin
45
Récursivité (7)
 Exemples de problèmes récursifs (3):
 Exemple 2: Tour de Hanoï:
 Définition du problème: N disques sont empilés par ordre de diamètre décroissant (tous les disques sont de
diamètres différents) sur un piquet A. Deux autres piquets B et C peuvent recevoir des disques, à condition que
ceux-ci soient toujours empilés selon la même règle du diamètre décroissant. Le but du jeu est de transporter les N
disques du piquet A au piquet C, en utilisant éventuellement le piquet B, tout en respectant les deux règles
suivantes :
 Ne déplacer qu’un seul disque à la fois.
 Ne placer un disque que sur un disque de diamètre supérieur, ou un piquet libre.
 Paramétrage du problème:
 N : nombre de disques
 A, B, C : les piquets (départ, intermédiaire et arrivée).
 Recherche de la valeur d’arrêt: Si (N = 1) Alors « Déplacer un disque de A vers C » : Déplacer (A, C)
 Décomposition du cas général: Résoudre le problème pour N disques ne présente pas de difficulté si on sait le
résoudre pour (N-1) disques ; en effet, transporter les N disques du piquet A au piquet C, c’est:
 Transporter les (N-1) premiers disques de A vers B (C piquet intermédiaire), puis
 Déplacer le disque restant de A vers C, et enfin,
 Transporter les (N-1) disques de B vers C (A piquet intermédiaire).
46
Récursivité (8)
 Exemples de problèmes récursifs (4):
 Exemple 2: Tour de Hanoï (2):
 Procédure Hanoi:
Procédure Hanoi (Don n: Entier, Don A, B, C: Chaîne)
-- Précond : n  1
Début
Si (n = 1)
Alors
Ecrire ("Déplacer un disque de ", A, " vers ", C)
Sinon
Hanoi (n-1, A, C, B)
Ecrire ("Déplacer un disque de ", A, " vers ", C)
Hanoi (n-1, B, A, C)
FinSi
Fin

47
Récursivité (9)
 Exemples de problèmes récursifs (5):
 Exemple 2: Tour de Hanoï (3):
 Exécution: Dans ce qui suit, voici un exemple d’exécution de cette procédure pour : Hanoi (3, A, B, C)

 Le nombre de déplacements est une fonction du


nombre de disques, en effet :
 Si n = 0  nombre de déplacements = 0
 Si n = 1  nombre de déplacements = 1
 Si n = 2  nombre de déplacements = 3
 Si n = 3  nombre de déplacements = 7
 Si n = 5  nombre de déplacements = 31
 Si n = 8  nombre de déplacements = 255
 Si n = 10  nombre de déplacements = 1023
 ...
  n1  nombre de déplacements = 2n - 1

48
Conclusion

 Rappeler les concepts fondamentaux de l’algorithmique.


 Unifier les notations dans l’écriture des algorithmes.
 Etre capable d’écrire des algorithmes modulaires.
 Utiliser la récursivité pour la résolution de certains problèmes.

49
A Suivre…

50

You might also like