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

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 ?

• 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 )

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

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

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

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

NonNon OuiOui

UnUn DeuxDeux

NonNon OuiOui

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

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

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

UnUn DeuxDeux

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

UnUn DeuxDeux

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

UnUn DeuxDeux

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.

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( ( 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 ».

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 )

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 )

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 , 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 !

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 )

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

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

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

( v )( v )

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

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

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

( v )( v )

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

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

( ( ( v ) )( v ) )

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

( v )( v )

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

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

( ( ( v ) )( v ) )

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

( v )( v )

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

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

( ( ( v ) )( v ) )

Une autre valeur !Une autre valeur !

( v )( v )

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

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

( ( ( v ) )( v ) )

ee f( v )f( v )

Une valeur initiale !Une valeur initiale !

( v )( v )

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

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

( ( ( v ) )( v ) )

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 )

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

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

kkk-1k-1

( v )( v )

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

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

kkk-1k-1hh

( v ) )( v ) )

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

k-1k-1

( 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 )

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

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

kkk-1k-1

f( v ) = hf( v ) = h

( v )( v )

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

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

kkk-1k-1

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

f( v ) = hf( v ) = h

( v )( v )

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

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

kkk-1k-1

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

f( v ) = hf( v ) = h

( v )( v )

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

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

kkk-1k-1

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

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

f( v ) = hf( v ) = h

( v )( v )

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

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

kkk-1k-1

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

f( v ) = hf( v ) = h

( v )( v )

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

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

kkk-1k-1

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

f( v ) = hf( v ) = h

( v )( v )

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

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

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

f( v ) = hf( v ) = h

( v )( v )

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

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

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

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

La dynamique ! ! !La dynamique ! ! !

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

( v )( v )

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

( ( ( v ) )( v ) )

( v )( v )

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

. . .. . .

( ( ( v ) )( v ) )

( v )( v )

( ( ( v ) )( v ) )

f( v ) = hf( v ) = h

( v )( v )

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

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

La pileLa pile

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

. . .. . .

( ( ( v ) )( v ) )

( v )( v )

f( v ) = hf( v ) = h

( v )( v )

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

( ( ( 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 )

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

( ( ( 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 )

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

( ( ( 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 !

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

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) :...

PROGRAMMES - CSA

ETI Programmes'

Programmes - Testia

Suites et séries - Univers TI-Nspire · mais l’efficacité limitée par le nombre d’appels récursifs. On verra plus un autre problème au de paragraphe 2, lors du calcul exact

Surveillance Programmes

Nouveaux Programmes

Cours d'algorithmique 1 - Intranet 1 6 novembre 2006 Cours dAlgorithmique Marc Gengler Marc.Gengler@esil.univ-mrs.fr Alexandra Bac - Henry Kanoui - Alain.

Programmes 2009

IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke Analyseurs LL(1) non récursifs.

Television programmes

PROGRAMMES EXTERNES

PROGRAMMES D’AIDE ADMISSIBLES AUX ORGANISMES … · Programmes du gouvernement provincial Programmes Objectif Projets admissibles Projet irrecevables Financement Date limite de

11 février 2014 Cours d'algorithmique 3 - Intranet 1 Cours dAlgorithmique Arbres. Parcours darbres.

Commerce Programmes

Programmes universitaires en cinéma au Québec — Production ou … · PROGRAMMES UNIVERSITAIRES COMPORTANT DES COURS E CINÉMN A AU QUÉBEC Programmes se rapprochant Programmes

Abyme : un voyage au c ur des hyperviseurs récursifs - SSTIC...Abyme : un voyage au c˙ur des hyperviseurs r ecursifs Beno^ t Morgan, Guillaume Averlant, Vincent Nicomette, Eric Alata

Programmes de formation Personnel Enseignant · Programmes de formation Personnel Enseignant Témoignages ... programmes de doctorat dans des établissements comme l‘Université

Cours: génie algorithmique · le paradigme ‘’diviser pour régner’’ Dr. DhouhaMaatarRazgallah 2019/2020 2 Outline Algorithmes récursifs Application: factorielle Application:

Cours d'algorithmique 9 - Intranet 1 12 décembre 2006 Cours dAlgorithmique Logique de Hoare (début) : Principes et constructions élémentaires.

IFT313 Introduction aux langages formels Froduald Kabanza Département dinformatique Université de Sherbrooke Analyseurs récursifs LL (1)