ALGORITHME RECURSIF :

sub Dplacer (nombre, de, , par) si nombre > 0 alors Dplacer (nombre-1, de, par, ) Bouger-un-disque (de, ) Dplacer (nombre-1, par, , de) fin-du-si fin-du-sub

COMPLEXITE DE LALGORITHME :

On dmontre par rcurrence : N = 1 : 2(1) -1= 1 cest vrai On suppose que cest juste pour lordre N : T(n)= 2(n) - 1 Et on la dmontre pour lordre n+1 :
T(n+1)= 2*T(n)+1 on remplace T(n) par 2(n)-1

=2(2(n)-1 )+1 = 2*2(n)-2+1 =2(n+1)+1

Ce qui donne : Avec la notation de landau cest une complexit exponentielle O(2(n)).

CODE SOURCE EN C :
#include<stdio.h> #include<time.h> void Tour(int nbdis,int A ,int B,int C); clock_t

temps_initial, /* temps initial en micro-secondes */ temps_final; /* temps final en micro-secondes */ float temps_cpu; main() { /* temps total en secondes */

int nbr;

printf("\nEntrez le nombre de disque\n"); scanf("%d",& nbr);

while (nbr<=0) { printf("\nErreur!!introduire un nombre >0:\n"); scanf("%d",& nbr); } //fin while

if(nbr > 0) { temps_initial = clock (); Tour(nbr,1,2,3); // 1 :disque A , 2 : disque B , 3 : disque C

temps_final = clock (); temps_cpu = (temps_final - temps_initial) * 1e-6;

printf("Le temps d'excution : %f",temps_cpu);

/**********************TOUR DE HANOI************************************/ void Tour(int nbdis,int A,int B,int C) {

if(nbdis==1) printf("\nDeplacer un disque de %d -> %d\n",A,B);

else {

Tour(nbdis-1,A,C,B); Tour(1,A,B,C); Tour(nbdis-1,C,B,A);

} //fin else

} //fin Tour

TABLEAU DU TEMPS DEXECUTION :

N T(s) 1 0,001 2 0,001 3 0,001 4 0,005 5 0,033 6 0,070 7 0,084

8 0,227

9 0,317

10 0,526

11 0,943

12 1,446

13 2,958

14 4,811

15 11,453

16 12,410

17 22,645

18 41,343

19 86,326

20 193,156

21 347,195

22 23 24 25 747,258 1640,115 3366,406 6328,825

Tableau Temps dExcution T(s) en fonction de N nombre de disques.

comparaison entre la complexit thorique et la complexit exprimentale:

Dans le tableau prcdent on remarque que : T(6)=~ 2*T(5) T(5)=~2*T(4)

Ainsi de suit donc T(n)=2*T(n)=2*2*T(n-1) =2*2.......2*T(1)=2(n-1)*T(1) Il s'agit d'une complexit exponentielle en O(2(n)). Donc effectivement, il y'a une correspondance entre le rsultat thorique et les mesures exprimentales.

ALGORITHME ITERATIF :
Dclarer les variables ; Initialiser la pile ; si (nbdis == 1) alors { printf("\nDeplacer un disque de %d -> %d\n",A,B); } Sinon { Tant que ( nbdis > 1 ){ Empiler contexte ; Nbdis-- ; Switch B et C ; } printf("\nDeplacer un disque de %d -> %d\n",A,B); Tant que (PileNonVide){

Depiler contexte ; printf("\nDeplacer un disque de %d -> %d\n",A,B); nbdis-- ; switch A et C ; Tant que (nbdis > 1 ){ Empiler contexte ; Nbdis-- ; Switch B et C ; } printf("\nDeplacer un disque de %d -> %d\n",A,B); } }

COMPLEXITE DE LALGORITHME :
Le dplacement s'effectue a chaque a chaque itration de la boucle pour donc coups fois avec coups=2n-1 tell que n = le nombre des disques. Donc la complexit de cet algorithme est en O(2n) #include <stdio.h> #include <time.h>

void Tour(int nbdis,int A ,int B,int C); typedef struct elt{int info ; struct elt *svt;}pile; void initpile (pile **sommet); void empiler ( pile **sommet, int x); void depiler (pile **sommet, int *x); int pilevide (pile *sommet); clock_t

temps_initial, /* temps initial en micro-secondes */ temps_final; /* temps final en micro-secondes */ float temps_cpu; main() { /* temps total en secondes */

int nbr;

printf("\nEntrez le nombre de disque\n"); scanf("%d",& nbr);

while (nbr<=0) { printf("\nErreur!!introduire un nombre >0:\n"); scanf("%d",& nbr); } //fin while

if(nbr > 0) { temps_initial = clock (); Tour(nbr,1,2,3); // 1 :disque A , 2 : disque B , 3 : disuqe C

temps_final = clock (); temps_cpu = (temps_final - temps_initial) * 1e-6;

printf("Le temps d'excution : %f",temps_cpu);

void Tour(int nbdis,int A,int B,int C){

int x,compteur = 0 ;

pile *s; s = (pile *) malloc(sizeof(pile)); initpile(&s); if (nbdis == 1) { printf("\nDeplacer un disque de %d -> %d\n",A,B); }

else { while (nbdis > 1){

empiler(&s,nbdis); empiler(&s,A);

empiler(&s,B); empiler(&s,C); nbdis = nbdis - 1 ; x = B; B = C; C = x;

printf("\nDeplacer un disque de %d -> %d\n",A,B);

while (!pilevide(s)){

depiler(&s,&C); depiler(&s,&B); depiler(&s,&A); depiler(&s,&nbdis);

printf("\nDeplacer un disque de %d -> %d\n",A,B);

nbdis = nbdis - 1 ; x = A; A = C; C = x;

while (nbdis > 1 ){ empiler(&s,nbdis); empiler(&s,A); empiler(&s,B); empiler(&s,C); nbdis = nbdis - 1 ; x = B; B = C; C = x; }

printf("\nDeplacer un disque de %d -> %d\n",A,B);

} } }

TABLEAU DU TEMPS DEXECUTION :

N T(s) 1 0,001 2 0,001 3 0,002 4 0,023 5 0,025 6 0,074 7 0,221

8 0,522

9 0,334

10 0,354

11 0,760

12 1,251

13 2,071

14 4,028

15 9,428

16 11,521

17 33,519

18 61,629

19 12,262

20 191,706

21 323,947

22 23 24 25 1145,439 1801,344 3474,351 6328,825

1. Comparaison entre la complexit thorique et la complexit exprimentale: On remarque que T(15)= 9,428=~ 2* 4,028=~2*T(14) Plus gnralis : T(n)=2*T(n-1) =2n-1T(1) Donc la complexit est en O(2n). On remarque qu'il y'a une correspondance entre le rsultat thorique et les mesures exprimentales.

Comparaison de la complexit thorique des 2 algorithmes:

Les deux algorithmes ont la mme complexits thoriques O(2n). On remarque que les deux graphes Itratif et rcursif: 1. ont la mme tangente ce qui veut dire qu'ils ont la mme complexit. 2. l'allure de graphe rcursif est lgrement moins rapide que celle de graphe itratif.

la mthode rcursive est plus performante que la mthode Itrative.

Donc