Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) :...

Cours d'algorithmique 7 - IntranetCours d'algorithmique 7 - Intranet 1127 novembre 200627 novembre 2006

Cours d’AlgorithmiqueCours d’Algorithmique

Dérécursion (début) :Dérécursion (début) :

Équivalences entreÉquivalences entre

programmes récursifsprogrammes récursifs

etet

programmes itératifs avec ou sans gestion de pile.programmes itératifs avec ou sans gestion de pile.

27 novembre 200627 novembre 2006 Cours d'algorithmique 7 - IntranetCours d'algorithmique 7 - Intranet 22

• Trier et chercher, recherche textuelleTrier et chercher, recherche textuelle• Listes et arbresListes et arbres• Le back-trackLe back-track• Arbres équilibrésArbres équilibrés• Récursivité et induction sur la structureRécursivité et induction sur la structure• Divide and conquerDivide and conquer• Minimax, alpha-betaMinimax, alpha-beta• DérécursionDérécursion• Divers problèmes particuliersDivers problèmes particuliers• Logique de HoareLogique de Hoare• Programmation dynamiqueProgrammation dynamique• Complexité et calculabilitéComplexité et calculabilité

Les grandes lignes du coursLes grandes lignes du cours


IntroductionIntroduction----------------------------------------------------------------------------------------------------------------------------------

• Si nous programmons à l’aide de fonctions récursives :Si nous programmons à l’aide de fonctions récursives :

– la gestion des différents appels est faite par le système,la gestion des différents appels est faite par le système,

– à travers la gestion de la pile.à travers la gestion de la pile.






• Si nous programmons de manière itérative (boucle Si nous programmons de manière itérative (boucle while) :while) :

– nous devons gérer nous-mêmes toutes les instances des nous devons gérer nous-mêmes toutes les instances des calculscalculs

– et donc gérer éventuellement une pile.et donc gérer éventuellement une pile.









• Questions :Questions :

– Comment passer du Comment passer du récursif à l’itératifrécursif à l’itératif et vice-versa ? et vice-versa ?










– Comment passer du Comment passer du récursif à l’itératifrécursif à l’itératif et vice-versa ? et vice-versa ?






• Si nous programmons de manière itérative (boucle while) :Si nous programmons de manière itérative (boucle while) :

– nous devons gérer nous-mêmes toutes les instances des calculsnous devons gérer nous-mêmes toutes les instances des calculs



– Comment passer du récursif à l’itératif et vice-versa ?Comment passer du récursif à l’itératif et vice-versa ?

– Et pourquoi on préfère souvent la récursion à l’itération . . .Et pourquoi on préfère souvent la récursion à l’itération . . .


Théorème fondamentalThéorème fondamental----------------------------------------------------------------------------------------------------------------------------------

• Tout programme qui comporte des itérations while et Tout programme qui comporte des itérations while et des fonctions récursives :des fonctions récursives :

– peut être transformé en un programme qui comporte peut être transformé en un programme qui comporte uniquement des fonctions récursives,uniquement des fonctions récursives,





• Tout programme qui comporte des itérations while et Tout programme qui comporte des itérations while et

des fonctions récursives :des fonctions récursives :

– peut être transformé en un programme qui comportepeut être transformé en un programme qui comporte uniquement des itérations while,uniquement des itérations while,





– et même une seule fonction récursive.et même une seule fonction récursive.


– peut être transformé en un programme qui comportepeut être transformé en un programme qui comporte uniquement des itérations while,uniquement des itérations while,

– et même une seule itération while.et même une seule itération while.


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

R é C u R s I fR é C u R s I f

V e R sV e R s

i T é R a T i F ! ! !i T é R a T i F ! ! !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

Nombre d’appels récursifsNombre d’appels récursifs

UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

Chaque appel récursif engendre au plus un autre appel !Chaque appel récursif engendre au plus un autre appel !


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( ... return( ... f( )f( ) ... ) ... )


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( ... return( ... f( )f( ) ... ) ... )

f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse if ( ... )if ( ... ) return( ... return( ... f( )f( ) ... ) ... ) elseelse return( ... return( ... f( )f( ) ... ) ... )

mais aussi :mais aussi :


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

Chaque appel récursif engendre au plus deux autres appels !Chaque appel récursif engendre au plus deux autres appels !


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

Chaque appel récursif engendre au plus deux autres appels !Chaque appel récursif engendre au plus deux autres appels !

f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse if ( ... )if ( ... ) return( ... return( ... f( )f( ) ... ) ... ) elseelse return( ... return( ... f( )f( ) ... ... f( )f( ) ... ... ))


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

Fonction enveloppeFonction enveloppe

NonNon OuiOui


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux

On dit que l’appel récursif est « terminal ».On dit que l’appel récursif est « terminal ».


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux

On dit que l’appel récursif est « terminal ».On dit que l’appel récursif est « terminal ».

f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( return( f( ... )f( ... ) ) )


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux

On dit que l’appel récursif est « non terminal ».On dit que l’appel récursif est « non terminal ».


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux

On dit que l’appel récursif est « non terminal ».On dit que l’appel récursif est « non terminal ».

f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( return( h( ...h( ... f( ) f( ) ... )... ) ) )

La fonction « h »La fonction « h »est l’enveloppe !est l’enveloppe !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux

Enveloppe associativeEnveloppe associative

NonNon OuiOui


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux


NonNon OuiOui

« h » est associative si, et seulement si, on a toujours :« h » est associative si, et seulement si, on a toujours :

h ( a , h ( b , c ) ) = h ( h ( a , b ) , c )h ( a , h ( b , c ) ) = h ( h ( a , b ) , c )


RemarqueRemarque----------------------------------------------------------------------------------------------------------------------------------


h ( a , h ( b , c ) ) = h ( h ( a , b ) , c )h ( a , h ( b , c ) ) = h ( h ( a , b ) , c )




h ( a , h ( b , c ) )h ( a , h ( b , c ) ) = h ( h ( a , b ) , c ) = h ( h ( a , b ) , c )

hh

aa hh

bb cc




h ( a , h ( b , c ) )h ( a , h ( b , c ) ) = = h ( h ( a , b ) , c )h ( h ( a , b ) , c )

hh

aa hh

bb cc

hh

cchh

aa bb




h ( a , h ( b , c ) )h ( a , h ( b , c ) ) = = h ( h ( a , b ) , c )h ( h ( a , b ) , c )

hh

aa hh

bb cc

hh

cchh

aa bb

==

Les structures des arbres n’importent pas !Les structures des arbres n’importent pas !

==


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

P R E S E N T A T I O P R E S E N T A T I O NN

G E N E R A L EG E N E R A L E

D E S C A SD E S C A S

D E F I G U R ED E F I G U R E


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux


NonNon OuiOui


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux


NonNon OuiOuiAvec élément neutreAvec élément neutre

NonNon OuiOui


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui

« h » admet le« h » admet leneutre « e » si, etneutre « e » si, etseulement si, on a toujours:seulement si, on a toujours:

h( e , a ) = a = h( a , e )h( e , a ) = a = h( a , e )


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui

Appréciations !Appréciations !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui


Sympas ! ! !Sympas ! ! !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui



Assez sympa !Assez sympa !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui




Il existe desIl existe destransformations !transformations !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui






PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui




Beurk ! ! ! ! !Beurk ! ! ! ! !Il existe desIl existe destransformations !transformations !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui






PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux


NonNon OuiOui


Itératif ! ! !Itératif ! ! !

Récursif ! ! !Récursif ! ! !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


UnUn DeuxDeuxFonction auto-enveloppéeFonction auto-enveloppée

NonNon OuiOui


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOui

La fonction récursive est sa propre enveloppe !La fonction récursive est sa propre enveloppe !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOui


f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( return( f( ...f( ... f( ) f( ) ... )... ) ) )


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOui


f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( return( f( ...f( ... f( ) f( ) ... )... ) ) )

La fonction enveloppeLa fonction enveloppede de « f »« f » est est « f » « f » !!

L’appel externe L’appel externe « f »« f »est terminal.est terminal.


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOui

Une fonction « h » enveloppe les deux appels récursifs !Une fonction « h » enveloppe les deux appels récursifs !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOui

Une fonction « h » enveloppe les deux appels récursifs !Une fonction « h » enveloppe les deux appels récursifs !

f ( x )f ( x ) = = if ( ... )if ( ... ) return( valeur )return( valeur ) elseelse return( return( h( ...h( ... f( ) f( ) ...... f( ) f( ) ... )... ) ) )


PlanPlan----------------------------------------------------------------------------------------------------------------------------------



NonNon OuiOuiEnveloppe associativeEnveloppe associative

OuiOui NonNon


PlanPlan----------------------------------------------------------------------------------------------------------------------------------




OuiOui NonNonAvec élément neutreAvec élément neutre

OuiOui NonNon


PlanPlan----------------------------------------------------------------------------------------------------------------------------------





OuiOui NonNon



PlanPlan----------------------------------------------------------------------------------------------------------------------------------





OuiOui NonNon


TransformationTransformationintéressante !intéressante !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------





OuiOui NonNon



Celle-là aussi !Celle-là aussi !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------





OuiOui NonNon



Celle-là aussi !Celle-là aussi !

Sans espoir ! ! !Sans espoir ! ! !


PlanPlan----------------------------------------------------------------------------------------------------------------------------------

D i S c U s S i O nD i S c U s S i O n

D e S d I v E r SD e S d I v E r S

C a S d E f I g U r E :C a S d E f I g U r E :

U n A p P e L r E c U r S i FU n A p P e L r E c U r S i F


Un appel récursif, terminalUn appel récursif, terminal----------------------------------------------------------------------------------------------------------------------------------

• Un seul appel récursif qui est terminal.Un seul appel récursif qui est terminal.

• C’est le cas de base, il est fondamental.C’est le cas de base, il est fondamental.


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui





• Il se transforme en boucle while sans pile.Il se transforme en boucle while sans pile.






• Les appels non terminaux avec une Les appels non terminaux avec une enveloppe associative se ramènent à ce enveloppe associative se ramènent à ce cas.cas.


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui






• Les appels non terminaux avec une Les appels non terminaux avec une enveloppe associative se ramènent à ce cas.enveloppe associative se ramènent à ce cas.

• Tout ce qui ne se ramène pas à Tout ce qui ne se ramène pas à ce cas nécessitera une pile ! ! !ce cas nécessitera une pile ! ! !



• Exemple :Exemple :

– Soient des couples ( x , y ) avec x >= y .Soient des couples ( x , y ) avec x >= y .

– On définit le « pgcd » comme ci-dessous.On définit le « pgcd » comme ci-dessous.

– La notation est proche d’une notation mathématique.La notation est proche d’une notation mathématique.

res <- pgcd( ( a , b ) )res <- pgcd( ( a , b ) )

pgcd ( ( m , n ) ) =pgcd ( ( m , n ) ) = si ( n = 0 )si ( n = 0 ) mm sinonsinon pgcd( ( n , m % n ) )pgcd( ( n , m % n ) )









L’appel initial.L’appel initial.










L’entête de définition.L’entête de définition.











Le corps de la définition :Le corps de la définition :

- l’indentation importe.l’indentation importe.

- les « return » sont implicites.les « return » sont implicites.



• Ce programme est de la forme :Ce programme est de la forme :



res <- f( v )res <- f( v )

f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon f( f( ( x ) )( x ) )




res <- res <- pgcdpgcd( ( a , b ) )( ( a , b ) )


res <- res <- ff( v )( v )





res <- res <- pgcdpgcd( ( ( a , b )( a , b ) ) )


res <- res <- ff( ( v v ))






pgcd ( pgcd ( ( m , n )( m , n ) ) = ) = si ( n = 0 )si ( n = 0 ) mm sinonsinon pgcd( ( n , m % n ) )pgcd( ( n , m % n ) )

res <- res <- ff( ( v v ))

f ( f ( x x ) =) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon f( f( ( x ) )( x ) )





pgcd ( pgcd ( ( m , n )( m , n ) ) = ) = si ( si ( n = 0n = 0 ) ) mm sinonsinon pgcd( ( n , m % n ) )pgcd( ( n , m % n ) )

res <- res <- ff( ( v v ))

f ( f ( x x ) =) = si ( si ( ( x )( x ) ) ) a( x )a( x ) sinonsinon f( f( ( x ) )( x ) )





pgcd ( pgcd ( ( m , n )( m , n ) ) = ) = si ( si ( n = 0n = 0 ) ) mm sinonsinon pgcd( pgcd( ( n , m % n )( n , m % n ) ) )

res <- res <- ff( ( v v ))

f ( f ( x x ) =) = si ( si ( ( x )( x ) ) ) a( x )a( x ) sinonsinon f( f( ( x )( x ) ) )




• Les calculs réalisés sont les suivants :Les calculs réalisés sont les suivants :



res <- res <- ff( ( v v ))






– Si Si ( ( vv ) ) alors alors a( a( vv ) ) et sinon :et sinon :



res <- res <- ff( ( v v ))







– Si Si ( ( ( ( vv ) ) )) alors alors a(a( ( ( vv ) ) ) ) et sinon :et sinon :



res <- res <- ff( ( v v ))







– Si Si ( ( ( ( vv ) ) )) alors alors a(a( ( ( vv ) ) ) ) et sinon :et sinon :

– Si Si ( ( ( ( ( ( v v ) )) ) )) alors alors a(a( ( ( ( ( vv ) ) ) ) ) ), etc . . ., etc . . .



res <- res <- ff( ( v v ))





• Le résultat final sera :Le résultat final sera :



res <- res <- ff( ( v v ))





• Le résultat final sera :Le résultat final sera :

– a(a( ( ( vv ) ) ) )

– avec k = avec k = i . i i . i N et N et ( ( ( v ) )( v ) )

– où où i . . . . signifie « le plus petit i tel que ». i . . . . signifie « le plus petit i tel que ».

kk

iiII



res <- res <- ff( ( v v ))




• Le programme itératif correspondant :Le programme itératif correspondant :

( m , n ) <- ( a , b )( m , n ) <- ( a , b )

while ( while ( ( n = 0 ) ) ( n = 0 ) ) ( m , n ) <- ( n , m % n )( m , n ) <- ( n , m % n )

res <- mres <- m




( m , n ) <- ( a , b )( m , n ) <- ( a , b )

while ( while ( ( n = 0 ) ) ( n = 0 ) ) ( m , n ) <- ( n , m % n )( m , n ) <- ( n , m % n )

res <- mres <- m

x <- vx <- v

while ( while ( ( x ) )( x ) ) x <- x <- ( x )( x )

res <- a( x )res <- a( x )




( m , n )( m , n ) <- <- ( a , b )( a , b )

while ( while ( ( n = 0 )( n = 0 ) ) ) ( m , n ) <- ( m , n ) <- ( n , m % n )( n , m % n )

res <- res <- mm

xx <- <- vv

while ( while ( ( x )( x ) ) ) x <- x <- ( x )( x )

res <- res <- a( x )a( x )




• Le résultat sera d’ailleurs le même :Le résultat sera d’ailleurs le même :

– a(a( ( ( vv ) ) ) ) avec k = avec k = i . i i . i N et N et ( ( ( v ) )( v ) )

( m , n )( m , n ) <- <- ( a , b )( a , b )

while ( while ( ( n = 0 )( n = 0 ) ) ) ( m , n ) <- ( m , n ) <- ( n , m % n )( n , m % n )

res <- res <- mm

kk iiII

xx <- <- vv

while ( while ( ( x )( x ) ) ) x <- x <- ( x )( x )

res <- res <- a( x )a( x )



• Donc, nous avons l’équivalence fondamentale Donc, nous avons l’équivalence fondamentale suivante :suivante :

x <- vx <- v


res <- a( x )res <- a( x )

res <- f( v )res <- f( v )





x <- vx <- v


res <- a( x )res <- a( x )

res <- f( v )res <- f( v )




• L’équivalence se généralise à deux ou plusieurs L’équivalence se généralise à deux ou plusieurs arguments :arguments :

x <- vx <- vy <- wy <- w

while ( while ( ( x , y ) )( x , y ) ) m <- m <- ( x , y )( x , y ) y <- y <- ( x , y )( x , y ) x <- mx <- m

res <- a( x , y )res <- a( x , y )

res <- f( v , w )res <- f( v , w )

f ( x , y ) =f ( x , y ) = si ( si ( ( x , y ) )( x , y ) ) a( x , y )a( x , y ) sinonsinon f( f( ( x , y ) ,( x , y ) , ( x , y ) )( x , y ) )



• Exemple : « pgcd » comme fonction binaire :Exemple : « pgcd » comme fonction binaire :

x <- vx <- vy <- wy <- w

while ( while ( ( y = 1 ) ) ( y = 1 ) ) m <- ym <- y y <- x % yy <- x % y x <- mx <- m

res <- xres <- x

res <- pgcd( v , w )res <- pgcd( v , w )

pgcd ( x , y ) =pgcd ( x , y ) = si ( y = 1 )si ( y = 1 ) xx sinonsinon pgcd( y , x % y )pgcd( y , x % y )



• Un autre exemple :Un autre exemple :

res <- fct( a )res <- fct( a )

fct ( x ) =fct ( x ) = si ( x = 1 )si ( x = 1 ) xx sinonsinon si ( pair( x ) )si ( pair( x ) ) fct( x / 2 )fct( x / 2 ) sinonsinon fct( 3 * x + 1 )fct( 3 * x + 1 )



• Un autre exemple :Un autre exemple :

x <- ax <- a

while ( while ( ( x = 1 ) ) ( x = 1 ) ) si ( pair( x ) )si ( pair( x ) ) x <- x / 2x <- x / 2 sinonsinon x <- 3 * x + 1x <- 3 * x + 1

res <- xres <- x

res <- fct( a )res <- fct( a )

fct ( x ) =fct ( x ) = si ( x = 1 )si ( x = 1 ) xx sinonsinon si ( pair( x ) )si ( pair( x ) ) fct( x / 2 )fct( x / 2 ) sinonsinon fct( 3 * x + 1 )fct( 3 * x + 1 )


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux


PlanPlan----------------------------------------------------------------------------------------------------------------------------------


NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui


Un appel récursif, non-terminalUn appel récursif, non-terminal----------------------------------------------------------------------------------------------------------------------------------

• Un appel récursif ayant une enveloppe « h ».Un appel récursif ayant une enveloppe « h ».

• Nous avons la forme générale suivante :Nous avons la forme générale suivante :

res <- f( v )res <- f( v )

f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , ( x ) , f( f( ( x ) ) ( x ) ) ))



• Un appel récursif ayant une enveloppe « h ».Un appel récursif ayant une enveloppe « h ».

• Nous avons la forme générale suivante :Nous avons la forme générale suivante :

• Si « h » est associative, nous pouvons nous ramener au cas Si « h » est associative, nous pouvons nous ramener au cas récursif terminal précédent,récursif terminal précédent,

• et donc nous ramener à une itération sans pile.et donc nous ramener à une itération sans pile.

res <- f( v )res <- f( v )

f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , ( x ) , f( f( ( x ) ) ( x ) ) ))



• Posons simplement :Posons simplement :

F( acc , x ) = h( acc , f( x ) )F( acc , x ) = h( acc , f( x ) )





• Pourquoi ? ? ?Pourquoi ? ? ? Parce que ça marchera ! ! !Parce que ça marchera ! ! !






• Déjà, si « h » admet le neutre « e » :Déjà, si « h » admet le neutre « e » :

f( x ) = h( e , f( x ) ) = F( e , x )f( x ) = h( e , f( x ) ) = F( e , x )






• Déjà, si « h » admet le neutre « e » :Déjà, si « h » admet le neutre « e » :

f( x ) = h( e , f( x ) ) = F( e , x )f( x ) = h( e , f( x ) ) = F( e , x )

– Nous pouvons donc remplacerNous pouvons donc remplacer

• l’appel l’appel f( v ) f( v ) parpar

• l’appell’appel F( e , v ) F( e , v )

res <- f( v )res <- f( v )

f ( x ) =f ( x ) = ......



• Il reste à exprimer F à l’aide d’elle-même et de Il reste à exprimer F à l’aide d’elle-même et de manière récursive terminale. h est associative. Nous manière récursive terminale. h est associative. Nous avons :avons :





F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) )

« f » est remplacée« f » est remplacéepar sa définition !par sa définition !




F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) )




• Il reste à exprimer F à l’aide d’elle-même et de manière Il reste à exprimer F à l’aide d’elle-même et de manière récursive terminale. h est associative. Nous avons :récursive terminale. h est associative. Nous avons :

F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) )

• Remarque ! On a « toujours » :Remarque ! On a « toujours » :

h( h( xx , si C alors , si C alors AA sinon sinon B B ) ) == si C alors h( si C alors h( x x , , A A ) sinon h() sinon h( x x , , B B ))





F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) = = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon h( acc , h( acc , h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) )





F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) = = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon h( acc , h( acc , h( h( ( x )( x ) , f( , f( ( x ) ) )( x ) ) ) ) )


Associativité !Associativité !




F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) = = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon h( acc , h( acc , h( h( ( x )( x ) , f( , f( ( x ) ) )( x ) ) ) ) ) h( h( h( h( acc , acc , ( x )( x ) ) , f( ) , f( ( x ) )( x ) ) ) )






F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) = = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon h( acc , h( acc , h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) h(h( h( acc , h( acc , ( x ) )( x ) ) , , f(f( ( x )( x ) ) )) )



Définition de F !Définition de F !F( a , b ) =F( a , b ) =

h( h( aa , f( , f( bb ) ) ) )



• Il reste à exprimer F à l’aide d’elle-même et de manière Il reste à exprimer F à l’aide d’elle-même et de manière récursive terminale. h est associative. Nous avons :récursive terminale. h est associative. Nous avons :

F( acc , x ) = h( acc , F( acc , x ) = h( acc , f( x )f( x ) ) ) = h( acc , = h( acc , si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) = = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon h( acc , h( acc , h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) ) ) h(h( h( acc , h( acc , ( x ) )( x ) ) , , f(f( ( x )( x ) ) )) ) F(F( h( acc , h( acc , ( x ) )( x ) ) , , ( x )( x ) ))



Définition de F !Définition de F !F( a , b ) =F( a , b ) =

h( h( aa , f( , f( bb ) ) ) )



• Pour h est associative, nous obtenons donc la Pour h est associative, nous obtenons donc la définition récursive terminale suivante :définition récursive terminale suivante :

F( acc , x ) = F( acc , x ) = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon F(F( h( acc , h( acc , ( x ) )( x ) ) , , ( x )( x ) ))




F( acc , x ) = F( acc , x ) = si ( si ( ( x ) )( x ) ) h( acc , h( acc , a( x )a( x ) ) ) sinonsinon F(F( h( acc , h( acc , ( x ) )( x ) ) , , ( x )( x ) ))




F( acc , x ) = F( acc , x ) = si si ( ( ( x ) )( x ) ) h( acc , a( x ) )h( acc , a( x ) ) sinonsinon F(F( h( acc , h( acc , ( x ) )( x ) ) , , ( x )( x ) ))


while while ( ( ( x ) )( x ) ) acc <- h( acc , acc <- h( acc , ( x ) )( x ) ) x <- x <- ( x )( x )

res <- h( acc , a( x ) )res <- h( acc , a( x ) )




F( acc , x ) = F( acc , x ) = si si ( ( ( x ) )( x ) ) h( acc , a( x ) )h( acc , a( x ) ) sinonsinon F(F( h( acc , h( acc , ( x ) )( x ) ) , , ( x )( x ) ))


while while ( ( ( x ) )( x ) ) acc <- h( acc , acc <- h( acc , ( x ) )( x ) ) x <- x <- ( x )( x )


D’où le nomD’où le nomd’accumulateur !d’accumulateur !



• L’initialisation est simple si « h » admet un neutre « e » L’initialisation est simple si « h » admet un neutre « e » : :

f( v ) = F( e , v )f( v ) = F( e , v )

x <- vx <- vacc <- eacc <- e

while ( while ( ( x ) )( x ) ) acc <- h( acc , acc <- h( acc , ( x ) )( x ) ) x <- x <- ( x )( x )




• L’initialisation est simple si « h » admet un neutre « e » L’initialisation est simple si « h » admet un neutre « e » : :

f( v ) = F( e , v )f( v ) = F( e , v )






• Si « h » est associative avec neutre « e », nous avons : Si « h » est associative avec neutre « e », nous avons :

res <- f( v )res <- f( v )

f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) )






• L’équivalence se généralise à deux ou plusieurs L’équivalence se généralise à deux ou plusieurs arguments : arguments :

res <- f( v , w )res <- f( v , w )

f ( x , y ) =f ( x , y ) = si ( si ( ( x , y ) )( x , y ) ) a( x , y )a( x , y ) sinonsinon h( h( ( x , y ) ,( x , y ) , f( f( ( x , y ) ,( x , y ) , ( x , y ) ) )( x , y ) ) )

x <- vx <- vy <- wy <- wacc <- eacc <- e

while ( while ( ( x , y ) )( x , y ) ) acc <- h( acc , acc <- h( acc , ( x , y ) )( x , y ) ) m <- m <- ( x , y )( x , y ) y <- y <- ( x , y )( x , y ) x <- mx <- m

res <- h( acc , a( x , y ) )res <- h( acc , a( x , y ) )



• C’est un peu plus embêtant si « h » est sans neutre. C’est un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à Nous devons alors traiter le premier appel « f( v ) » à part, en observant que :part, en observant que :

f( x )f( x ) = si ( = si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) )




f( x )f( x ) = si ( = si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) , f( ( x ) , f( ( x ) ) )( x ) ) ) F( F( ( x )( x ) , , ( x )( x ) ) )





x <- vx <- v

si ( si ( ( x ) )( x ) ) res <- a( x )res <- a( x )sinonsinon acc <- acc <- ( x )( x ) x <- x <- ( x )( x ) while ( while ( ( x ) )( x ) ) acc <- h( acc , acc <- h( acc , ( x ) )( x ) ) x <- x <- ( x )( x )






x <- vx <- v



Le premier élément est traité à part !Le premier élément est traité à part !Et nous passons au second élément !Et nous passons au second élément !



• Si « h » est associative sans neutre, nous avons : Si « h » est associative sans neutre, nous avons :

res <- f( v )res <- f( v )


x <- vx <- v





• L’équivalence se généralise à deux ou plusieurs L’équivalence se généralise à deux ou plusieurs arguments : arguments :

res <- f( v , w )res <- f( v , w )


x <- vx <- vy <- wy <- wsi ( si ( ( x , y ) )( x , y ) ) res <- a( x , y )res <- a( x , y )sinonsinon acc <- acc <- ( x , y)( x , y) m <- m <- ( x , y )( x , y ) y <- y <- ( x , y )( x , y ) x <- mx <- m while ( while ( ( x , y ) )( x , y ) ) acc <- h( acc , acc <- h( acc , ( x , y) )( x , y) ) m <- m <- ( x , y )( x , y ) y <- y <- ( x , y )( x , y ) x <- mx <- m res <- h( acc , a( x ) )res <- h( acc , a( x ) )


Sous forme d’arbre …Sous forme d’arbre …----------------------------------------------------------------------------------------------------------------------------------



a( v )a( v ) = ou bien= ou bien hh

( v )( v ) f( f( ( v ) )( v ) )

{{f( v )f( v )



a( v )a( v ) = ou bien= ou bien hh

( v )( v ) f( f( ( v ) )( v ) )

{{f( v )f( v )

Continuons à développerContinuons à développerce deuxième terme !ce deuxième terme !



= ou bien= ou bien hh

( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) f( f( ( ( ( v ) ) )( v ) ) )




( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) f( f( ( ( ( v ) ) )( v ) ) )




( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) )

f( f( ( ( ( v ) ) )( v ) ) )




( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) )

f( f( ( ( ( v ) ) )( v ) ) )Une valeur !Une valeur !




( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) )


Une autre valeur !Une autre valeur !




( v )( v )

{{hh

( v )( v ) f( f( ( v ) )( v ) )

hh

( v )( v ) a( a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) )



hh

ee f( v )f( v )

Une valeur initiale !Une valeur initiale !


Le cas généralLe cas général----------------------------------------------------------------------------------------------------------------------------------

f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1


( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1hh

( v ) )( v ) )

f( f( ( v ) )( v ) )kk

k-1k-1

hh

( v )( v ) ……

Le cas généralLe cas général----------------------------------------------------------------------------------------------------------------------------------

f( v ) = hf( v ) = h


Le cas général --- h non associativeLe cas général --- h non associative----------------------------------------------------------------------------------------------------------------------------------

f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1

Soit k = Soit k = i . i i . i N et N et ( ( ( v ) )( v ) )

iiII



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) ) ( v ) ) = a( = a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1


iiII

kk

res <res <-- a( a( ( v ) )( v ) )kk



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) ) ( v ) ) = a( = a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1


iiII

kk

res <res <-- a( a( ( v ) )( v ) )kk

res <res <-- h( h( ( v ) )( v ) ) , , resres ) )k-1k-1



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) ) ( v ) ) = a( = a( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1


iiII

kk

res <res <-- a( a( ( v ) )( v ) )kk




f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .

kkk-1k-1Ou sont-elles ? ? ?Ou sont-elles ? ? ?



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .


Sur la pile, voyons !Sur la pile, voyons !



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

La dynamique ! ! !La dynamique ! ! !



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

( v )( v )




f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

( ( ( v ) )( v ) )

( v )( v )




f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

. . .. . .

( ( ( v ) )( v ) )

( v )( v )


( ( ( v ) )( v ) )



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

( v ) )( v ) )k-1k-1

. . .. . .

( ( ( v ) )( v ) )

( v )( v )




f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

. . .. . .

( ( ( v ) )( v ) )

( v )( v )

La dynamique ! ! !La dynamique ! ! ! ( v ) )( v ) )k-1k-1

res <res <-- a( a( ( v ) )( v ) )kk



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile

. . .. . .

( ( ( v ) )( v ) )

( v )( v )


res <res <-- a( a( ( v ) )( v ) )kk

res <res <-- h( h( ( v ) ) ( v ) ) resres ) )k-1k-1



f( v ) = hf( v ) = h

( v )( v )

hh

( v ) )( v ) )f( f( ( v ) )( v ) )

hh

( ( ( v ) )( v ) ) . . .

. . .



La pileLa pile


res <res <-- a( a( ( v ) )( v ) )kk

res <res <-- h( h( ( v ) ) ( v ) ) resres ) )k-1k-1

res <res <-- h( h( ( v )( v ) res res ))



p <- p <- I()I()x <- vx <- v

while ( while ( ( x ) )( x ) ) p <- p <- E( E( ( x ) , p )( x ) , p ) x <- x <- ( x )( x )

res <- a( x )res <- a( x )

while ( while ( V( p )V( p ) ) ) res <- h( res <- h( S( p )S( p ) , res ) , res ) p <- p <- D( p )D( p )



Légende des fonctions :Légende des fonctions :

- I( ) initialise une pile vide.I( ) initialise une pile vide.

- E( e , p ) empile e sur p.E( e , p ) empile e sur p.

- S( p ) rend une copie du S( p ) rend une copie du sommet de p.sommet de p.

- D( p ) supprime le sommet de D( p ) supprime le sommet de p.p.

- V( p ) dit si p est vide ou non.V( p ) dit si p est vide ou non.

p <- p <- I()I()x <- vx <- v


res <- a( x )res <- a( x )




Légende des fonctions :Légende des fonctions :

- I( ) initialise une pile vide.I( ) initialise une pile vide.

- E( e , p ) empile e sur p.E( e , p ) empile e sur p.

- S( p ) rend une copie du S( p ) rend une copie du sommet de p.sommet de p.

- D( p ) supprime le sommet de D( p ) supprime le sommet de p.p.

- V( p ) dit si p est vide ou non.V( p ) dit si p est vide ou non.

p <- p <- I()I()x <- vx <- v


res <- a( x )res <- a( x )


V( I() ) = VRAIV( I() ) = VRAIV( E( e , p ) ) = FAUXV( E( e , p ) ) = FAUXS( E( e , p ) ) = eS( E( e , p ) ) = eD( E( e , p ) ) = pD( E( e , p ) ) = p



p <- I()p <- I()x <- vx <- v

while ( while ( ( x ) )( x ) ) p <- E( p <- E( ( x ) , p )( x ) , p ) x <- x <- ( x )( x )

res <- a( x )res <- a( x )

while ( while ( V( p ) ) V( p ) ) res <- h( S( p ) , res )res <- h( S( p ) , res ) p <- D( p )p <- D( p )

L’initialisation !L’initialisation !



p <- I()p <- I()x <- vx <- v


res <- a( x )res <- a( x )



Nous descendonsNous descendonsen empilant lesen empilant les

différents éléments.différents éléments.



p <- I()p <- I()x <- vx <- v


res <- a( x )res <- a( x )





La valeur initiale du résultat !La valeur initiale du résultat !



p <- I()p <- I()x <- vx <- v


res <- a( x )res <- a( x )






Nous remontons enNous remontons encombinant lescombinant les

éléments empilés !éléments empilés !



• Si « h » n’est pas associative, nous avons : Si « h » n’est pas associative, nous avons :

res <- f( v )res <- f( v )


p <- I()p <- I()x <- vx <- v


res <- a( x )res <- a( x )




• L’équivalence se généralise à 2 ou plus d’arguments L’équivalence se généralise à 2 ou plus d’arguments pour f : pour f :

res <- f( v , w )res <- f( v , w )


p <- I()p <- I()x <- vx <- vy <- wy <- w

while ( while ( ( x , y ) )( x , y ) ) p <- E( p <- E( ( x , y ) , p )( x , y ) , p ) m <- m <- ( x , y )( x , y ) y <- y <- ( x , y )( x , y ) x <- mx <- m

res <- a( x , y )res <- a( x , y )




• L’équivalence se généralise à 3 ou plus d’arguments L’équivalence se généralise à 3 ou plus d’arguments pour h : pour h :

res <- f( v )res <- f( v )

f ( x ) =f ( x ) = si ( si ( ( x ) )( x ) ) a( x )a( x ) sinonsinon h( h( ( x ) ,( x ) , ( x ) ,( x ) , f( f( ( x ) ) )( x ) ) )

p <- I()p <- I()x <- vx <- v

while ( while ( ( x ) )( x ) ) p <- E( p <- E( ( x ) , p )( x ) , p ) p <- E( p <- E( ( x ) , p )( x ) , p ) x <- x <- ( x )( x )

res <- a( x )res <- a( x )

while ( while ( V( p ) ) V( p ) ) m <- S( p )m <- S( p ) p <- D( p )p <- D( p ) res <- h( S( p ) , m , res )res <- h( S( p ) , m , res ) p <- D( p )p <- D( p )


Un appel récursif --- résuméUn appel récursif --- résumé----------------------------------------------------------------------------------------------------------------------------------

R E S U M ER E S U M E

P O U RP O U R

U NU N

A P P E L R E C U R S A P P E L R E C U R S I FI F




NonNon OuiOui


UnUn DeuxDeux



NonNon OuiOui

Cas 1)Cas 1)

Cas 2)Cas 2)Cas 3)Cas 3)

Cas 4)Cas 4)

Nous retenons lesNous retenons lesquatre cas suivants !quatre cas suivants !



• 1) Appel récursif terminal !1) Appel récursif terminal !

x <- vx <- v


res <- a( x )res <- a( x )

res <- f( v )res <- f( v )


Code itératif raisonnable !Code itératif raisonnable !



• 2) Appel récursif avec enveloppe associative et neutre 2) Appel récursif avec enveloppe associative et neutre « e » !« e » !

res <- f( v )res <- f( v )





Code itératif raisonnable !Code itératif raisonnable !


x <- vx <- v




• 3) Appel récursif avec enveloppe associative, sans 3) Appel récursif avec enveloppe associative, sans neutre !neutre !

res <- f( v )res <- f( v )


Code itératif à peu près raisonnable !Code itératif à peu près raisonnable !



• 4) Appel récursif avec enveloppe non associative !4) Appel récursif avec enveloppe non associative !

res <- f( v )res <- f( v )


Code itératif non raisonnableCode itératif non raisonnableà cause de la gestion de pile !à cause de la gestion de pile !

p <- I()p <- I()x <- vx <- v


res <- a( x )res <- a( x )



Dérécursion (début) :Dérécursion (début) :

Équivalences entreÉquivalences entre

programmes récursifsprogrammes récursifs

etet

programmes itératifs avec ou sans gestion de pile.programmes itératifs avec ou sans gestion de pile.

SynthèseSynthèse----------------------------------------------------------------------------------------------------------------------------------


m E r C i e Tm E r C i e Tb O n N e J o U r N é b O n N e J o U r N é

E ! ! !E ! ! !

n ‘ O u B l I e Z p A s D en ‘ O u B l I e Z p A s D ep R é P a R e R v O sp R é P a R e R v O s

T D ! ! !T D ! ! !

Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) :...

Documents

Transcript of Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) :...