LA RECURSIVITE

1
RECURSIVITE
2
Sommaire

• Introduction et intérêt
• Pile des contextes (Factorielle)
• Arbre des appels (tours de Hanoi)
• Elimination de la récursivité
• Elimination premier modèle
• Elimination deuxième modèle
• Elimination troisième modèle

3
LA RECURSIVITE

• Définition
• La récursivité est un procédé pour lequel dans
  une définition apparaît la définition elle même.
• Quand ?
• Suite récurrentes (exemple factorielle)
• Type récursifs
• Liste non vide premier liste
• Arbre binaire racine sous-arbre droit
  sous-arbre gauche
• Définitions récursives
• Grammaire ltEgt (ltEgt,ltEgt)
• ltEgt (ltEgt,ltEgt)
• ltEgt Nombre identificateur

4
FONCTION FACTORIELLE
Règle récursive fact(n) n fact
(n-1) Condition darrêt fact (0) 1

• int fact (int n)
• if (n 0) return 1
• else return (n fact (n-1))

5
PILE DES CONTEXTES

• A chaque appel dune fonction récursive, les
  arguments transmis par valeur et les variables
  locales sont empilés.
• Ces valeurs constituent le contexte dactivation
  de lappel.
• A chaque retour le contexte situé en haut de la
  pile est disponible
• Les contextes sont indépendants

6
EXECUTION DE FACTORIELLE(3)
Nfact(2)
N3
1 (empiler)
Nfact(1)
N2
2 (empiler)
Nfact(0)
N1
3 (empiler)
Return(1)
N0
4 (empiler)
Return (11)
N1
(dépiler) gt 3
Return (2 1)
N2
(dépiler) gt 2
Return (3 2)
N3
(dépiler) gt 1
Retour au point appelant
Pile vide
(dépiler)
7
ALGORITHME RECURSIF AVANTAGES

• Fiabilité
• Solution naturelle et facile à concevoir
• si la fonction est récursive
• quand la structure de données traitée est
  récursive
• Exemples
• Traitement sur les arbres
• Tours de Hanoï

8
Les tours de Hanoï Problème

• Problème
• Soit n tours de tailles décroissantes sur un
  socle A, transférer les n tours sur le socle B en
  utilisant un socle intermédiaire C.

Déplacement dune tour on ne peut empiler
quune tour de plus petite taille sur une autre
tour
9
Paramétrage

• void Hanoi(int n, socle A, socle B, socleC)
• n nombre de tours
• A socle de départ (valeur initiale suite de
  n tours décroissantes)
• B socle de darrivée (valeur initiale vide)
• C socle intermédiaire (valeur initiale vide)

10
Les tours de Hanoï résolution
Socle A
11
RESOLUTION RECURSIVE

• Cas trivial (arrêt)
• n1
• il suffit de déplacer lunique tour de A vers B
• Règle récursive
• ngt1 Hanoi (n-1, A ,C, B)
• Déplacer (A,B)
• Hanoi (n-1, C, B, A)

12
FONCTION HANOI
A départ B arrivée C intermédiaire

• void Hanoi (int n, socle A, socle B, socleC)
• if (n 1) Déplacer (A,B)
• else
• Hanoi (n-1,A,C,B)
• Déplacer (A,B)
• Hanoi (n-1,C,B,A)

13
ARBRE DES APPELS (n3)
Déplacer (A,B)
Déplacer (C,A)
Déplacer (A,C)
Déplacer (C,B)
Déplacer (A,B)
14
LELIMINATION DE LA RECURSIVITE

• Pourquoi ?
• Problème dencombrement mémoire
• gt Diminuer la taille de la pile
• Comment ?
• Écrire un algorithme itératif équivalent
• Gérer dans lalgorithme la pile des sauvegardes
  gt ne garder que celles utiles

Transformer un algorithme récursif en une
version itérative équivalente qui conduise à une
diminution de la pile.
15
Transformation un cas simple

• void fonction (H x) if (c(x)) A0(x)
• else A1(x) fonction(F1(x))

void fonction (H x) while (! c(x))
A1(x) xF1(x) A0(x)
Un seul appel récursif terminal. gt La pile est
inutile. gt Version itérative équivalente qui
conduise à l élimination de la pile.
16
Transformation un cas simple

• void enumerer (int n) if (n lt 0) cout ltlt
  "fin"
• else cout ltlt n enumerer (n - 1)

c(x) n lt 0 A0 cout ltlt "fin" A1 cout
ltlt n F1 (x) n n - 1
void enumerer (int n) while (n gt 0) cout
ltlt n n n - 1 cout ltlt "fin"
17
Transformation autre modèle

• T fonction (T2 x)
• if (c(x)) return f(x)
• else return u (g(x), fonction(h(x)))

T fonction (T2 x) if (c(x)) return f(x) else
pg(x) xh(x) while (! c(x)) p
u(p,g(x)) xh(x) return u
(p,f(x))
18
Exemple un seul appel récursif

• Version récursive
• ! c(x) gt u g(x),fonction(h(x))
• puis c(h(x)) gt u g(x),f(h(x))
• Version itérative
• ! c(x) gt pg(x) xh(x)
• puis c(h(x)) gt u g(x),f(h(x))

19
Exemple deux appels

• Version récursive
• ! c(x) gt u g(x),fonction (h(x))
• ! c(h(x)) gt u g(x), u g(h(x)),fonction
  (h2(x))
• c(h2 (x)) gt u g(x), u g(h(x)),f(h2(x))
  
• Version itérative
• ! c(x) gt pg(x) xh(x)
• ! c(h(x)) gt p u g(x), g(h(x))
• x h2 (x)
• c(h2 (x)) gt u u g(x), g(h(x)) ,f(h2(x))

u doit être une relation associative
20
Factorielle

• int fact (int x)
• if (x 0) return 1
• else return (x fact (x-1))

int fact (int x)if (x0) return 1 else px
xx-1 while (!(x0)) p p x x
x-1 return p1
c(x) x 0 f(x) 1 u g(x) x h(x)x-1
21
Transformation autre modèle

• algorithme P (T x)
• si (c(x)) alors A0(x)
• sinon A1(x)
• P(F1(x))
• A2(x)
• P(F2(x))
• . . .
• Am(x)
• P(Fm(x))
• Am1(x)

22
ARBRE DES APPELS (m2)
A1
A1
A2
A3 On remonte
P F1(F1(x))
P F2(F1(x))
23
Transformation autre modèle

• algorithme P (T x)
• empiler (x,1) // marque fin de pile
• REPETER
• TANT QUE (non c(x)) FAIRE
• A1(x)
• empiler (x,2)
• x lt- F1(x)
• FAIT
• A0(x)depiler (x, numret)
• TANT QUE(numret m1)FAIRE
• Am1(x)
• depiler (x, numret)
• FAIT

SI (numret ! 1) alors Anumret(x) empiler
(x,numret1) x lt- Fnumret(x) FSI JUSQU A
(numret 1) depiler (x, numret) // fin de
// pile

• On empile
• le contexte (données)
• n de l action suivante

24
FONCTION HANOI

• void Hanoi (int n, socle A, socle B, socleC)
• if (n 1)Déplacer (A,B) // A0(x)
• else // A1(x) action vide
• Hanoi (n-1,A,C,B) // P(F1(x))
• Déplacer (A,B) // A2(x)
• Hanoi (n-1,C,B,A) // P(F2(x))

c(x) n 1A0(x) deplacer (A,B)A1(x)
action videF1(x) permuter(B,C) nn-1A2(x)
deplacer (A,B)F2(x) permuter(A,C)
nn-1A3(x) action vide

• m2
• Am1 action vide
• Dernier appel terminal gtEconomie mémoire
  (pile)

25
Transformation Hanoi

• void Hanoi (int n, ...)
• empiler (x,1)
• REPETER
• TANT QUE (non c(x)) FAIRE
• //action vide
• empiler (n,a,b,c,2)
• permuter(B,C) nn-1
• FAIT
• deplacer (A,B) //A0(x)depiler (n,a,b,c,numret)
• TANT QUE (numret m1) FAIRE
• Am1(x)
• depiler (x, numret)
• FAIT

SI (numret ! 1) alors deplacer (A,B)
//A2(x)empiler (x,numret1) permuter(A,C)
nn-1 FSI JUSQU A (numret 1) depiler
(n,a,b,c,numret)
Pas d appel récursif suivant
Dernier appel est terminal
26
Algorithme à essais successifs

• AES ou encore algorithme de back tracking
• idée construire progressivement une solution à
  un problème donné en essayant toutes les
  possibilités à chaque étape de la construction.
• Rqe la complexité de ce genre d algorithme est
  de nature exponentielle gt à utiliser si l on
  n en connaît pas de meilleur.

27
Algorithme à essais successifs

• AES ou encore algorithme de back tracking
• On part dune situation initiale So (ex
  échiquier vide) pour aller vers une situation
  finale Sf (ex Huit reines placées). Plusieurs
  situations peuvent répondre au problème.
• La situation finale est atteinte par le passage
  successif de situations jusquà atteindre Sf.
• Le passage de la situation Si à Si1 se fait par
  une action.
• Pour chaque situation Si on a le choix entre
  plusieurs actions menant à des situations
  éventuellement différentes.

28
Algorithme à essais successifs

• MODELISATION
• Une fonction Succès(S) qui permet de savoir si
  une situation S répond au problème.
• Une fonction EnsembleChoix(S) qui permet
  d obtenir à partir d une situation S donnée
  lensemble des actions possibles pour passer à
  une situation suivante.
• Une fonction Successeur(S,A) qui donne la
  situation obtenue par lapplication de laction A
  à la situation S.
• Pour chaque situation Si on a le choix entre
  plusieurs actions menant à des situations
  éventuellement différentes.
• On appelle chemin une suite d actions ltA0, A1,
  , Angt

29
Algorithme

• Fonction AES (sSituation) (Chemin,Situation)
• Variables trouvé, choix
• si succès(s) alors
• trouvévrai retourner(vide,s)
• sinon
• trouvéfaux choix lt- ensembleChoix(s)
• tant que choix nest pas vide et non trouvé
  faire
• action lt-un élément de choix
• choix lt-choix - action
• (chemin,situation)lt- (AES (successeur(s,action))
  )
• fin tant que
• si trouvé alors
• ajouter(action, chemin),sf))
• sinon retourner (Erreur Chemin, Erreur action)
• fin si
• fin si