COURS ALGOgithmique et programmation ofppt.ppt

Algorithmique et Programmation

Cours d'algorithmique
3
Notion d'algorithme
= Description d'un processus de résolution d'un
problème bien défini
= Succession d'actions qui, agissant sur un ensemble de
ressources (entrée), fourniront la solution (sortie) au
problème
 Comment faire pour l'obtenir ?
Énoncé Réflexion Programme
Résolution Codage

4
Intérêt de l’algorithmique
 Faire la conception détaillée dans un langage
algorithmique, indépendant des langages de
programmation, et compréhensible par des
informaticiens qui ne sont pas des développeurs ;
 Préparer la phase de test.

5
Les étapes d’un algorithme
 Préparation du traitement
 Données nécessaires à la résolution du problème
 Traitement
 Résolution pas à pas, après décomposition en sous-
problèmes si nécessaire.
 Édition des résultats
 impression à l’écran, dans un fichier, etc.

6
Un premier algorithme
Algorithme CalculDuCarré
{Cet algorithme calcule le carré d’un nombre}
Variables unNombre, sonCarré: entiers
{préparation du traitement} {déclarations: réservation d'espace-
mémoire}
Début
unNombre <- 5
{traitement : calcul du carré}
sonCarré <- unNombre×unNombre
{présentation du résultat}
Fin

7
Variables
 Fonction : Instruction permettant de réserver de l’espace
mémoire pour stocker des données (dépend du type de ces
données : entiers, réels, caractères, etc.)
 Déclaration de variable:
 Exemples :
Variables val, unNombre: entiers
nom, prénom : chaînes de caractères

8
Types des variables
 Pour être utilisée par un ordinateur, elle doit
souvent être typée :
- entier : les entiers de -32 768 à 32 767
- réel :
- 3,40x1038
à -1,40x1045
pour les valeurs négatives
- 1,40x10-45
à 3,40x1038
pour les valeurs positives
- caractère (‘a’, ‘b’, …) ;
- chaînes de caractères ( "bonjour" ).
- Etc.…

9
Remarques
Lorsque l’on déclare une variable, on ne lui donne pas de valeur.
On ne fait qu’indiquer au processeur le nom et le type des variables.
Le choix des noms de variables est arbitraire mais devrait toujours
refléter ce que représente les valeurs qu’elles contiennent.
Le contenu d’une case mémoire peut être modifié au cours de
l’exécution d’un programme mais pas le type de valeur qu’elle
contient.
Les déclaration sont faites à l’intérieur d’un programme donné.
Lorsque le programme se termine le nom, le type et la valeur
contenue dans les cases mémoire disparaissent.

10
Affectation
 Fonction : Instruction permettant
d’attribuer à la variable identifiée par
l’élément placé à gauche du symbole la
valeur de l’élément placé à droite de ce
symbole.

11
Exemple d’affectation
total
x2
y
entier
réel
réel
.
.
.
.
.
.
Après la déclaration
entiers: total
réels: x2,y
la mémoire ressemble à la figure
suivante:
45
55.5
-35.33
total
x2
y
entier
réel
réel
.
.
.
.
.
.
Si par la suite le processeur exécute
les instructions suivantes:
total <- 45
x2 <- -35.33
y <- 55.5
La mémoire devient:

12
Affectation

13
Constantes
 Fonction: Instruction permettant de réserver de
l’espace mémoire pour stocker des données dont la
valeur est fixée pour tout l’algorithme.
 Déclaration de la constante:
 Exemples:
Constantes (Max : entier) 25
(Min : entier) 10

14
moyenne
note1
note2
réel
entier
entier
.
.
.
.
.
.
Exemple: calcul de la moyenne
note3
note4
entier
entier
Après les déclarations suivantes,
Réels: moyenne
Entiers: note1, note2, note3, note4
la mémoire ressemble à la figure
ci-contre

15
95
moyenne
note1
note2
réel
entier
entier
.
.
.
.
.
.
Calcul de la moyenne (suite)
Après les instructions d’assignation
suivantes
note1 <- 75
note2 <- 100
note3 <- 88
note4 <- 95
La mémoire devient:
note3
note4
entier
entier
88
75
100
Remarque: la variable moyenne est toujours indéfinie puisqu’aucune valeur n’y
a été assignée.

16
95
moyenne
note1
note2
réel
entier
entier
.
.
.
.
.
.
moyenne = ( note1 + note2 + note3 + note4 ) / 4
note3
note4
entier
entier
88
75
100
Pour calculer la moyenne de ces 4 valeurs et mettre le résultat dans la variable moyenne
le processeur doit exécuter l’instruction suivante:

17
95
moyenne
note1
note2
réel
entier
entier
.
.
.
.
.
.
( note1 + note2 + note3 + note4 ) / 4
( 75 + 100 + 88 + 95 ) / 4
( 175 + 88 + 95 ) / 4
( 263 + 95 ) / 4
358 / 4
89.5
2) Le résultat est ensuite déposé dans la case
mémoire associée à la variable moyenne.
moyenne <- 89.5
note3
note4
entier
entier
88
75
100
1) Le processeur évalue d'abord la partie de gauche:
89.5

18
Liste des variables:
Réels: moyenne
Entiers: note1, note2, note3, note4
Instructions:
note1 <- 75
note2 <- 100
note3 <- 88
note4 <- 95
moyenne <- (note1 + note2 + note3 + note4 ) / 4
La séquence d'instructions nécessaires au calcul de la moyenne est donc:
Remarque: Les instructions sont toujours exécutées de façon séquentielle
par le processeur.

19
Lecture et écriture
 Saisir des données en provenance du clavier :
Algorithme moyenne
Début
variables n, somme, moyenne : réel
Lire n
somme <- ...
moyenne <- somme / n
Écrire n
Fin
 Afficher des données sur un périphérique
(écran, imprimante, disque dur)

20
Comparez
réels: moyenne
entiers: note1, note2, note3, note4
note1 = 75
note2 = 83
note3 = 79
note4 = 96
moyenne = note1 + note2 + note3 + note4 / 4
réels: moyenne
entiers: note1, note2, note3, note4
lire note1 note2 note3 note4
moyenne = note1 + note2 + note3 + note4 / 4
afficher moyenne
Ne calcule la
moyenne que
de ces 4
valeurs
particulières
Calcule la
moyenne de
n'importe
quelle
valeurs

22
Les structures de contrôle 1/3
Instruction conditionnelle: Il est possible de demander à
l’ordinateur d’exécuter une instruction (ou une série
d’instructions) seulement si une certaine condition est
satisfaite.
Forme générale:
si (condition) alors
{instructions exécutées si la condition est vrai}
sinon
{instructions exécutées si la condition est fausse}

23
 Les conditions peuvent être du type
- <expression arithmétique>
- <symbole de comparaison>
- <expression Booléen>
 les symboles de comparaisons sont :
= , < , > , <= , >= , <> ou #

24
Exemple 1
Début
variable : note = 18: entier;
si (note >= 17) alors
Ecrire (" vous etes excellent " )
Finsi
Fin

25
Exemple 2
Début
si (note >= 17) alors
{
Ecrire ( " votre note est “, note)
}
Finsi
Fin

26
Les conditions composées
si (condition1) et (condition2) alors instructions

27
Exemple 3
Début
si (note >= 17) && (absence <=3) alors
{
Ecrire ( " votre note est “, note)
}
Finsi
Fin

28
Les structures de contrôle
(Si..Sinon Si )
si (condition) alors
instructions
sinon si (condition) alors
instructions
sinon
instructions

29
Exemple 4
Début
Variables A,B : entiers
Ecrire ("Entrez deux nombres entiers :")
Lire A , B
Si (A > B)
Ecrire (A, " est plus grand que " ,B )
Sinon Si (A < B)
Ecrire ( A, " est plus petit que ",B )
Sinon
Ecrire ( A , " est égal à " , B )
Fin

30
 Les choix peuvent avoir un degré quelconque
d’imbrication.

32
Itération à bornes non définies
 Lorsque les bornes ne sont pas
connues, il existe deux types de
boucles :
- Boucle TantQue ... Faire ...
- Boucle Repeter ... Jusqu‘à ...

33
La boucle TantQue
 Fonction : répéter une suite d’instructions
tant qu’une condition est remplie
 Syntaxe :
TantQue < Expression logique (vrai) > Faire
Instructions
Fin TantQue
 Remarque : si la condition est fausse dès le
départ, le traitement n’est jamais exécuté

34
Exemple
Algorithme CalculLeTotal
{Cet algorithme fait la somme des données qu’il saisit, arrêt à la lecture de -1)
constante (STOP : entier) ← -1
variables val, totalValeurs : entiers
Début
totalValeurs ← 0
Écrire ("Donnez une valeur, " , STOP, " pour finir.")
Lire (val)
TantQue val ≠ STOP faire
totalValeurs ← totalValeurs + val
Écrire ("Donnez une autre valeur, " , STOP, " pour finir.")
Lire (val)
Fin Tantque
Écrire ("La somme des valeurs saisies est " , totalValeurs)
Fin

35
Sémantique de la boucle tant que
Lire (val)
TantQue val ≠ STOP faire
totalValeurs ← totalValeurs + val
Écrire ("Donnez une autre valeur, " , STOP, " pour finir.")
Lire (val)
Fin Tantque

36
La boucle Répéter ….Jusqu’à
 Fonction: exécuter une suite
d’instructions au moins une fois et la
répéter tant qu’une condition est remplie
 Syntaxe :
Répéter <séquence d'instruction>
Jusqu’à < Expression logique (vrai) >

37
Exemple
Algorithme Essai
{Cet algorithme a besoin d’une valeur positive non nulle}
variables valeur : entier
Début
Répéter
Écrire ("Donnez une valeur positive non nulle : ")
Lire (valeur)
Jusqu’à valeur <= 0
Écrire ("La valeur positive non nulle que vous avez saisie est ")
Lire ( valeur )
… {traitement de la valeur saisie}
Fin

38
Boucle à bornes définies
 Dans le cas d'une boucle à bornes
définies, nous connaissons le nombre
d'itérations à effectuer, grâce aux valeurs
des bornes minimum et maximum fournies
dans la définition de la boucle.

39
La boucle Pour
 Fonction: répéter une suite d’instructions
un certain nombre de fois
 Syntaxe :
Pour variable Allant de valeur initiale à valeur finale
Faire <séquence d'instruction>

40
Exemple
Algorithme CalculLeTotal
variables nbVal, cpt : entiers
valeur, totalValeurs : réels
Début
Écrire ("Combien de valeurs voulez-vous saisir ?")
Lire (nbVal)
totalValeurs ← 0
Pour cpt Allant de 1 à nbVal faire
Écrire ("Donnez une valeur :")
Lire (valeur)
totalValeurs ← totalValeurs + valeur
finPour
Écrire ("Le total des ", nbVal, "valeurs est " ,Valeur )
Fin

41
Les champs de la boucle POUR
Pour variable Allant de valeur initiale à valeur finale
[PAS Valeur du pas]
Faire <séquence d'instruction>

42
Sémantique de la boucle pour
 Implicitement, l’instruction pour:
 initialise une variable de boucle (le compteur)
 incrémente cette variable à chaque pas
 vérifie que cette variable ne dépasse pas la borne
supérieure
 Attention :le traitement ne doit pas modifier
le compteur

43
Pour et TantQue – Comparaison
 Implicitement, l’instruction Pour :
- initialise un compteur
- incrémente le compteur à chaque pas
- vérifie que le compteur ne dépasse pas la borne supérieure
 Explicitement, l’instruction TantQue doit :
- initialiser un compteur
- incrémenter le compteur à chaque pas
- vérifier que le compteur ne dépasse pas la borne supérieure

44
Choisir Pour.. TantQue.. Répéter..

45
Le problème d’une boucle : il faut en sortir!
 Quelque chose dans la suite d’instructions B
doit amener A à prendre la valeur Faux.
 La suite d’instructions B doit modifier au
moins une variable de l’expression logique A
 (mauvais) exemple :

47
Structures de données
 Lorsque l’on utilise un grand nombre de valeur
stockées sous forme de variables l’écriture d’un
algo devient laborieuse.
 Exemple : calculer la moyenne des notes obtenues au partiel d’algo par
les 24 étudiants de STI 1ère année :
Moy = (N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9 + N10 + N11+ N12 + N13 +
N14 + N15 + N16 + N17 + N18 + N19 + N20 + N21 + N22 + N23 + N24 ) / 24
 Que faire si le nombre de variables est 100,1000
ou plus ?

48
 On introduit donc la notion de structures de
données.
 De telles structures sont définies dans le
seul but de stocker des données.
 Chacune a ses spécificités et est adaptée à
un type de donnée mais surtout aux
traitements que l’on va y appliquer.

49
Les tableaux
 Un tableau est un ensemble ordonné et
homogène de valeurs :
- ordonné car les cases mémoires composant un tableau sont numérotés
- homogène car un tableau ne peut avoir que des valeurs du même type.
 Avec un indice commençant à 0, les cases d’un
tableau de N éléments sont numérotés de 0 à N-1.

50
Exemples d'applications
 Ensemble de valeurs entières, réelles,
booléennes,....
 Ensemble de noms (type chaîne)
 Ensemble de caractères (type caractère)
 Ensemble d'ouvrages

51
Définition d’un tableau
 On définit un tableau par:
 Son nom
 Le nombre de ses dimensions
 Sa taille
 Le type de données qu’il contient

52
Les tableaux à une dimension
 Déclaration :
<TypeSimple> <NomTableau>[<Dimension>];
 Exemples:
 int A[25];
 int C[10];
 char D[30];

53
Initialisation et réservation
 Initialisation :
 int A[5] = {10, 20, 30, 40, 50};
 float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
 int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
 Réservation automatique :
 int A[] = {10, 20, 30, 40, 50};

54
Accès aux éléments
 En déclarant un tableau par:
int A[5];
 On peut accéder à ces élément par :
A[0], A[1], ... , A[4]
 Attention aux indices

55
Exercice
 Comment saisir les éléments d’un tableau
de taille N ?

56
Affichage et affectation
 Affichage :
Pour I Allant de 1 à N faire
écrire A[I]
finpour
 Affectation :
Pour I Allant de 1 à N faire
écrire A[I]
finpour

57
Tableaux à deux dimensions
 Déclaration :
<TypeSimple> NomTabl>[<DimLigne>][<DimCol>];
 Exemples:
 int A[10][10];
 float B[2][20];
 int C[3][3];
 char D[15][40];

58
Initialisation et réservation
 Initialisation :
int A[3][10] = { { 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};
 Réservation automatique :
int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};

59
Accès aux éléments
 Accès à un tableau à deux dimensions en C
<NomTableau>[<Ligne>][<Colonne>]
 Attention aux indices

60
Exercice
 Comment saisir les éléments d’un tableau à
deux dimensions de taille N*M ?

61
Affichage
 Affichage du contenu d'un tableau à deux dimensions
/* Pour chaque ligne */
Pour I Allant de 1 à L faire
Pour J variant de 1 à C faire
écrire A[I,J]
finpour
/* Retour à la ligne */
écrire
Fin pour

62
Recherche dans un tableaux
 Recherche d’un élément dans un tableau
 Technique de flag
 Recherche dico

63
Exercices

64
Exercice 1

65
Exercice 2

66
Exercice 3

67
Exercice 4

68
Trier
 Trier, c'est ordonner des éléments en
fonction d'une certaine clé (valeur)
 Nous verrons comment trier les éléments
d'un tableau
 Tri par insertions
 Tri par permutations (tri-bulle)
 Tri rapide (quick sort)

69
Les algorithmes de Tri
 Tri par sélection.
 Tri par insertion.
 Tri par bulle.
 Tri par fusion.
 Tri rapide.

70
Tri par insertion
 On trie en prenant chaque élément du tableau, de
gauche à droite
 On le compare avec la partie déjà triée (à sa
gauche) pour trouver sa position
 On décale les éléments plus grands à droite pour
créer un "trou“
 On insert l'élément dans le "trou"

71
Tri par insertion
 Le premier élément est toujours déjà trié
 78 est plus grand que 14, il est trié
 54 est plus petit que 78, il faut les déplacer

72
Tri par insertion
 23 est plus petit que 54, il faut déplacer 54

73
Tri par insertion
 est plus petit que 54, il faut déplacer 54

74
Tri par insertion
 5 est tout au bout du tableau, il est trié

75
Tri par insertion
 Tout le tableau est trié

76
Pseudo-code
 Pour chaque position du tableau i (sauf la
première), répéter
 Mettre l'élément i dans une variable temporaire x
 Initialiser un indice j à la position précédente à i
 Tant que
 1. j ne dépasse pas la borne inférieure du tableau
 et
 2. x est plus petit que l'élément à la position j
 Faire
 déplacer l'éléments j du tableau un crans à la droite
 décrémenter j
 Fin Tant que
 Mettre x à la place ainsi libérée

77
Algorithme de Tri par insertion
Pour i Allant de 1 à n - 1 Faire
temp tableau[i];
j i - 1;
TantQue (j >= 0) & (temp < tableau[j]) Faire
tableau[j+1] tableau[j];
j j-1
FinTantQue
tableau[j+1] temp
FinPour

78
Tri par insertions en action
 Voir Applet

79
Tri par bulle
 Principe
- Comparaison deux à deux des éléments du
tableau (de gauche à droite ou de droite à
gauche) et permutation si nécessaire
- A chaque itération, un nouvel élément est placé
dans sa position définitive

80
 14 et 78 sont en ordre, respectivement
 78 est plus grand que 54, permutation

81
 78 est en place, fin du 1er tour

82
 54 est plu grand que 23, permutation

83
 66 est en place, fin du 2e tour
 14 et 23 sont en ordre, repectivement

84

85

86
 14 est en place, fin du 5e et dernier tour
 Fin de l'algorithme

87
Pseudo-code
 Pour chaque position du tableau (sauf
la première), répéter
 Pour chaque position du tableau, de la
première à l'avant-dernière non triée,
répéter
 Si l'élément courant est plus grand que sont
suivant
 Les permuter (utilisation d'une variable temporaire)

88
Algorithme de Tri par bulle
Pour i Allant de 1 à n-1 Faire
Pour j Allant de 0 à n-i-1 Faire
Si tableau[j] > tableau[j+1] Alors
temp tableau[j+1];
tableau[j+1] tableau[j];
tableau[j] temp
FinSi
FinPour
FinPour

89
Tri par insertions en action
 Voir Applet

91
Programmation modulaire
 Comment traiter les problèmes trop
complexes pour être appréhendés en un
seul bloc ?
 Programmation modulaire.
 Types de modules :
- Les procédures
- Les fonctions
 Un module est appelé (exécuté) quand son
nom est invoqué.

92
Exemple

93
Structure de blocs
 Définition de sous-programmes induit sur le programme
une structure de blocs, chaque bloc correspondant à un
sous-programme, l'imbrication des définitions engendre
une hiérarchie de niveaux.

94
Les fonctions
 Les fonctions sont des sous-programmes admettant
des paramètres et retournant un seul résultat.
 Déclaration d’une fonction :
Fonction nom de la fonction (paramètre(s) de la fonction) : type de la valeur retournée
Variable locale 1 : type 1; . . .
Début
instructions de la fonction avec au moins une fois l’instruction
retourner
Fin

95
Définition de la fonction
 On définit une fonction, c’est-à-dire le traitement
qu’elle effectue, généralement dans les lignes qui
suivent sa déclaration.
 Une fonction doit impérativement :
- retourner une valeur ;
- faire en sorte que cette valeur soit bien du
type spécifié dans sa déclaration.

96
Exemple de fonction
fonction abs (unEntier : Entier) : Entier
début
si unEntier > 0 alors
retourner unEntier
sinon
retourner -unEntier
finsi
fin

97
Paramètres formels (1)
 Les arguments utilisés lors de la définition
d’une fonction sont appelés paramètres
formels
 Leur rôle est de permettre, au sein du
corps de la fonction de décrire ce qu’elle
doit faire.

98
Paramètres formels (2)
 Le corps de la fonction doit utiliser les
arguments (ou paramètres formels).
 Exemple :
Fonction somme(x : réel, y : réel, z : réel) : réel
Début
retourner x+y+z
Fin

99
Appel de la fonction
 Une fois la fonction définie, il est possible de
l’appeler n’importe où dans le programme
principal.
 L’appel doit respecter :
- le type des arguments de la fonction
- leur nombre.
 Au niveau du programme principal, on appelle
ces arguments les paramètres effectifs

100
Exemple – Appel d’une fonction
 L’allure générale d’un algorithme incluant des
fonctions est la suivante :
Algorithme Exemple1
fonction abs (unEntier : Entier) : réel
Variable valeurAbsolue : réel
Début
Si unEntier > 0 Alors
valeurAbsolue ← unEntier
Sinon
valeurAbsolue ← -unEntier
finsi
retourner valeurAbsolue
fin
Variable a : Entier, b : réel /* var. du prog. Principal */
Début /* Début de programme principal */
écrire("Entrez un entier :")
lire(a)
b ← abs(a)
écrire("la valeur absolue de ",a," est ",b)
fin

101
Attention!
 Il n’est pas possible de changer la valeur d’un paramètre effectif. Par
exemple, ici, la fonction ne modifie en rien la valeur de x :
Algorithme calcul :
Fonction fois2(a : réel) : réel
Début
a ← a*2
retourner (a)
Fin
Variable x : réel
Début
x ← 3
Écrire fois2(x)
// x param. eff. passé par valeur
Écrire(x)
Fin
Exécution
6
3

102
Les procédures
 Une procédure est une fonction qui ne renvoie
aucune valeur. Elle effectue seulement un
traitement particulier.
 Déclaration d’une procédure :
Procédure nom de la fonction (paramètre(s) du procédure)
Variable locale 1 : type 1; . . .
Début
instructions de la procédure
Fin

103
Les procédures
 Les procédures se définissent et s’utilisent
comme des fonctions (ce sont en fait des
fonctions particulières de type vide) :
- Déclaration avec paramètres formels,
- Utilisation de variables locales,
- Appel avec paramètres effectifs
- Impossibilité de modifier les paramètres effectifs.

104
Exemple 1
Algorithme VariablesLocales(input,output);
var nombre1, nombre2: entier {variables globales}
Procédure add;
Variable resultat: entier {variable locale à "add"}
Début
resultat ← nombre1 + nombre2;
writeln('La réponse est: ',resultat)
Fin
Début {programme principal}
Écrire('Entrez les 2 nombres entiers à additionner');
Lire(nombre1,nombre2);
add
Fin

105
Exemple 2
Algorithme AddNombres
Procédure calcReponse(premier,second : entier);
Variable résultat : entier; {variable locale à calcReponse}
Début
resultat ← premier + second;
Écrire ('La réponse est ', resultat )
Fin
Variable nombre1,nombre2: entier; {variables globales}
Début {programme principal}
Écrire ('Entrez les 2 nombres à additionner');
Lire (nombre1,nombre2);
calcReponse(nombre1,nombre2)
Fin

106
Récursivité
Définition:
Définition:
Une fonction est récursive si elle peut s'appeler elle-même de façon directe
Une fonction est récursive si elle peut s'appeler elle-même de façon directe
ou indirecte.
ou indirecte.
Idée générale
Idée générale :
:
La réalisation d'une tâche par un algorithme récursif
La réalisation d'une tâche par un algorithme récursif
repose sur deux éléments:
repose sur deux éléments:
 La résolution partielle du problème d'une façon simple. La réalisation du
La résolution partielle du problème d'une façon simple. La réalisation du
reste de la tâche étant déléguée aux appels récursifs successifs.
reste de la tâche étant déléguée aux appels récursifs successifs.
 La détermination d'une condition d'arrêt qui permet d'arrêter la cascade
La détermination d'une condition d'arrêt qui permet d'arrêter la cascade
d'appels récursifs. Résoudre le problème au moment où la condition d'arrêt
d'appels récursifs. Résoudre le problème au moment où la condition d'arrêt
est détectée correspond en général à résoudre un cas trivial de celui-ci.
est détectée correspond en général à résoudre un cas trivial de celui-ci.

107
Avantages et inconvénients
Avantages:
Avantages:
 Formulation compacte, claire et élégante.
Formulation compacte, claire et élégante.
 Maîtrise des problèmes dont la nature même est
Maîtrise des problèmes dont la nature même est
récursive.
récursive.
Désavantages:
Désavantages:
 Possibilité de grande occupation de la mémoire.
Possibilité de grande occupation de la mémoire.
 Temps d'exécution peut être plus long.
Temps d'exécution peut être plus long.
 Estimation difficile de la profondeur maximale
Estimation difficile de la profondeur maximale
de la récursivité.
de la récursivité.

108
Fonction récursive factorielle
Factorielle(N:réel):réel
Si (N==0) Alors
retourner 1;
Sinon
retourner (Factorielle(N-1)*N);
Soit la fonction Factorielle, effectuant l’opération
Soit la fonction Factorielle, effectuant l’opération n!
n!

109
Exécution de Factorielle
Factorielle (4)
Factorielle (4)
Factorielle (4);
Factorielle (4);
Factorielle (3)
Factorielle (3)
Factorielle (2)
Factorielle (2)
Factorielle (1)
Factorielle (1)
Factorielle (0)
Factorielle (0)

110
Récursivité (suite)
Quatre règles régissent la récursivité
Quatre règles régissent la récursivité:
:
1.
1. Présence de cas de base pouvant être résolu sans
Présence de cas de base pouvant être résolu sans
récursivité
récursivité
2.
2. Toujours progresser vers le cas de base à chaque
Toujours progresser vers le cas de base à chaque
appel récursif
appel récursif
3.
3. « Ayez la Foi »: avoir confiance que les appels
« Ayez la Foi »: avoir confiance que les appels
récursifs progressent réellement vers le cas de base.
récursifs progressent réellement vers le cas de base.
4.
4. Intérêt composé: Ne jamais dédoubler du travail
Intérêt composé: Ne jamais dédoubler du travail
dans deux appels récursifs différents.
dans deux appels récursifs différents.

111
Limitations: Fonction récursive
Limitations: Fonction récursive
Fibonnacci
Fibonnacci
fibo (valeur:réel):réel
Si (valeur <= 1)Alors
retourner valeur;
Sinon
returnourner(fibo(valeur-1) + fibo(valeur-2));
Soit la fonction Fibo (Fibonacci), effectuant
Soit la fonction Fibo (Fibonacci), effectuant
l’opération
l’opération f(n) = f(n-1) + f(n-2)
f(n) = f(n-1) + f(n-2)

112
Exécution de Fibonnacci
Exécution de Fibonnacci
Soit les appels effecutés pour fibo(4) :
Soit les appels effecutés pour fibo(4) :
fibo(4)
fibo(4)
fibo(3)
fibo(3)
fibo(2)
fibo(2)
fibo(1)
fibo(1) fibo(0)
fibo(0)
fibo(1)
fibo(1)
fibo(2)
fibo(2)
fibo(0)
fibo(0)
fibo(1)
fibo(1)

113
Danger de Fibonnacci
Danger de Fibonnacci
Note :
Note :
 Cette fonction récursive effectue plusieurs appels au même calcul.
Cette fonction récursive effectue plusieurs appels au même calcul.
Par exemple pour déterminer f(n), on calcule d’abord f(n-1), puis au
Par exemple pour déterminer f(n), on calcule d’abord f(n-1), puis au
retour de l’appel, f(n-2) est calculé. Or, dans le calcul de f(n-1), f(n-
retour de l’appel, f(n-2) est calculé. Or, dans le calcul de f(n-1), f(n-
2) est déjà calculé!
2) est déjà calculé!
 Ce problème s’aggrave en descendant l’arborescence, puisque f(n-3)
Ce problème s’aggrave en descendant l’arborescence, puisque f(n-3)
sera appelé à 3 reprises : chaque appel récursif entraînera de plus en
sera appelé à 3 reprises : chaque appel récursif entraînera de plus en
plus d’appel redondant.
plus d’appel redondant.
 Règle 4:
Règle 4: Ne jamais dupliquer le travail par la résolution d’une
Ne jamais dupliquer le travail par la résolution d’une
même instance d’un problème dans plusieurs appels récursifs.
même instance d’un problème dans plusieurs appels récursifs.

114
Récursivité
 Calcul de la racine carrée d'un nombre par approximation
successive
- calculer c’est trouver une quantité y telle que y2 = x
et x ≥ 0
 Algorithme:
– faire une première approximation G de
– améliorer cette approximation en calculant la moyenne
entre G et x/G
– continuer jusqu’à ce que l’estimation G soit jugée
satisfaisante

115
Exemple

COURS ALGOgithmique et programmation ofppt.ppt

Contenu connexe

Tendances

Similaire à COURS ALGOgithmique et programmation ofppt.ppt

Dernier

COURS ALGOgithmique et programmation ofppt.ppt

Notes de l'éditeur