Introduction la Programmation Objet : [5pt] R cursivit ...icsam/ipo/documents/cours12.pdf · Récursion Complexité algorithmique Calcul de complexité Annexes c EPFL 2002–2012

Récursion

Complexitéalgorithmique

Calcul decomplexité

Annexes

c©EPFL 2002–2012J. Sam

Introduction à la Programmation Objet :

RécursivitéAlgorithmique et complexité

Laboratoire d’Intelligence ArtificielleFaculté I&C

IPO – Cours 12 :– Récursivité | Complexité– – 1 / 56

Récursion



Annexes


Objectifs

◮ Introduire la notion de récursion◮ Introduire les bases de l’algorithmique◮ Introduire la notion de complexité algorithmique◮ Vous apprendre à comparer deux algorithmes


Récursion



Annexes


Récursion

La plupart des problèmes (par exemple, le tri d’un tableau, lecalcul d’une équation), peuvent être résolus de différentes façons :☞ différents algorithmesUne catégorie particulière de solutions est constituée desméthodes de résolution récursives .Le principe de l’approche récursive est de

ramener le problème à résoudre à un sous-problème,version simplifiée du problème d’origine.

☞ Exemple en mathématiques : le raisonnement par récurrence


Récursion



Annexes


Exemple : Les tours de Hanoï

Jeu des tours de Hanoï :déplacer une colonne de disques d’un pilier à un autre

◮ en utilisant un seul pilier de transition (c’est-à-dire 3 piliers entout)

◮ en ne posant un disque que sur le sol ou sur un disque plusgrand.


Récursion



Annexes


Les tours de Hanoï (2)

Idée : si je sais le faire pour une pile de n disques,je sais le faire pour n+1 disques

Démonstration :◮ Déplacer les n disques du haut sur le pilier de transition

(en utilisant la méthode que je connais par hypothèse)◮ Mettre le dernier disque sur le pilier destination◮ Redéplacer la tour de n disques du pilier de transition au pilier

destination (en utilisant le pilier initial comme transition).

��

��

��

��

��

��

��

��


Récursion



Annexes


Autre(s) exemple(s)

Calculer la somme des n premiers entiers.Si je sais le faire pour n, je sais le faire pour n+1 :

S(n+1) = (n+1)+S(n)

Note : se généralise trivialement au calcul de toute grandeurdéfinie par une équation de récurrence.


Récursion



Annexes


Algorithme récursif

Le schéma général d’un algorithme récursif est le suivant :

monalgo_recentrée : . . .sortie : . . .

. . .monalgo_recentrée : entrée du sous-problème

. . .

Exemple :

sommeentrée : nsortie : S(n)

sommeentrée : n−1sortie : m

S(n) = n+m


Récursion



Annexes


Algorithme récursif

Attention! Pour que la résolution récursive soit correcte , il fautune

condition de terminaison

sinon, on risque une boucle infinie.

Exemple :

sommeentrée : 3sortie : –

sommeentrée : 2

3+ . . .


sommeentrée : 1

2+ . . .


sommeentrée : 0

1+ . . .


sommeentrée : -1

0+ . . .

. . .


Récursion



Annexes


Algorithme récursif (correct)

Le schéma général correct d’un algorithme récursif est donc lesuivant :

monalgo_recentrée : Xsortie : Y

si terminaison(X)alors Y ← . . .

sinon. . .

monalgo_recentrée : entrée de l’instance réduitesortie : . . .

. . .

. . .


Récursion



Annexes


Exemple (1)

Reprenons la somme des n premiers entiers positifs

sommeentrée : nsortie : S(n)

si n ≤ 0alors S(n) = 0sinon

sommeentrée : n−1sortie : m

S(n) = n+m


Récursion



Annexes


Exemple (2)

sommeentrée : 3sortie : S(3)

si 3≤ 0alorsS(3) = 0sinon

sommeentrée : 2sortie : 3

S(3) = 3+3




S(2) = 2+1




S(1) = 1+0



sommeentrée : −1sortie : m

S(0) = 0+m

S(3) = 6


Récursion



Annexes


Les méthodes récursives

Concrètement, un algorithme récursif sera implémenté en Javapar une/plusieurs méthodes récursivesComme la définition d’une méthode (i.e., son corps) peut faireappel à toute méthode accessible depuis un programme, elle peutdonc, en particulier, faire appel à elle-même.Une méthode qui fait appel à elle-même dans sa définition estappelée méthode récursive .☞ Pour être effectivement utilisable, une méthode récursive doitégalement contenir une condition d’arrêt .

> java Hanoijava.lang.StackOverflowErrorat Hanoi.hanoi(Hanoi.java:39)at Hanoi.hanoi(Hanoi.java:40)at Hanoi.hanoi(Hanoi.java:40)at Hanoi.hanoi(Hanoi.java:40)at Hanoi.hanoi(Hanoi.java:40)...


Récursion



Annexes


Les méthodes récursives

Le schéma général d’une méthode récursive est donc le suivant :

type nom(type1 arg1, type2 arg2, ... ) {type1 y1;type2 y2;if (terminaison(arg1, arg2, ...)) {

...} else {

...nom(y1,y2,...)...

}}

même nom


Récursion



Annexes


Les méthodes récursives (3)

Exemple de méthode récursive : la somme des n premiers entierspositifs

static int somme(int n) {if (n <= 0) // condition d’arretreturn 0;

elsereturn (n + somme(n- 1));

}


Récursion



Annexes


Remarque

Notez qu’il est parfois beaucoup mieux d’écrire la méthode sousune autre forme que la forme récursive.Si l’on reprend l’exemple de la somme des n premiers entiers :

S(n+1) = (n+1)+S(n)

mais on a aussi (!) :

S(n) =n

∑i=1

i

On préfèrera alors programmer le calcul de S(n) comme uneboucle (solution itérative) :

for ( int i= 1, s= 0; i <= n ; i++) {s += i;

}

plutôt que sous forme récursive !..Exercice : Comparer la vitesse des deux méthodes.


Récursion



Annexes


Remarque (2)

...voire utiliser une expression analytique, lorsqu’on en a une !Par exemple :

S(n) =n (n+1)

2que l’on pourra directement calculer par :

n * (n+ 1) / 2

Note : on peut toujours “dérécursifier” une fonction

récursive.C’est-à-dire en trouver un équivalent itératif.(mais on n’a pas toujours une solution analytique au problème !)


Récursion



Annexes


Exemple: factorielle

◮ Définition

fact(x) ={

x · fact(x −1) x > 11 x = 1

◮ Implémentation récursive:

public static int fact( int x) {if (x== 1) {return 1;

}else {return x* fact(x- 1);

}}


Récursion



Annexes


Exemple: factorielle (2)

◮ Implémentation itérative:

public static int fact_iter( int x) {int result= 1;for ( int i= 1; i<=x; i++) {

result * =i;}return result;

}


Récursion



Annexes


Exemple: Suite de Fibonacci

◮ Définition

fib(x) ={

fib(x −1)+fib(x −2) x > 21 x ≤ 2

◮ Implémentation récursive:

public static int fib( int x) {if (x< 3) {return 1;

}else {return fib(x- 1)+fib(x- 2);

}}


Récursion



Annexes


Exemple: Suite de Fibonacci (2)

◮ Implémentation itérative:

public static int fib_iter( int x) {int prev= 1;int prev2= 1;int result= 1;for ( int i= 3; i<=x; i++) {

result=prev+prev2;prev2=prev;prev=result;

}return result;

}


Récursion



Annexes


Suite de Fibonacci: Performances

x t(fib) [ms] t(fib_iter) [ms] fib(x)10 0 0 5520 2 0 676530 114 0 83204035 265 0 922746540 1444 0 10233415541 2456 0 16558014142 3199 0 26791429643 5767 0 43349443744 7303 0 70140873345 10972 0 113490317046 19027 0 1836311903

◮ Pour fib(46) , la solution récursive prend 19 secondes, alorsque le même résultat est obtenu en moins d’une millisecondeavec l’implémentation itérative! (AMD Athlon64 3000+)


Récursion



Annexes


La récursion, pour quoi d’autre?

◮ “Diviser pour régner” (Divide & Conquer)◮ On divise le problème en 2 (ou plus) sous-problèmes et on

les résout (indépendamment). . .◮ Idée pour une recherche d’un élément dans une liste:

Recherche(Liste l, Elem e) {// gestion de la condition d’arret...

Recherche(Moitié_gauche_de_l, e);Recherche(Moitié_droite_de_l, e);

}


Récursion



Annexes


Exemple: Tri par fusion

On veut trier une liste L = x1, x2,. . . , xn, |L|= n◮ On divise L en deux sous-listes:

◮ L1 = x1,. . . , xi et L2 = xi+1,. . . , xn◮ |Li |= i et |L2|= j = n− i où i ≃ j (idéallement i = j)

◮ On trie séparément L1 et L2 (récursion!)◮ On a donc deux sous-listes triées L1,tri ee et L2,tri ee◮ On obtient Ltri ee en interclassant L1,tri ee et L2,tri ee

◮ Si |Li | ≤ 1, on dit que Li est triée◮ C’est la condition de terminaison de la récursion


Récursion



Annexes


Qualité d’un algorithme ?

Qu’est-ce qu’un bon algorithme ?

Y en a t il des meilleurs que d’autres ?

En clair :Comment comparer différents algorithmes (résolvant le mêmeproblème) ?

Deux points de vue :◮ rapidité : combien de temps ?◮ taille des ressources : combien de place mémoire ?

Mais peut-on comparer objectivement ?c’est-à-dire indépendamment de la réalisation de l’algorithme surune machine donnée dans un langage donné ? (nous voulonscomparer des algorithmes, pas des programmes)


Récursion



Annexes


Notion de complexité : introduction

La complexité d’un algorithme est une fonction qui mesure :

◮ le temps d’exécution (complexité temporelle , la plusutilisée),

◮ ou encore la quantité de mémoire (complexité spatiale ),

requis(e) pour la mise en œuvre de cet algorithme sur un certainjeu de données (variable).La complexité est donc fonction de la taille n du jeu de données.

On distigue de plus la complexité pire cas (la plus utilisée) de lacomplexité moyenne.


Récursion



Annexes


Mesure de la complexité (1/2)

Il est possible de déterminer la complexité (temporelle ou spatiale)d’un algorithme de façon théorique

☞ Machine de Turing

Les machines de Turing sont des automates abstraits quiconstituent une notion centrale en informatique, car ellespermettent de donner :

1. une définition précise à la notion informelle d’algorithme

2. une base théorique solide aux notions importantes que sontla calculabilité , la décidabilité et la complexité .

Dans la pratique, cette machine de Turing est rarementdisponible...


Récursion



Annexes


Mesure de la complexité (2/2)

En pratique l’on mesure donc la complexité par le nombred’instructions élémentaires nécessaires à l’exécution del’algorithme.

Par instruction élémentaire, nous entendrons ici toute instructionpour laquelle il a été prouvé au moyen d’une machine de Turingqu’elle peut-être utilisé en un nombre d’opération borné par uneconstante connue a priori.


Récursion



Annexes


instructions élémentaires

Exemples d’instructions élémentaires :◮ écrire un caractère à l’écran◮ lire un caractère dans un fichier◮ affecter une valeur atomique (un caractère, un entier, un réel,

...) à une variable(mais l’affectation d’une valeur composée peut ne pascorrespondre à un nombre constant de déplacements en casde dépendance par rapport au nombre d’éléments constituantla valeur composée)

◮ (parfois : réaliser une opération arithmétique sur des valeursatomiques)


Récursion



Annexes


Complexité: notation O(...)

Pour comparer des algorithmes, ce qui nous intéresse c’est desavoir comment leur complexité évolue en fonction de la taille desdonnées en entrée.

Pour cela on effectue des comparaisons sur les ordres degrandeur asymptotiques (quand la taille des données en entréetend vers l’infini)Ces ordres de grandeur sont généralement notés en utilisant lanotation de Landau O(...)

Pour deux fonctions f et g de R dans R, on écrit :

f = O(g)

si et seulement si

∃c > 0;∃x0|∀x > x0; |f (x)| ≤ c · |g(x)|

Dans ce cas, on dit que f est « en grand O » de g.IPO – Cours 12 :– Récursivité | Complexité– – 29 / 56

Récursion



Annexes


Notation O(...)

Quelles opérations sont possibles avec la notation de Landau?

◮ Transitivité◮ Si f est O(g) et g est O(h), alors f est O(h)

◮ Changement d’échelle◮ Si f est O(g) alors pour tout k > 0, f est O(k ·g)

◮ Somme◮ Si f1 est O(g1) et f2 est O(g2), alors f1 + f2 est O(max(g1,g2))

◮ Produit◮ Si f1 est O(g1) et f2 est O(g2), alors f1 · f2 est O(g1 ·g2)


Récursion



Annexes


Notation « grand O » : exemple

f (n) = n2 +100n+ logn+1000

n f (n) n2 100n logn 1000valeur % valeur % valeur % valeur %

1 1’101 1 0.1 100 9.1 0 0 1000 90.8210 2’101 100 4.8 1’000 47.6 1 0.0 1000 47.6

100 21’002 10’000 47.6 10’000 47.6 2 0.0 1000 4.8103 1’101’003 106 90.8 105 9.1 3 0.0 1000 0.1104 101’001’004 108 99.0 106 1.0 4 0.0 1000 0.0

...


Récursion



Annexes


Notation « grand O » : exemple (suite)

f (n) = n2 +100n+ logn+1000

1

10

100

1000

10000

100000

1e+06

1e+07

1e+08

1 10 100 1000 10000

f(n)n*n

100*nlog(n)1000


Récursion



Annexes


Comparaison d’algorithmes

En pratique pour mesurer la complexité d’un algorithme on utiliseévidemment le plus petit des « grands O » possibles

Exemples :

n est O(n2) mais n est aussi O(n)12 est O(n2), O(n), mais surtout O(1)

Différentes classes de complexité permettent alors de caractériserles algorithmes (n représentant la taille d’entrée) :

◮ complexité constante O(1) : le nombre d’éléments n’a pasd’influence sur l’algorithme

◮ complexité logarithmique O(logn)◮ complexité linéaire O(n)◮ complexité quasi-linéaire O(n log(n))◮ complexité polynomiale O(n2), ... O(nk )◮ complexité exponentielle O(2n)


Récursion



Annexes


Calcul de complexité

◮ le coût d’instructions en séquence est la somme des coûts de chacune desinstructions

C(I1; I2) = C(I1)+C(I2)

◮ d’où le coût d’une boucle (for ou while ) :

C(boucle q fois B(i)) =q

∑i=1

C(B(i))

où B(i) est un bloc d’instructions correspondant à la ième itération de laboucle

Dans les cas les plus simples, c’est le produit du coût du bloc répété par lenombre de fois que se fait la boucle

☞ une des difficultés principale (à part dans les cas triviaux) est de trouvercombien de fois s’éxecute la boucle

◮ Pour les appels récursifs : on écrit l’équation de récurrence


Récursion



Annexes


Analyse de complexité : exemple

Exemple : recherche d’un élément dans une liste triéeSoit l’algorithme suivant :

appartient1entrée : x, Esortie : x ∈ E ?

tailleentrée : Esortie : t

Pour i de 1 à tSi x = E [i]

x ∈ Ex 6∈ E

Par exemple implémenté en Javacomme cela :

boolean appartient1(type x, Liste E){

for ( int i= 0; i < taille(E); i++){

if (x==E[i]) return true;}return false;

}

Quelle est la complexité de appartient1 ?


Récursion



Annexes


Analyse de complexité : exemple (2)

Analyse de la complexité de appartient1(x,E) :

Taille des entrées : les entrées sont constituées d’un élément x etd’une liste E de m=taille(E) éléments du même type que x .La taille d’un codage binaire de la séquence d’entrée pourra êtrede la forme : K · (m+1) et l’on pourra donc prendre mcommemesure de référence.

Instructions élémentaires utilisées :

1. l’affectation d’une valeur à une variable entière ;

2. le calcul de la taille d’une liste d’entiers ;

3. la comparaison de deux valeurs entières (avec < et ==) ;

4. l’incrément d’une valeur entière ;

5. l’accès au i-ème élément d’une liste ;

6. le renvoi d’une valeur booléenne.


Récursion



Annexes


Analyse de la complexité : exemple (3)

Remarques a propos des instructions élémentaires :◮ Pour des entiers codés sur un nombre fixe de bits, les

instructions (1), (3), (4) et (6) peuvent être réalisées en unnombre constant de déplacements d’une machine de Turing.☞ Ces instructions pourront donc être associées à un coûtunité lors du calcul de complexité.


Récursion



Annexes


Par contre, pour les instructions (2) et (5), la situation est pluscompliquée, car dépendante de la représentation qui est utiliséepour les listes :

◮ En effet, selon que cette représentation contient ou non defaçon explicite l’indication de la taille, le calcul de cettedernière pourra être réalisé :

◮ soit en un nombre constant d’étapes (mémorisation explicite dela taille)

◮ soit en un nombre d’étapes dépendant du nombre d’élémentsde la liste (parcours + sommation)

◮ De même, selon que la liste est représentée ou non par unestructure de données permettant un accès direct à seséléments (tableau, vecteur), l’accès au ième élément pourrase faire:

◮ soit en un nombre constant d’étapes (accès direct)◮ soit à nouveau en un nombre d’étapes dépendant du nombre

d’éléments de la liste (parcours).


Récursion



Annexes



Dans le cas où la liste E est représentée par un structure dedonnées permettant le calcul de la taille de E et l’accès à soni-ème élément en un temps constant, l’analyse de la complexitéde appartient1(x,E) est la suivante :

(1) affectation de la valeur 0 à la variable i 1 instruction(2) calcul de la taille de E et vérification de la

condition (i<taille(E) )2 instructions

(3) accès au i-ème élément de E et comparaisonde cet élément avec x

2 instructions

(4) décrément (de 1) de i et retour en (2) 1 instruction

Par construction de l’algorithme, les étapes (2), (3) et (4) seront faites au plusautant de fois qu’il y a d’éléments dans E, donc m=taille(E) fois. Si C1(m) est lenombre d’instructions élémentaires nécessaires pour réaliser l’algorithmeappartient1(x,E) , on a donc :

C1(m) = 1+5m = O(m)


Récursion



Annexes



Supposons maintenant que la liste E est représentée par unstructure de données ne permettant pas le calcul de la taille de Een temps constant.

Supposons par exemple que le calcul de taille(E) est en a+b ·minstructions (donc en O(m)).

L’analyse de la complexité de appartient1(x,E) est lasuivante :

pour l’étape 1 : 1 instructionpour l’étape 2 : 1+a+b ·m instructionspour l’étape 3 : 2 instructionspour l’étape 4 : 1 instruction

et on aura :

C1′(m) = 1+m (1+a+bm+3) = O(m2)


Récursion



Annexes



Mais si l’on modifie très légèrement l’algorithme de la façonsuivante :

boolean appartient2(type x, Liste E) {for ( int i= 0, j=taille(E); i<j; i++) {if (x == E[i]) return ( true); }

return ( false);}

Les nombres d’instructions élémentaires pour les étapes seront

alors :

pour l’étape 1 : 1+a+b ·m instructionspour l’étape 2 : 1 instructionpour l’étape 3 : 2 instructionspour l’étape 4 : 1 instruction

et on aura donc:

C2(m) = 1+a+bm+m (1+2+1)) = O(m)

☞ algorithme linéaire


Récursion



Annexes


Autre exemple

Calcul récursif des nombres de Fibonacci

Fibonacci Récursifentrée : nsortie : F (n)

Si n = 0F (n) = 0

Si n = 1F (n) = 1

SinonFibonacci Récursifentrée : n−1sortie : p

Fibonacci Récursifentrée : n−2sortie : q

F (n) = p+q

int fibonacci( int n) {if (n == 0)return 0;

else if (n == 1)return 1;

elsereturn fibonacci(n- 1)

+ fibonacci(n- 2);}


Récursion



Annexes


Complexité de la version recursive desnombres de Fibonnacci

A: coût des tests et B: coût de l’addition

C(0) = A

C(1) = A

C(n) = A+C(n−1)+C(n−2)+B

Résolution (voir annexe mathématique) :

C(n) =2A+B√

5

(

Φn+1−Φn+1

)

−A−B

avec Φ= 1+√

52 (nombre d’or) et Φ= 1−

√5

2d’où

C(n) = O(Φn)

(notez que |Φ|< 1)☞ algorithme exponentiel


Récursion



Annexes


Autre exemple (suite)Calcul itératif de Fibonacci

Fibonacci Itératifentrée : nsortie : F (n)

y ← 0z← 1Pour i de 1 à n

x ← y +zz← yy ← x

F (n) = x

int fibonacci( int n) {int fn1 = 0;int fn2 = 1;int fn = 1;for ( int i= 1; i <= n; i++){

fn = fn1 + fn2;fn2 = fn1;fn1 = fn;

}return fn;

}

C′(n) = 1+1+n

∑i=1

(D+3) = (D+3) ·n+2

avec D coût de l’addition

C′(n) = O(n)

☞ algorithme linéaireIPO – Cours 12 :– Récursivité | Complexité– – 44 / 56

Récursion



Annexes


Ce que j’ai appris aujourd’hui

◮ Ce qu’était une résolution récursive d’un problème◮ Comment implémenter (proprement) des fonctions

récursives :◮ condition d’arrêt◮ appel (récursif) du/des sous-problème(s)

◮ Comment comparer des algorithmes : notion de complexitéalgorithmique


Récursion



AnnexesNotation « grandO » : calcul

Machine de Turing

Fibonacci récursif


g(n) = 2n2+14n log(n)+12log(n)

Comment traduire en notation « grand O » . . .

O(2n2 +14n log(n)+12log(n)) = O(max(2n2,14n log(n),12log(n)))= O(2n2) par la somme

O(2n2) = O(n2) par le changement d’échelle

O(2n2 +14n log(n)+12log(n)) = O(2n2)

O(2n2) = O(n2)

}

par la transitivité, on a donc:

O(2n2 +14n log(n)+12log(n)) = O(n2)


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing : définition

Automate abstrait , constitué des éléments suivants :

◮ une bande infinie (i.e., de taille non bornée),

◮ cellules pouvant “stocker” des caractères (∈ ensemble fini Σ)

◮ une tête de lecture/écriture , pouvant :

◮ lire et modifier le caractère courant◮ se déplacer d’une cellule vers la gauche ou vers la droite

◮ un ensemble fini E d’états internes (fonctionnement de la machine)

◮ une table de transitions indiquant, pour chaque couple(état interne, caractère courant)

une nouvelle valeur pour ce couple, ainsi que le déplacement de la tête delecture/écriture.Dans la table de transitions, chaque couple est donc associé à un triplet :

(nouvel état interne, nouveau caractère, déplacement)Application :

E×Σ 7→ E ×Σ×{−1,1}


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing : exemple

Σ= {0,1,ε}E = {1,2}

1 1 100

3

... ...

0 1 ε

1 (1,0,+) (1,0,+) (2,ε,-)

2 (2,0,-) (2,0,-) (3,ε,+)

caractèrecourantétat

courant

avec+ (respect.-) indiquant un déplacementvers la droite (respect. vers la gauche).


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing: fonctionnement

1. la bande est initialisée avec la séquence de caractèrescorrespondant aux (à un codage des) données d’entrée,

2. la tête de lecture/écriture est positionnée sur la cellule initiale de labande (disons 0), et l’état interne est positionné à sa valeur initiale(qui fait partie de la définition de la machine),

3. tant que le couple courant (état interne, caractère courant) estprésent dans la table de transitions, le triplet(état interne[nouveau], caractère[nouveau], déplacement)est utilisé pour mettre à jour l’état interne, le caractère courant, puisle déplacement de la tête de lecture/écriture est effectué,

4. si le couple (état interne, caractère courant) n’est pas dans latable de transitions, la machine s’arrête.Le contenu de la bande à ce moment-là est considéré comme lerésultat du traitement.


Récursion




Machine de Turing

Fibonacci récursif


Exemple de fonctionnement

machine de Turing déterminant si un nombre est pair

Entrée : le nombre à tester, sous forme binaireSortie : 1 si le nombre est pair, 0 sinon

0 1 ε

1 (1,0,+) (1,1,+) (2,ε,-)

2 (3,ε,-) (4,ε,-) x

3 (3,ε,-) (3,ε,-) (5,1,+)

4 (4,ε,-) (4,ε,-) (5,0,+)

5 x x (6,ε,-)

caractèreétat

Exemple pour l’entrée 2

1 0 εε

1

1 0 εε

1

1 0 εε

1

1 0 εε

2

1 ε εε

3

ε ε εε

3

ε ε ε1

5

ε ε ε1

5

déplace à droite

déplace à droite

déplace à droitejusqu’à la fin

détecte la fin droite,revient sur le derniercaractère

revient sur ledernier caractère

revient au débuten effaçant tout

efface età gauche

résultat età droite

repositionne audébut et termine


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing: forme canonique

On voit qu’une machine de Turing est caractérisée par1. sa logique générale de fonctionnement ;2. le codage de ses entrées et sorties (par exemple sous forme de

séquences binaires) ;3. la table de transitions décrivant son fonctionnement.

Si l’on impose de coder les entrées et les sorties sous forme binaire (etle caractère ε indique l’absence de caractère dans une cellule), on obtientune représentation uniforme des machines de Turing, appeléereprésentation canonique .

Remarque :

D’autres choix sont possibles pour la définition des machines de Turing (plusieurs

bandes, autres opérations élémentaires, autres alphabets de caractères, ...) mais

on peut montrer que les résultats théoriques obtenus avec de telles machines sont

équivalents à ceux obtenus à l’aide d’une machine de Turing canonique.


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing universelle (1)

Le fonctionnement d’une machine de Turing est conditionné parsa table de transition.

=⇒ machine de Turing = abstraction d’automate decomportement modifiable a priori ...

...mais pas encore automate programmable, pour laquelle leprogramme doit faire partie des données d’entrée de lamachine(et non pas représenter un élément constitutif de la machinecomme la table de transitions)

Si l’on désire qu’une machine de Turing constitue une abstractionpour la notion d’automate programmable, il faut donc que sa tablede transition soit fixe , et que le conditionnement de sonfonctionnement soit entièrement imposé par ses donnéesd’entrées.


Récursion




Machine de Turing

Fibonacci récursif


Machine de Turing universelle (2)

C’est-à-dire que bien qu’ayant une table de transition fixe ellepuisse effectuer des tâches différentes décrites uniquement parses données d’entrée (ces données d’entrés sont donc à la fois leprogramme et les données au sens usuel)

Une telle machine, s’appelle la machine de Turing universelle(dépasse le cadre de ce cours)


Récursion




Machine de Turing

Fibonacci récursif


Annexe mathématique

Résolution de

C(0) = A

C(1) = A

C(n) = A+C(n−1)+C(n−2)+B

C(n)−C(n−1)−C(n−2) = A+B

Équation homogène associée :

C(n)−C(n−1)−C(n−2) = 0

r2− r −1 = 0

r =Φ=1+√

52

ou r =Φ=1−√

52


Récursion




Machine de Turing

Fibonacci récursif


Annexe mathématique (2)

=⇒ C(n) = λ1Φn +λ2Φ

n

Solution particulière de l’équation complète :

C(n) =−A−B

Solution générale :

C(n) = λ1Φn +λ2Φ

n−A−B

Résolution des conditions initiales :

λ1 +λ2−A−B = A

λ1 ·Φ+λ2 ·Φ−A−B = A


Récursion




Machine de Turing

Fibonacci récursif


Annexe mathématique (3)

λ1 =(2A+B)Φ√

5(1)

λ2 = − (2A+B)Φ√5

(2)

et finalement

C(n) =2A+B√

5

(

Φn+1−Φn+1

)

−A−B


Documents

Introduction la Programmation Objet : [5pt] R cursivit ...icsam/ipo/documents/cours12.pdf · Récursion Complexité algorithmique Calcul de complexité Annexes c EPFL 2002–2012