. PGCD de deux nombres int PGCD(int A, int B){ int reste; reste = A % B; while (reste !

== 0) { A = B; B = reste; reste = A % B; } return(B); } /* fin de la fonction */ Avant de procder, nous avons besoin du rsultat suivant: Proposition : Si reste = n % m alors reste < n/2 Preuve: Par dfinition, nous avons: reste = n qm; q 1 reste n m On sait aussi que reste m -1 2 reste n 1 reste < n / 2 CQFD Durant les itrations de la boucle while, lalgorithme gnre, travers la variable reste, la suite de nombre de nombre {r0, r1, r2, r3 , ... }, reprsentant les valeurs que prennent les variable n et m, o
r0 n; r1 m; rj 1 rj 1 mod rj ; j 2

(1) (2)

En additionnant (1) avec (2), on obtient:

De la proposition prcdente, on peut dduire Par induction sur j, on obtient lune des deux relations suivantes, selon la parit de lindice j rj < r0 / 2j/2 rj < r0 / 2
(j-1)/2

si j est pair

si j est impair

r j 1 r j 1 / 2

Dans les deux cas, la relation suivantes est vrifie: rj < max(n,m) / 2j/2

Ds que rj < 1, la boucle while se termine, cest--dire ds que: 2j/2 = max(n,m) +1 Par consquent, le nombre de fois que la boucle while est rpte est gal 2log(max(n,m)+1) = O(log max(n,m)). Comme le corps de cette boucle est en O(1), alors la complexit de tout lalgorithme est aussi en O(log max(n,m)) Analyse dalgorithmes rcursifs Tours de hanoi void hanoi(int n, int i, int j, int k){ } /*Affiche les messages pour dplacer n disques de la tige i vers la tige k en utilisant la tige j */ if (n > 0) { hanoi(n-1, i, k, j) printf (Dplacer %d vers %d, i,k); hanoi(n-1, j, i, k)

} /* fin de la fonction */ Pour dterminer la complexit de cette fonction, nous allons dterminer combien de fois elle fait appel elle-mme. Une fois ce nombre connu, il est alors facile de dterminer sa complexit. En effet, dans le corps de cette fonction, il a y a: Un test Deux appels elle mme Deux soustractions Une opration de sortie En tout, pour chaque excution de cette fonction, il y a 6 oprations lmentaires qui sont excutes. Soit t(n) la complexit de la fonction hanoi(n,i,j,k). Il nest pas difficile de voir, quelque que soit les trois derniers paramtres, t(n-1) va reprsenter la complexit de hanoi(n-1, -,-,-). Par ailleurs, la relation entre t(n) et t(n-1) est comme suit: t(n) = t(n-1)+ t(n-1) + 6, si n > 0 t(0) = 1 (un seul test)

Autrement crit, nous avons: t(n) = 2 t(n-1) + 6, si n > 0 t(0) = 1 (un seul test) Pour rsoudre cette quation (de rcurrence), on procde comme suit: t(n) = 2 t(n-1) + 6 2 t(n-1) = 4 t(n-2) + 2.6 4t(n-2) = 8 t(n-3) + 4.6 ................................... 2(n-1) t(1) = 2n t(0) + 2(n-1) .6 En additionnant membre membre, on obtient: t(n) = 2n t(0) +6(1+2+4+ ... + 2(n-1) = 2n + 6. (2n-1 - 1) = O(2n).
#include <stdio.h> #include <time.h> int main ( void ) { clock_t start, end; /* Start the timer */ start = clock(); printf ( "Please wait a few moments and hit return\n" ); getchar(); /* End the timer */ end = clock(); /* Print out the difference */ printf ( "The interval was: %f seconds\n", (double)( end - start ) / (double)CLOCKS_PER_SEC ); return 0; }