Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) : Équivalences entre programmes récursifs et programmes.

Présentation au sujet: "Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) : Équivalences entre programmes récursifs et programmes."— Transcription de la présentation:

1 Cours d'algorithmique 7 - Intranet 1 27 novembre 2006 Cours dAlgorithmique Dérécursion (début) : Équivalences entre programmes récursifs et programmes itératifs avec ou sans gestion de pile.

2 27 novembre 2006Cours d'algorithmique 7 - Intranet2 Trier et chercher, recherche textuelle Trier et chercher, recherche textuelle Listes et arbres Listes et arbres Le back-track Le back-track Arbres équilibrés Arbres équilibrés Récursivité et induction sur la structure Récursivité et induction sur la structure Divide and conquer Divide and conquer Minimax, alpha-beta Minimax, alpha-beta Dérécursion Dérécursion Divers problèmes particuliers Divers problèmes particuliers Logique de Hoare Logique de Hoare Programmation dynamique Programmation dynamique Complexité et calculabilité Complexité et calculabilité Les grandes lignes du cours

3 27 novembre 2006Cours d'algorithmique 7 - Intranet3 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile.

4 27 novembre 2006Cours d'algorithmique 7 - Intranet4 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile.

5 27 novembre 2006Cours d'algorithmique 7 - Intranet5 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile. Questions : Questions : – Comment passer du récursif à litératif et vice-versa ?

6 27 novembre 2006Cours d'algorithmique 7 - Intranet6 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile. Questions : Questions : – Comment passer du récursif à litératif et vice-versa ?

7 27 novembre 2006Cours d'algorithmique 7 - Intranet7 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile. Questions : Questions : – Comment passer du récursif à litératif et vice-versa ? – Et pourquoi on préfère souvent la récursion à litération...

8 27 novembre 2006Cours d'algorithmique 7 - Intranet8 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile. Questions : Questions : – Comment passer du récursif à litératif et vice-versa ? – Et pourquoi on préfère souvent la récursion à litération...

9 27 novembre 2006Cours d'algorithmique 7 - Intranet9 Introduction ----------------------------------------------------------------- Si nous programmons à laide de fonctions récursives : Si nous programmons à laide de fonctions récursives : – la gestion des différents appels est faite par le système, – à travers la gestion de la pile. 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 calculs – et donc gérer éventuellement une pile. Questions : Questions : – Comment passer du récursif à litératif et vice-versa ? – Et pourquoi on préfère souvent la récursion à litération...

10 27 novembre 2006Cours d'algorithmique 7 - Intranet10 Théorème fondamental ----------------------------------------------------------------- Tout programme qui comporte des itérations while et des fonctions récursives : Tout programme qui comporte des itérations while et des fonctions récursives : – peut être transformé en un programme qui comporte uniquement des fonctions récursives,

11 27 novembre 2006Cours d'algorithmique 7 - Intranet11 Théorème fondamental ----------------------------------------------------------------- Tout programme qui comporte des itérations while et des fonctions récursives : Tout programme qui comporte des itérations while et des fonctions récursives : – peut être transformé en un programme qui comporte uniquement des fonctions récursives, Tout programme qui comporte des itérations while et des fonctions récursives : Tout programme qui comporte des itérations while et des fonctions récursives : – peut être transformé en un programme qui comporte uniquement des itérations while,

12 27 novembre 2006Cours d'algorithmique 7 - Intranet12 Théorème fondamental ----------------------------------------------------------------- Tout programme qui comporte des itérations while et des fonctions récursives : Tout programme qui comporte des itérations while et des fonctions récursives : – peut être transformé en un programme qui comporte uniquement des fonctions récursives, – et même une seule fonction récursive. Tout programme qui comporte des itérations while et des fonctions récursives : Tout programme qui comporte des itérations while et des fonctions récursives : – peut être transformé en un programme qui comporte uniquement des itérations while, – et même une seule itération while.

13 27 novembre 2006Cours d'algorithmique 7 - Intranet13 Plan ----------------------------------------------------------------- R é C u R s I f V e R s i T é R a T i F ! ! !

14 27 novembre 2006Cours d'algorithmique 7 - Intranet14 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

15 27 novembre 2006Cours d'algorithmique 7 - Intranet15 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

16 27 novembre 2006Cours d'algorithmique 7 - Intranet16 Plan ----------------------------------------------------------------- Chaque appel récursif engendre au plus un autre appel ! Nombre dappels récursifs Un Deux

17 27 novembre 2006Cours d'algorithmique 7 - Intranet17 Plan ----------------------------------------------------------------- Chaque appel récursif engendre au plus un autre appel ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return(... f( )... ) return(... f( )... ) Nombre dappels récursifs Un Deux

18 27 novembre 2006Cours d'algorithmique 7 - Intranet18 Plan ----------------------------------------------------------------- Chaque appel récursif engendre au plus un autre appel ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return(... f( )... ) return(... f( )... ) f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else if (... ) if (... ) return(... f( )... ) return(... f( )... ) else else return(... f( )... ) return(... f( )... ) mais aussi : Nombre dappels récursifs Un Deux

19 27 novembre 2006Cours d'algorithmique 7 - Intranet19 Plan ----------------------------------------------------------------- Chaque appel récursif engendre au plus deux autres appels ! Nombre dappels récursifs Un Deux

20 27 novembre 2006Cours d'algorithmique 7 - Intranet20 Plan ----------------------------------------------------------------- Chaque appel récursif engendre au plus deux autres appels ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else if (... ) if (... ) return(... f( )... ) return(... f( )... ) else else return(... f( )... f( )... ) return(... f( )... f( )... ) Nombre dappels récursifs Un Deux

21 27 novembre 2006Cours d'algorithmique 7 - Intranet21 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux

22 27 novembre 2006Cours d'algorithmique 7 - Intranet22 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux On dit que lappel récursif est « terminal ».

23 27 novembre 2006Cours d'algorithmique 7 - Intranet23 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux On dit que lappel récursif est « terminal ». f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return( f(... ) ) return( f(... ) )

24 27 novembre 2006Cours d'algorithmique 7 - Intranet24 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux On dit que lappel récursif est « non terminal ».

25 27 novembre 2006Cours d'algorithmique 7 - Intranet25 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux On dit que lappel récursif est « non terminal ». f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return( h(... f( )... ) ) return( h(... f( )... ) ) La fonction « h » est lenveloppe !

26 27 novembre 2006Cours d'algorithmique 7 - Intranet26 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui

27 27 novembre 2006Cours d'algorithmique 7 - Intranet27 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui « h » est associative si, et seulement si, on a toujours : h ( a, h ( b, c ) ) = h ( h ( a, b ), c )

28 27 novembre 2006Cours d'algorithmique 7 - Intranet28 Remarque ----------------------------------------------------------------- « h » est associative si, et seulement si, on a toujours : h ( a, h ( b, c ) ) = h ( h ( a, b ), c )

29 27 novembre 2006Cours d'algorithmique 7 - Intranet29 Remarque ----------------------------------------------------------------- « h » est associative si, et seulement si, on a toujours : h ( a, h ( b, c ) ) = h ( h ( a, b ), c ) h a h bc

30 27 novembre 2006Cours d'algorithmique 7 - Intranet30 Remarque ----------------------------------------------------------------- « h » est associative si, et seulement si, on a toujours : h ( a, h ( b, c ) ) = h ( h ( a, b ), c ) h a h bc h c h ab

31 27 novembre 2006Cours d'algorithmique 7 - Intranet31 Remarque ----------------------------------------------------------------- « h » est associative si, et seulement si, on a toujours : h ( a, h ( b, c ) ) = h ( h ( a, b ), c ) h a h bc h c h ab = Les structures des arbres nimportent pas ! =

32 27 novembre 2006Cours d'algorithmique 7 - Intranet32 Plan ----------------------------------------------------------------- P R E S E N T A T I O N P R E S E N T A T I O N G E N E R A L E D E S C A S D E F I G U R E

33 27 novembre 2006Cours d'algorithmique 7 - Intranet33 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui

34 27 novembre 2006Cours d'algorithmique 7 - Intranet34 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui

35 27 novembre 2006Cours d'algorithmique 7 - Intranet35 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui « h » admet le neutre « e » si, et seulement si, on a toujours: h( e, a ) = a = h( a, e ) h( e, a ) = a = h( a, e )

36 27 novembre 2006Cours d'algorithmique 7 - Intranet36 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations !

37 27 novembre 2006Cours d'algorithmique 7 - Intranet37 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! !

38 27 novembre 2006Cours d'algorithmique 7 - Intranet38 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa !

39 27 novembre 2006Cours d'algorithmique 7 - Intranet39 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Il existe des transformations !

40 27 novembre 2006Cours d'algorithmique 7 - Intranet40 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Il existe des transformations !

41 27 novembre 2006Cours d'algorithmique 7 - Intranet41 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Il existe des transformations !

42 27 novembre 2006Cours d'algorithmique 7 - Intranet42 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Beurk ! ! ! ! ! Il existe des transformations !

43 27 novembre 2006Cours d'algorithmique 7 - Intranet43 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Beurk ! ! ! ! ! Il existe des transformations !

44 27 novembre 2006Cours d'algorithmique 7 - Intranet44 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Appréciations ! Sympas ! ! ! Assez sympa ! Beurk ! ! ! ! ! Il existe des transformations !

45 27 novembre 2006Cours d'algorithmique 7 - Intranet45 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Appréciations ! Itératif ! ! ! Récursif ! ! !

46 27 novembre 2006Cours d'algorithmique 7 - Intranet46 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

47 27 novembre 2006Cours d'algorithmique 7 - Intranet47 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

48 27 novembre 2006Cours d'algorithmique 7 - Intranet48 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

49 27 novembre 2006Cours d'algorithmique 7 - Intranet49 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux

50 27 novembre 2006Cours d'algorithmique 7 - Intranet50 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui

51 27 novembre 2006Cours d'algorithmique 7 - Intranet51 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui La fonction récursive est sa propre enveloppe !

52 27 novembre 2006Cours d'algorithmique 7 - Intranet52 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui La fonction récursive est sa propre enveloppe ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return( f(... f( )... ) ) return( f(... f( )... ) )

53 27 novembre 2006Cours d'algorithmique 7 - Intranet53 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui La fonction récursive est sa propre enveloppe ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return( f(... f( )... ) ) return( f(... f( )... ) ) La fonction enveloppe de « f » est « f » ! Lappel externe « f » est terminal.

54 27 novembre 2006Cours d'algorithmique 7 - Intranet54 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Une fonction « h » enveloppe les deux appels récursifs !

55 27 novembre 2006Cours d'algorithmique 7 - Intranet55 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Une fonction « h » enveloppe les deux appels récursifs ! f ( x ) = if (... ) if (... ) return( valeur ) return( valeur ) else else return( h(... f( )... f( )... ) ) return( h(... f( )... f( )... ) )

56 27 novembre 2006Cours d'algorithmique 7 - Intranet56 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non

57 27 novembre 2006Cours d'algorithmique 7 - Intranet57 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non

58 27 novembre 2006Cours d'algorithmique 7 - Intranet58 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non Appréciations !

59 27 novembre 2006Cours d'algorithmique 7 - Intranet59 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non Appréciations ! Transformation intéressante !

60 27 novembre 2006Cours d'algorithmique 7 - Intranet60 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non Appréciations ! Transformation intéressante ! Celle-là aussi !

61 27 novembre 2006Cours d'algorithmique 7 - Intranet61 Plan ----------------------------------------------------------------- Nombre dappels récursifs Un Deux Fonction auto-enveloppée Non Oui Enveloppe associative Oui Non Avec élément neutre Oui Non Appréciations ! Transformation intéressante ! Celle-là aussi ! Sans espoir ! ! !

62 27 novembre 2006Cours d'algorithmique 7 - Intranet62 Plan ----------------------------------------------------------------- D i S c U s S i O n D e S d I v E r S 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 F

63 27 novembre 2006Cours d'algorithmique 7 - Intranet63 Un appel récursif, terminal ----------------------------------------------------------------- Un seul appel récursif qui est terminal. Un seul appel récursif qui est terminal. Cest le cas de base, il est fondamental. Cest le cas de base, il est fondamental.

64 27 novembre 2006Cours d'algorithmique 7 - Intranet64 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui

65 27 novembre 2006Cours d'algorithmique 7 - Intranet65 Un appel récursif, terminal ----------------------------------------------------------------- Un seul appel récursif qui est terminal. Un seul appel récursif qui est terminal. Cest le cas de base, il est fondamental. Cest le cas de base, il est fondamental. Il se transforme en boucle while sans pile. Il se transforme en boucle while sans pile.

66 27 novembre 2006Cours d'algorithmique 7 - Intranet66 Un appel récursif, terminal ----------------------------------------------------------------- Un seul appel récursif qui est terminal. Un seul appel récursif qui est terminal. Cest le cas de base, il est fondamental. Cest le cas de base, il est fondamental. Il se transforme en boucle while sans pile. Il se transforme en boucle while sans pile. Les appels non terminaux avec une enveloppe associative se ramènent à ce cas. Les appels non terminaux avec une enveloppe associative se ramènent à ce cas.

67 27 novembre 2006Cours d'algorithmique 7 - Intranet67 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui

68 27 novembre 2006Cours d'algorithmique 7 - Intranet68 Un appel récursif, terminal ----------------------------------------------------------------- Un seul appel récursif qui est terminal. Un seul appel récursif qui est terminal. Cest le cas de base, il est fondamental. Cest le cas de base, il est fondamental. Il se transforme en boucle while sans pile. Il se transforme en boucle while sans pile. Les appels non terminaux avec une enveloppe associative se ramènent à ce cas. Les appels non terminaux avec une enveloppe associative se ramènent à ce cas. Tout ce qui ne se ramène pas à ce cas nécessitera une pile ! ! ! Tout ce qui ne se ramène pas à ce cas nécessitera une pile ! ! !

69 27 novembre 2006Cours d'algorithmique 7 - Intranet69 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : Exemple : – Soient des couples ( x, y ) avec x >= y. – On définit le « pgcd » comme ci-dessous. – La notation est proche dune notation mathématique. res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) )

70 27 novembre 2006Cours d'algorithmique 7 - Intranet70 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : Exemple : – Soient des couples ( x, y ) avec x >= y. – On définit le « pgcd » comme ci-dessous. – La notation est proche dune notation mathématique. res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) Lappel initial.

71 27 novembre 2006Cours d'algorithmique 7 - Intranet71 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : Exemple : – Soient des couples ( x, y ) avec x >= y. – On définit le « pgcd » comme ci-dessous. – La notation est proche dune notation mathématique. res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) Lappel initial. Lentête de définition.

72 27 novembre 2006Cours d'algorithmique 7 - Intranet72 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : Exemple : – Soient des couples ( x, y ) avec x >= y. – On définit le « pgcd » comme ci-dessous. – La notation est proche dune notation mathématique. res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) Lappel initial. Lentête de définition. Le corps de la définition : - lindentation importe. - les « return » sont implicites.

73 27 novembre 2006Cours d'algorithmique 7 - Intranet73 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : Exemple : – Soient des couples ( x, y ) avec x >= y. – On définit le « pgcd » comme ci-dessous. – La notation est proche dune notation mathématique. res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) Lappel initial. Lentête de définition. Le corps de la définition : - lindentation importe. - les « return » sont implicites.

74 27 novembre 2006Cours d'algorithmique 7 - Intranet74 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

75 27 novembre 2006Cours d'algorithmique 7 - Intranet75 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

76 27 novembre 2006Cours d'algorithmique 7 - Intranet76 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

77 27 novembre 2006Cours d'algorithmique 7 - Intranet77 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

78 27 novembre 2006Cours d'algorithmique 7 - Intranet78 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

79 27 novembre 2006Cours d'algorithmique 7 - Intranet79 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

80 27 novembre 2006Cours d'algorithmique 7 - Intranet80 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

81 27 novembre 2006Cours d'algorithmique 7 - Intranet81 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Les calculs réalisés sont les suivants : Les calculs réalisés sont les suivants : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

82 27 novembre 2006Cours d'algorithmique 7 - Intranet82 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Les calculs réalisés sont les suivants : Les calculs réalisés sont les suivants : – Si ( v ) alors a( v ) et sinon : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

83 27 novembre 2006Cours d'algorithmique 7 - Intranet83 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Les calculs réalisés sont les suivants : Les calculs réalisés sont les suivants : – Si ( v ) alors a( v ) et sinon : – Si ( ( v ) ) alors a( ( v ) ) et sinon : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

84 27 novembre 2006Cours d'algorithmique 7 - Intranet84 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Les calculs réalisés sont les suivants : Les calculs réalisés sont les suivants : – Si ( v ) alors a( v ) et sinon : – Si ( ( v ) ) alors a( ( v ) ) et sinon : – Si ( ( ( v ) ) ) alors a( ( ( v ) ) ), etc... res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

85 27 novembre 2006Cours d'algorithmique 7 - Intranet85 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Le résultat final sera : Le résultat final sera : res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

86 27 novembre 2006Cours d'algorithmique 7 - Intranet86 Un appel récursif, terminal ----------------------------------------------------------------- Ce programme est de la forme : Ce programme est de la forme : Le résultat final sera : Le résultat final sera : – a( ( v ) ) – avec k = i. i N et ( ( v ) ) – où i.... signifie « le plus petit i tel que ». k i I res <- pgcd( ( a, b ) ) pgcd ( ( m, n ) ) = si ( n = 0 ) si ( n = 0 ) m sinon sinon pgcd( ( n, m % n ) ) pgcd( ( n, m % n ) ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

87 27 novembre 2006Cours d'algorithmique 7 - Intranet87 Un appel récursif, terminal ----------------------------------------------------------------- Le programme itératif correspondant : Le programme itératif correspondant : ( m, n ) <- ( a, b ) while ( ( n = 0 ) ) ( m, n ) <- ( n, m % n ) ( m, n ) <- ( n, m % n ) res <- m

88 27 novembre 2006Cours d'algorithmique 7 - Intranet88 Un appel récursif, terminal ----------------------------------------------------------------- Le programme itératif correspondant : Le programme itératif correspondant : ( m, n ) <- ( a, b ) while ( ( n = 0 ) ) ( m, n ) <- ( n, m % n ) ( m, n ) <- ( n, m % n ) res <- m x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x )

89 27 novembre 2006Cours d'algorithmique 7 - Intranet89 Un appel récursif, terminal ----------------------------------------------------------------- Le programme itératif correspondant : Le programme itératif correspondant : ( m, n ) <- ( a, b ) while ( ( n = 0 ) ) ( m, n ) <- ( n, m % n ) ( m, n ) <- ( n, m % n ) res <- m x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x )

90 27 novembre 2006Cours d'algorithmique 7 - Intranet90 Un appel récursif, terminal ----------------------------------------------------------------- Le programme itératif correspondant : Le programme itératif correspondant : Le résultat sera dailleurs le même : Le résultat sera dailleurs le même : – a( ( v ) ) avec k = i. i N et ( ( v ) ) ( m, n ) <- ( a, b ) while ( ( n = 0 ) ) ( m, n ) <- ( n, m % n ) ( m, n ) <- ( n, m % n ) res <- m k i I x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x )

91 27 novembre 2006Cours d'algorithmique 7 - Intranet91 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

92 27 novembre 2006Cours d'algorithmique 7 - Intranet92 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

93 27 novembre 2006Cours d'algorithmique 7 - Intranet93 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

94 27 novembre 2006Cours d'algorithmique 7 - Intranet94 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

95 27 novembre 2006Cours d'algorithmique 7 - Intranet95 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

96 27 novembre 2006Cours d'algorithmique 7 - Intranet96 Un appel récursif, terminal ----------------------------------------------------------------- Donc, nous avons léquivalence fondamentale suivante : Donc, nous avons léquivalence fondamentale suivante : x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) )

97 27 novembre 2006Cours d'algorithmique 7 - Intranet97 Un appel récursif, terminal ----------------------------------------------------------------- Léquivalence se généralise à deux ou plusieurs arguments : Léquivalence se généralise à deux ou plusieurs arguments : x <- v y <- w while ( ( x, y ) ) m <- ( x, y ) m <- ( x, y ) y <- ( x, y ) y <- ( x, y ) x <- m x <- m res <- a( x, y ) res <- f( v, w ) f ( x, y ) = si ( ( x, y ) ) si ( ( x, y ) ) a( x, y ) a( x, y ) sinon sinon f( ( x, y ), f( ( x, y ), ( x, y ) ) ( x, y ) )

98 27 novembre 2006Cours d'algorithmique 7 - Intranet98 Un appel récursif, terminal ----------------------------------------------------------------- Exemple : « pgcd » comme fonction binaire : Exemple : « pgcd » comme fonction binaire : x <- v y <- w while ( ( y = 1 ) ) m <- y m <- y y <- x % y y <- x % y x <- m x <- m res <- x res <- pgcd( v, w ) pgcd ( x, y ) = si ( y = 1 ) si ( y = 1 ) x sinon sinon pgcd( y, x % y ) pgcd( y, x % y )

99 27 novembre 2006Cours d'algorithmique 7 - Intranet99 Un appel récursif, terminal ----------------------------------------------------------------- Un autre exemple : Un autre exemple : res <- fct( a ) fct ( x ) = si ( x = 1 ) si ( x = 1 ) x sinon sinon si ( pair( x ) ) si ( pair( x ) ) fct( x / 2 ) fct( x / 2 ) sinon sinon fct( 3 * x + 1 ) fct( 3 * x + 1 )

100 27 novembre 2006Cours d'algorithmique 7 - Intranet100 Un appel récursif, terminal ----------------------------------------------------------------- Un autre exemple : Un autre exemple : x <- a while ( ( x = 1 ) ) si ( pair( x ) ) si ( pair( x ) ) x <- x / 2 x <- x / 2 sinon sinon x <- 3 * x + 1 x <- 3 * x + 1 res <- x res <- fct( a ) fct ( x ) = si ( x = 1 ) si ( x = 1 ) x sinon sinon si ( pair( x ) ) si ( pair( x ) ) fct( x / 2 ) fct( x / 2 ) sinon sinon fct( 3 * x + 1 ) fct( 3 * x + 1 )

101 27 novembre 2006Cours d'algorithmique 7 - Intranet101 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux

102 27 novembre 2006Cours d'algorithmique 7 - Intranet102 Plan ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui

103 27 novembre 2006Cours d'algorithmique 7 - Intranet103 Un 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 ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) )

104 27 novembre 2006Cours d'algorithmique 7 - Intranet104 Un 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 : Si « h » est associative, nous pouvons nous ramener au cas récursif terminal précédent, Si « h » est associative, nous pouvons nous ramener au cas 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 ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) )

105 27 novembre 2006Cours d'algorithmique 7 - Intranet105 Un appel récursif, non-terminal ----------------------------------------------------------------- Posons simplement : Posons simplement : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) )

106 27 novembre 2006Cours d'algorithmique 7 - Intranet106 Un appel récursif, non-terminal ----------------------------------------------------------------- Posons simplement : Posons simplement : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) Pourquoi ? ? ? Parce que ça marchera ! ! ! Pourquoi ? ? ? Parce que ça marchera ! ! !

107 27 novembre 2006Cours d'algorithmique 7 - Intranet107 Un appel récursif, non-terminal ----------------------------------------------------------------- Posons simplement : Posons simplement : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) Pourquoi ? ? ? Parce que ça marchera ! ! ! Pourquoi ? ? ? 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 )

108 27 novembre 2006Cours d'algorithmique 7 - Intranet108 Un appel récursif, non-terminal ----------------------------------------------------------------- Posons simplement : Posons simplement : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) Pourquoi ? ? ? Parce que ça marchera ! ! ! Pourquoi ? ? ? 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 ) – Nous pouvons donc remplacer lappel f( v ) par lappel f( v ) par lappel F( e, v ) lappel F( e, v ) res <- f( v ) f ( x ) =......

109 27 novembre 2006Cours d'algorithmique 7 - Intranet109 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) )

110 27 novembre 2006Cours d'algorithmique 7 - Intranet110 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) « f » est remplacée par sa définition !

111 27 novembre 2006Cours d'algorithmique 7 - Intranet111 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) « f » est remplacée par sa définition !

112 27 novembre 2006Cours d'algorithmique 7 - Intranet112 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) Remarque ! On a « toujours » : Remarque ! On a « toujours » : h( x, si C alors A sinon B ) h( x, si C alors A sinon B ) = si C alors h( x, A ) sinon h( x, B ) si C alors h( x, A ) sinon h( x, B ) « f » est remplacée par sa définition !

113 27 novembre 2006Cours d'algorithmique 7 - Intranet113 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) = si ( ( x ) ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon h( acc, h( ( x ), f( ( x ) ) ) ) h( acc, h( ( x ), f( ( x ) ) ) ) « f » est remplacée par sa définition !

114 27 novembre 2006Cours d'algorithmique 7 - Intranet114 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) = si ( ( x ) ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon h( acc, h( ( x ), f( ( x ) ) ) ) h( acc, h( ( x ), f( ( x ) ) ) ) « f » est remplacée par sa définition ! Associativité !

115 27 novembre 2006Cours d'algorithmique 7 - Intranet115 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) = si ( ( x ) ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon h( acc, h( ( x ), f( ( x ) ) ) ) h( acc, h( ( x ), f( ( x ) ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) « f » est remplacée par sa définition ! Associativité !

116 27 novembre 2006Cours d'algorithmique 7 - Intranet116 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) = si ( ( x ) ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon h( acc, h( ( x ), f( ( x ) ) ) ) h( acc, h( ( x ), f( ( x ) ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) « f » est remplacée par sa définition ! Associativité ! Définition de F ! F( a, b ) = h( a, f( b ) )

117 27 novembre 2006Cours d'algorithmique 7 - Intranet117 Un appel récursif, non-terminal ----------------------------------------------------------------- Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : Il reste à exprimer F à laide delle-même et de manière récursive terminale. h est associative. Nous avons : F( acc, x ) = h( acc, f( x ) ) F( acc, x ) = h( acc, f( x ) ) = h( acc, si ( ( x ) ) = h( acc, si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) ) h( ( x ), f( ( x ) ) ) ) = si ( ( x ) ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon h( acc, h( ( x ), f( ( x ) ) ) ) h( acc, h( ( x ), f( ( x ) ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) h( h( acc, ( x ) ), f( ( x ) ) ) F( h( acc, ( x ) ), ( x ) ) F( h( acc, ( x ) ), ( x ) ) « f » est remplacée par sa définition ! Associativité ! Définition de F ! F( a, b ) = h( a, f( b ) )

118 27 novembre 2006Cours d'algorithmique 7 - Intranet118 Un appel récursif, non-terminal ----------------------------------------------------------------- Pour h est associative, nous obtenons donc la définition récursive terminale suivante : Pour h est associative, nous obtenons donc la définition récursive terminale suivante : F( acc, x ) = si ( ( x ) ) F( acc, x ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon F( h( acc, ( x ) ), ( x ) ) F( h( acc, ( x ) ), ( x ) )

119 27 novembre 2006Cours d'algorithmique 7 - Intranet119 Un appel récursif, non-terminal ----------------------------------------------------------------- Pour h est associative, nous obtenons donc la définition récursive terminale suivante : Pour h est associative, nous obtenons donc la définition récursive terminale suivante : F( acc, x ) = si ( ( x ) ) F( acc, x ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon F( h( acc, ( x ) ), ( x ) ) F( h( acc, ( x ) ), ( x ) )

120 27 novembre 2006Cours d'algorithmique 7 - Intranet120 Un appel récursif, non-terminal ----------------------------------------------------------------- Pour h est associative, nous obtenons donc la définition récursive terminale suivante : Pour h est associative, nous obtenons donc la définition récursive terminale suivante : F( acc, x ) = si ( ( x ) ) F( acc, x ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon F( h( acc, ( x ) ), ( x ) ) F( h( acc, ( x ) ), ( x ) ) Le programme itératif correspondant : Le programme itératif correspondant : while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) )

121 27 novembre 2006Cours d'algorithmique 7 - Intranet121 Un appel récursif, non-terminal ----------------------------------------------------------------- Pour h est associative, nous obtenons donc la définition récursive terminale suivante : Pour h est associative, nous obtenons donc la définition récursive terminale suivante : F( acc, x ) = si ( ( x ) ) F( acc, x ) = si ( ( x ) ) h( acc, a( x ) ) h( acc, a( x ) ) sinon sinon F( h( acc, ( x ) ), ( x ) ) F( h( acc, ( x ) ), ( x ) ) Le programme itératif correspondant : Le programme itératif correspondant : while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) Doù le nom daccumulateur !

122 27 novembre 2006Cours d'algorithmique 7 - Intranet122 Un appel récursif, non-terminal ----------------------------------------------------------------- Linitialisation est simple si « h » admet un neutre « e » : Linitialisation est simple si « h » admet un neutre « e » : f( v ) = F( e, v ) f( v ) = F( e, v ) x <- v acc <- e while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) )

123 27 novembre 2006Cours d'algorithmique 7 - Intranet123 Un appel récursif, non-terminal ----------------------------------------------------------------- Linitialisation est simple si « h » admet un neutre « e » : Linitialisation est simple si « h » admet un neutre « e » : f( v ) = F( e, v ) f( v ) = F( e, v ) x <- v acc <- e while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) )

124 27 novembre 2006Cours d'algorithmique 7 - Intranet124 Un appel récursif, non-terminal ----------------------------------------------------------------- Si « h » est associative avec neutre « e », nous avons : Si « h » est associative avec neutre « e », nous avons : res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) x <- v acc <- e while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) )

125 27 novembre 2006Cours d'algorithmique 7 - Intranet125 Un appel récursif, non-terminal ----------------------------------------------------------------- Léquivalence se généralise à deux ou plusieurs arguments : Léquivalence se généralise à deux ou plusieurs arguments : res <- f( v, w ) f ( x, y ) = si ( ( x, y ) ) si ( ( x, y ) ) a( x, y ) a( x, y ) sinon sinon h( ( x, y ), h( ( x, y ), f( ( x, y ), f( ( x, y ), ( x, y ) ) ) ( x, y ) ) ) x <- v y <- w acc <- e while ( ( x, y ) ) acc <- h( acc, ( x, y ) ) acc <- h( acc, ( x, y ) ) m <- ( x, y ) m <- ( x, y ) y <- ( x, y ) y <- ( x, y ) x <- m x <- m res <- h( acc, a( x, y ) )

126 27 novembre 2006Cours d'algorithmique 7 - Intranet126 Un appel récursif, non-terminal ----------------------------------------------------------------- Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : f( x ) = si ( ( x ) ) f( x ) = si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) )

127 27 novembre 2006Cours d'algorithmique 7 - Intranet127 Un appel récursif, non-terminal ----------------------------------------------------------------- Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : f( x ) = si ( ( x ) ) f( x ) = si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) F( ( x ), ( x ) ) F( ( x ), ( x ) )

128 27 novembre 2006Cours d'algorithmique 7 - Intranet128 Un appel récursif, non-terminal ----------------------------------------------------------------- Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : f( x ) = si ( ( x ) ) f( x ) = si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) F( ( x ), ( x ) ) F( ( x ), ( x ) ) x <- v si ( ( x ) ) res <- a( x ) res <- a( x )sinon acc <- ( x ) acc <- ( x ) x <- ( x ) x <- ( x ) while ( ( x ) ) while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) res <- h( acc, a( x ) )

129 27 novembre 2006Cours d'algorithmique 7 - Intranet129 Un appel récursif, non-terminal ----------------------------------------------------------------- Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : f( x ) = si ( ( x ) ) f( x ) = si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) F( ( x ), ( x ) ) F( ( x ), ( x ) ) x <- v si ( ( x ) ) res <- a( x ) res <- a( x )sinon acc <- ( x ) acc <- ( x ) x <- ( x ) x <- ( x ) while ( ( x ) ) while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) res <- h( acc, a( x ) ) Le premier élément est traité à part ! Et nous passons au second élément !

130 27 novembre 2006Cours d'algorithmique 7 - Intranet130 Un appel récursif, non-terminal ----------------------------------------------------------------- Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : Cest un peu plus embêtant si « h » est sans neutre. Nous devons alors traiter le premier appel « f( v ) » à part, en observant que : f( x ) = si ( ( x ) ) f( x ) = si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) F( ( x ), ( x ) ) F( ( x ), ( x ) ) x <- v si ( ( x ) ) res <- a( x ) res <- a( x )sinon acc <- ( x ) acc <- ( x ) x <- ( x ) x <- ( x ) while ( ( x ) ) while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) res <- h( acc, a( x ) ) Le premier élément est traité à part ! Et nous passons au second élément !

131 27 novembre 2006Cours d'algorithmique 7 - Intranet131 Un appel récursif, non-terminal ----------------------------------------------------------------- Si « h » est associative sans neutre, nous avons : Si « h » est associative sans neutre, nous avons : res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) x <- v si ( ( x ) ) res <- a( x ) res <- a( x )sinon acc <- ( x ) acc <- ( x ) x <- ( x ) x <- ( x ) while ( ( x ) ) while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) res <- h( acc, a( x ) )

132 27 novembre 2006Cours d'algorithmique 7 - Intranet132 Un appel récursif, non-terminal ----------------------------------------------------------------- Léquivalence se généralise à deux ou plusieurs arguments : Léquivalence se généralise à deux ou plusieurs arguments : res <- f( v, w ) f ( x, y ) = si ( ( x, y ) ) si ( ( x, y ) ) a( x, y ) a( x, y ) sinon sinon h( ( x, y ), h( ( x, y ), f( ( x, y ), f( ( x, y ), ( x, y ) ) ) ( x, y ) ) ) x <- v y <- w si ( ( x, y ) ) res <- a( x, y ) res <- a( x, y )sinon acc <- ( x, y) acc <- ( x, y) m <- ( x, y ) m <- ( x, y ) y <- ( x, y ) y <- ( x, y ) x <- m x <- m while ( ( x, y ) ) while ( ( x, y ) ) acc <- h( acc, ( x, y) ) acc <- h( acc, ( x, y) ) m <- ( x, y ) m <- ( x, y ) y <- ( x, y ) y <- ( x, y ) x <- m x <- m res <- h( acc, a( x ) ) res <- h( acc, a( x ) )

133 27 novembre 2006Cours d'algorithmique 7 - Intranet133 Sous forme darbre … -----------------------------------------------------------------

134 27 novembre 2006Cours d'algorithmique 7 - Intranet134 Sous forme darbre … ----------------------------------------------------------------- a( v ) a( v ) = ou bien = ou bien h ( v ) ( v ) f( ( v ) ) { f( v )

135 27 novembre 2006Cours d'algorithmique 7 - Intranet135 Sous forme darbre … ----------------------------------------------------------------- a( v ) a( v ) = ou bien = ou bien h ( v ) ( v ) f( ( v ) ) { f( v ) Continuons à développer ce deuxième terme !

136 27 novembre 2006Cours d'algorithmique 7 - Intranet136 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) )

137 27 novembre 2006Cours d'algorithmique 7 - Intranet137 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) )

138 27 novembre 2006Cours d'algorithmique 7 - Intranet138 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) )

139 27 novembre 2006Cours d'algorithmique 7 - Intranet139 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) ) Une valeur !

140 27 novembre 2006Cours d'algorithmique 7 - Intranet140 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) ) Une valeur ! Une autre valeur !

141 27 novembre 2006Cours d'algorithmique 7 - Intranet141 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) ) Une valeur ! Une autre valeur ! h e f( v ) Une valeur initiale !

142 27 novembre 2006Cours d'algorithmique 7 - Intranet142 Sous forme darbre … ----------------------------------------------------------------- = ou bien = ou bien h ( v ) ( v ) { h f( ( v ) ) h ( v ) ( v ) a( ( v ) ) h ( ( v ) ) ( ( v ) ) f( ( ( v ) ) ) Une valeur ! Une autre valeur ! h e f( v ) Une valeur initiale !

143 27 novembre 2006Cours d'algorithmique 7 - Intranet143 Le cas général ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1

144 27 novembre 2006Cours d'algorithmique 7 - Intranet144 ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 h ( v ) ) ( v ) ) f( ( v ) ) k k-1 h ( v ) ( v ) … Le cas général ----------------------------------------------------------------- f( v ) = h

145 27 novembre 2006Cours d'algorithmique 7 - Intranet145 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1

146 27 novembre 2006Cours d'algorithmique 7 - Intranet146 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Soit k = i. i N et ( ( v ) ) i I

147 27 novembre 2006Cours d'algorithmique 7 - Intranet147 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) = a( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Soit k = i. i N et ( ( v ) ) i I k res < - a( ( v ) ) k

148 27 novembre 2006Cours d'algorithmique 7 - Intranet148 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) = a( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Soit k = i. i N et ( ( v ) ) i I k res < - a( ( v ) ) k res < - h( ( v ) ), res ) k-1

149 27 novembre 2006Cours d'algorithmique 7 - Intranet149 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) = a( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Soit k = i. i N et ( ( v ) ) i I k res < - a( ( v ) ) k res < - h( ( v ) ), res ) k-1

150 27 novembre 2006Cours d'algorithmique 7 - Intranet150 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) = a( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Soit k = i. i N et ( ( v ) ) i I k res < - a( ( v ) ) k res < - h( ( v ) ), res ) k-1

151 27 novembre 2006Cours d'algorithmique 7 - Intranet151 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ?

152 27 novembre 2006Cours d'algorithmique 7 - Intranet152 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons !

153 27 novembre 2006Cours d'algorithmique 7 - Intranet153 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile

154 27 novembre 2006Cours d'algorithmique 7 - Intranet154 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile La dynamique ! ! !

155 27 novembre 2006Cours d'algorithmique 7 - Intranet155 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile ( v ) ( v ) La dynamique ! ! !

156 27 novembre 2006Cours d'algorithmique 7 - Intranet156 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile ( ( v ) ) ( ( v ) ) ( v ) ( v ) La dynamique ! ! !

157 27 novembre 2006Cours d'algorithmique 7 - Intranet157 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile... ( ( v ) ) ( ( v ) ) ( v ) ( v ) La dynamique ! ! ! ( ( v ) ) ( ( v ) )

158 27 novembre 2006Cours d'algorithmique 7 - Intranet158 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile ( v ) ) ( v ) ) k-1... ( ( v ) ) ( ( v ) ) ( v ) ( v ) La dynamique ! ! !

159 27 novembre 2006Cours d'algorithmique 7 - Intranet159 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile... ( ( v ) ) ( ( v ) ) ( v ) ( v ) La dynamique ! ! ! ( v ) ) ( v ) ) k-1 res < - a( ( v ) ) k

160 27 novembre 2006Cours d'algorithmique 7 - Intranet160 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile... ( ( v ) ) ( ( v ) ) ( v ) ( v ) La dynamique ! ! ! res < - a( ( v ) ) k res < - h( ( v ) ) res ) k-1

161 27 novembre 2006Cours d'algorithmique 7 - Intranet161 Le cas général --- h non associative ----------------------------------------------------------------- f( v ) = h ( v ) ( v ) h ( v ) ) ( v ) ) f( ( v ) ) h ( ( v ) ) ( ( v ) )... kk-1 Ou sont-elles ? ? ? Sur la pile, voyons ! La pile La dynamique ! ! ! res < - a( ( v ) ) k res < - h( ( v ) ) res ) k-1 res < - h( ( v ) res )

162 27 novembre 2006Cours d'algorithmique 7 - Intranet162 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p )

163 27 novembre 2006Cours d'algorithmique 7 - Intranet163 Le cas général --- h non associative ----------------------------------------------------------------- Légende des fonctions : - I( ) initialise une pile vide. - E( e, p ) empile e sur p. - S( p ) rend une copie du sommet de p. - D( p ) supprime le sommet de p. - V( p ) dit si p est vide ou non. p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p )

164 27 novembre 2006Cours d'algorithmique 7 - Intranet164 Le cas général --- h non associative ----------------------------------------------------------------- Légende des fonctions : - I( ) initialise une pile vide. - E( e, p ) empile e sur p. - S( p ) rend une copie du sommet de p. - D( p ) supprime le sommet de p. - V( p ) dit si p est vide ou non. p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) V( I() ) = VRAI V( E( e, p ) ) = FAUX S( E( e, p ) ) = e D( E( e, p ) ) = p

165 27 novembre 2006Cours d'algorithmique 7 - Intranet165 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) Linitialisation !

166 27 novembre 2006Cours d'algorithmique 7 - Intranet166 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) Linitialisation ! Nous descendons en empilant les différents éléments.

167 27 novembre 2006Cours d'algorithmique 7 - Intranet167 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) Linitialisation ! Nous descendons en empilant les différents éléments. La valeur initiale du résultat !

168 27 novembre 2006Cours d'algorithmique 7 - Intranet168 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) Linitialisation ! Nous descendons en empilant les différents éléments. La valeur initiale du résultat ! Nous remontons en combinant les éléments empilés !

169 27 novembre 2006Cours d'algorithmique 7 - Intranet169 Le cas général --- h non associative ----------------------------------------------------------------- p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p ) Linitialisation ! Nous descendons en empilant les différents éléments. La valeur initiale du résultat ! Nous remontons en combinant les éléments empilés !

170 27 novembre 2006Cours d'algorithmique 7 - Intranet170 Un appel récursif, non-terminal ----------------------------------------------------------------- Si « h » nest pas associative, nous avons : Si « h » nest pas associative, nous avons : res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p )

171 27 novembre 2006Cours d'algorithmique 7 - Intranet171 Un appel récursif, non-terminal ----------------------------------------------------------------- Léquivalence se généralise à 2 ou plus darguments pour f : Léquivalence se généralise à 2 ou plus darguments pour f : res <- f( v, w ) f ( x, y ) = si ( ( x, y ) ) si ( ( x, y ) ) a( x, y ) a( x, y ) sinon sinon h( ( x, y ), h( ( x, y ), f( ( x, y ), f( ( x, y ), ( x, y ) ) ) ( x, y ) ) ) p <- I() x <- v y <- w while ( ( x, y ) ) p <- E( ( x, y ), p ) p <- E( ( x, y ), p ) m <- ( x, y ) m <- ( x, y ) y <- ( x, y ) y <- ( x, y ) x <- m x <- m res <- a( x, y ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p )

172 27 novembre 2006Cours d'algorithmique 7 - Intranet172 Un appel récursif, non-terminal ----------------------------------------------------------------- Léquivalence se généralise à 3 ou plus darguments pour h : Léquivalence se généralise à 3 ou plus darguments pour h : res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), h( ( x ), ( x ), ( x ), f( ( x ) ) ) f( ( x ) ) ) p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( 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 )

173 27 novembre 2006Cours d'algorithmique 7 - Intranet173 Un appel récursif --- résumé ----------------------------------------------------------------- R E S U M E P O U R U N A P P E L R E C U R S I F

174 27 novembre 2006Cours d'algorithmique 7 - Intranet174 Un appel récursif --- résumé ----------------------------------------------------------------- Fonction enveloppe Non Oui Nombre dappels récursifs Un Deux Enveloppe associative Non Oui Avec élément neutre Non Oui Cas 1) Cas 2) Cas 3) Cas 4) Nous retenons les quatre cas suivants !

175 27 novembre 2006Cours d'algorithmique 7 - Intranet175 Un appel récursif --- résumé ----------------------------------------------------------------- 1) Appel récursif terminal ! 1) Appel récursif terminal ! x <- v while ( ( x ) ) x <- ( x ) x <- ( x ) res <- a( x ) res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon f( ( x ) ) f( ( x ) ) Code itératif raisonnable !

176 27 novembre 2006Cours d'algorithmique 7 - Intranet176 Un appel récursif --- résumé ----------------------------------------------------------------- 2) Appel récursif avec enveloppe associative et neutre « e » ! 2) Appel récursif avec enveloppe associative et neutre « e » ! res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) x <- v acc <- e while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) Code itératif raisonnable !

177 27 novembre 2006Cours d'algorithmique 7 - Intranet177 x <- v si ( ( x ) ) res <- a( x ) res <- a( x )sinon acc <- ( x ) acc <- ( x ) x <- ( x ) x <- ( x ) while ( ( x ) ) while ( ( x ) ) acc <- h( acc, ( x ) ) acc <- h( acc, ( x ) ) x <- ( x ) x <- ( x ) res <- h( acc, a( x ) ) res <- h( acc, a( x ) ) Un appel récursif --- résumé ----------------------------------------------------------------- 3) Appel récursif avec enveloppe associative, sans neutre ! 3) Appel récursif avec enveloppe associative, sans neutre ! res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) Code itératif à peu près raisonnable !

178 27 novembre 2006Cours d'algorithmique 7 - Intranet178 Un appel récursif --- résumé ----------------------------------------------------------------- 4) Appel récursif avec enveloppe non associative ! 4) Appel récursif avec enveloppe non associative ! res <- f( v ) f ( x ) = si ( ( x ) ) si ( ( x ) ) a( x ) a( x ) sinon sinon h( ( x ), f( ( x ) ) ) h( ( x ), f( ( x ) ) ) Code itératif non raisonnable à cause de la gestion de pile ! p <- I() x <- v while ( ( x ) ) p <- E( ( x ), p ) p <- E( ( x ), p ) x <- ( x ) x <- ( x ) res <- a( x ) while ( V( p ) ) res <- h( S( p ), res ) res <- h( S( p ), res ) p <- D( p ) p <- D( p )

179 27 novembre 2006Cours d'algorithmique 7 - Intranet179 Dérécursion (début) : Équivalences entre programmes récursifs et programmes itératifs avec ou sans gestion de pile. Synthèse -----------------------------------------------------------------

180 27 novembre 2006Cours d'algorithmique 7 - Intranet180 m E r C i e T b O n N e J o U r N é E ! ! ! n O u B l I e Z p A s D e p R é P a R e R v O s T D ! ! !