Embed Size (px)
Citation preview
Récursion
IFT1025: Programmation 2
Jian-Yun Nie
Définition
• Le fait pour un programme ou une méthode de s'appeler lui-même.
• Par exemple– Définir la notion de « ancêtre »
• Les parents sont des ancêtres• Les ancêtres des parents sont des ancêtres
– Définition de « ami »• Les gens directement autour de moi sont des amis• Les amis de mes amis sont mes amis
Pourquoi récursion
• Certains problèmes en informatiques sont de nature récursive– Ne peuvent pas être résolus sans récursion– E.g. ancêtre et ami
• Certains problèmes peuvent être formulés de façon plus concise et claire avec récursivité
Un exemple en Java
class Test
{ …
public int calcul(int val)
{
if (val<=0) return 0
else return val + calcul(val-1);
}
}
sinon ),1(
0 si ,0)(
valcalculval
valvalcalcul
Quelques fonctions mathématiques• Fibobacci
n: 0 1 2 3 4 5 6 7
Fibo(n): 1 1 2 3 5 8 13 21
• Une fonction de nature récursive– La valeur de fibo(n) dépend de fibo(n-1) et fibo(n-2)
1 ),2()1(
1 ,1
0 ,1
)(
nnfibonfibo
n
n
nfibo
Définition d’une fonction récursive
• Cas simple– Problème directement résoluble– Pas de récursion
• Cas récursif (cas complexe)– Appel à la même fonction– Pour des cas plus simples
• n-1, n-2 sont plus simples que n
1 ),2()1(
1 ,1
0 ,1
)(
nnfibonfibo
n
n
nfiboCas simples
Cas récursif
Forme d’une méthode récursive
• Méthode pour un problème n– Si n est directement résoluble,
• retourner une réponse ou faire un traitement direct
– Sinon (cas récursif)1. Décomposer le problème n en des sous
problèmes moins complexes: n1, n2, …
2. Appel à Méthode pour traiter n1, n2, …
3. Utiliser les résultats pour n1, n2, … pour composer un résultat pour n
Exemple fibonacci
• Fibo(n)– Si n=0 ou n=1: cas simple
• Retourner le résultat = 1
– Si non (n>1): cas complexe• Décomposer le problème en deux parties
– n-1 et n-2– Appel a la méthode pour les traiter: fibo(n-1), fibo(n-2)– Composer le résultat pour n: fibo(n-1)+fibo(n-2)
Importants pour réussir la récursion
• Bien définir le cas simple– Pour arrêter la récursion– Sinon, récursion à l’infinie
• Bien décomposer le problème– En sous-problèmes plus simples– Si les sous-problèmes sont aussi complexes:
récursion à l’infinie
Mauvais exemples
• Sans une bonne condition d’arrêt:
• Une mauvaise décomposition
1 ),2()1(
)(
nnfibonfibo
nfibo
1 ),1()(
1 ,1
0 ,1
)(
nnfibonfonct
n
n
nfonct
1 ),2()1(
1 ,1
)(
nnfibonfibo
nnfibo
1 ),1()1(
1 ,1
0 ,1
)(
nnfibonfonct
n
n
nfonct
En Java
public double fibo(int n)
{
if n<=1 return 1
else return fibo(n-1)+fibo(n-2);
}
Attention: à chaque récursion, on teste d’abord pour traiter le cas simple en premier
Exécutionfibo(4)
fibo(3) fibo(2)
fibo(2) fibo(1) fibo(1) fibo(0)
1 1 1
fibo(1) fibo(0)
1 1
Exécutionfibo(4)?
fibo(3)? fibo(2)?
fibo(2)? fibo(1)? fibo(0)?fibo(1)?
fibo(0)?fibo(1)?
1 1
3
1
5
2
2
11
Fonction transformable en récursive
• Factoriel
n: 1 2 3 4 5 6
Fac(n): 1 2 6 24 120 720
• Somme:
1 ),1(*
1 ,1)(
nnfacn
nnfac
n
i
infac1
)(
1 ),1(
1 ,1)(
nnsommen
nnsomme
n
i
insomme1
)(
En Javapublic double fact(int n){
int i;double f=1;for (i=1; i<=n; i++) f = f*n;return f;
}public double somme(int n){
int i;double f=0;for (i=1; i<=n; i++) f = f+n;return f;
}
public double fact(int n){
if n=1 return 1else return n*fact(n-1);
}
public double somme(int n){
if n=1 return 1else return n+somme(n-1);
}
Un autre exempletraverser un tableau
• Problème initial: traverser le tableau à partir de l’indexe 0 (jusqu’à la fin)
• Le problème est décomposable ?– Pour traverser à partir de l’indexe i
• Traverser l’élément courant i• Traverser le reste du tableau – à partir de i+1
– Attention: condition d’arrêt!• Traverser le reste – à partir de i+1 si il en reste
Traverser
• Structure d’une méthode– traverser(i, tableau)
• Traiter i• Si non à la fin du tab, traverser(i+1, tableau)
• Appel pour traverser complètement un tableauint [ ] tableau;
traverser(0, tableau);
import java.io.*;
//------------------------------------------------------class Parcours{
//--------------------------------------------------- static void croissant( int index,
int [] tableau ) {
if( ( null != tableau ) && ( index >= 0 ) && ( index < tableau.length ) ) {
System.out.println( tableau[index]);croissant( index + 1, tableau );
} }
//------------------------------------------------------------ static void decroissant( int index, int []
tableau ) {
if( ( null != tableau ) && ( index >= 0 ) && ( index < tableau.length ) ) {
decroissant( index + 1, tableau );System.out.println( tableau[ index
] ); }
}
//------------------------------------------------------------ public static void main( String [] args ) {
// initialiser le tableauint [] tableau = new int [ 10 ];for( int i = 0; i < 10; ++i ) tableau[ i ] = i;
croissant( 0, tableau );decroissant( 0, tableau );
}}
Utiliser d’une méthode utilitaire
• Quand on appelle une méthode pour parcourir complètement un tableau, on ne devrait pas avoir besoin de spécifier l’index du début (0).– Appel normal: parcours(tab)
• Solution:– Une méthode à être appelée de l’extérieur :
parcours(tableau)– Une autre méthode utilitaire qui utilise un index dans
ses paramètres afin de faire la récursion : parcours_help(i, tableau)
– parcours(tableau) appelle parcours_help(0, tableau)
import java.io.*;
//------------------------------------------------------class Parcours{
// parcours_help est identique à croissant static void parcours_help( int index,
int [] tableau ) {
if( ( null != tableau ) && ( index >= 0 ) && ( index < tableau.length ) ) {
System.out.println( tableau[index]);croissant( index + 1, tableau );
} }
//------------------------------------------------------------ static void parcours (int [] tableau ) {
parcours_help(0, tableau); }
//------------------------------------------------------------ public static void main( String [] args ) {
// initialiser le tableauint [] tableau = new int [ 10 ];for( int i = 0; i < 10; ++i ) tableau[ i ] = i;
parcours( tableau ); }}
Un problème plus complexe
• Tours de Hanoi:
• Problème: déplacer les n disques d’une tour à un autre
• Contraintes– Déplacer un disque à la fois– Plus gros disque jamais sur de plus petits
Origine
Une légende raconte qu’un groupe de moines, gardien des trois tours, doivent déplacer 64 anneaux d’or d’une tour à une autre en respectant la règle unique qui stipule qu’un anneau ne doit pas reposer sur un anneau plus petit. Lorsque les moines auront déplacé les 64 anneaux, le monde se détruira.
Situations typique
• Libérer le dessus
• Déplacer le dernier
• Déplacer les autres
Décomposition
Déplacer n disque de tour 1 à 3 – Si n=1: déplacer le disque directement
• Cas simple, condition d’arrêt de récursion
– Sinon• Déplacer n-1 disque de 1 à 2
– Problème moins complexe
• Déplacer 1 disque de 1 à 3– Problème résoluble directement
• Déplacer n-1 disque de 2 à 3– Problème moins complexe
Illustration
Illustration
Une vue plus synthétiqueDéplacer 2 premier de A à B
Déplacer 2 de B à A
En Java• Stocker n disques dans un tableau de int• Utiliser int pour désigner la grandeur de disque• E.g.:
– tour[1] = {4,3,2,1};– Mieux: le générer automatiquement
• Supposons 3 tours: tour[1], tour[2], tour[3]• public void deplacer(n,i,j): déplacer n disque de tour i à
tour j– Si n=1: mettre un disque de tour[i] à tour[j] – Sinon:
• deplacer(n-1,i,6-i-j)• deplacer(1,i,j)• deplacer(n-1,6-i-j,j)
• Utilisation (Test)– Générer 3 tours– Appeler déplacer
• (Lab)
