Vous êtes sur la page 1sur 36

Algorithmique, module I2

SMP/SMC

4.

Les structures de donnes statiques

4.1 Tableaux une dimension


4.1.1 Introduction
Imaginons que dans un programme, nous ayons besoin simultanment de 25 valeurs (par exemple, des notes pour calculer une moyenne). La solution consiste dclarer 25 variables relles, appeles par exemple n1,n2,n3,,n25 et la variable moyenne relle. moyenne = (n1+n2+n3++n25) / 25 En programmation (exemple langage C) : lordinateur va rserver 25*4=100 octets pour les valeurs relles des 25 variables et 25*4=100 octets pour les adresses de ces 25 variables. La programmation nous permet de rassembler toutes ces variables en une seule : " la note numro 1 ", " la note numro 2 ", , " la note numro 25 ". Un ensemble de valeurs portant ainsi le mme nom de variable et repres par un nombre, sappelle un tableau, et le nombre qui sert reprer chaque valeur sappelle un indice. Un tableau de taille n est une structure trs simple constitue de n emplacements conscutifs en mmoire. Il est donc possible d'accder un lment d'un tableau en temps constant pourvu que l'on connaisse sa position (ou indice). Un tableau est donc une structure trs simple et trs efficace. Il n'est cependant pas possible de modifier la taille d'un tableau, ce qui est gnant pour un certain nombre d'algorithmes. On dit cette structure est statique. Le nombre d'lments qu'elle contient ne peut pas varier. Dans notre exemple, nous crerons donc un tableau appel Note[]. Et chaque note individuelle sera dsigne par : Note[i] (llment qui se trouve la position i). Pour dclarer un tableau il faut prciser le nombre et le type de valeurs quil contiendra. Tableau Note[25] : rels Cette dclaration rserve lemplacement de 25 lments de type rels. Chaque lment est repr par son indice (position de llment dans le tableau). Dans la plus part des langages de programmation (en particulier en langage C), la premire position porte le numro 0. Dans notre exemple, les indices vont de 0 24. Le premier lment du tableau sera dsign par Note[0], le deuxime par Note[1], le dernier par Note[24]. Lutilisation de Note[25] dclanchera une erreur. On peut crer des tableaux contenant des variables de tous types : tableaux de numriques, tableaux de caractres, tableaux de boolens, tableaux de tout ce qui existe dans un langage donn comme type de variables. Par contre, on ne peut pas faire un mixage de types diffrents de valeurs au sein dun mme tableau. Lnorme avantage des tableaux, cest quon va pouvoir les traiter en faisant des boucles. Par exemple, pour effectuer notre calcul de moyenne, cela donnera par exemple :

4.1.2 Exemple
Voici un programme qui comporte la dclaration dun tableau de 25 rels (les notes dune classe), on commence par effectuer la saisie des notes, et en suite on calcul la moyenne des 25 notes et on affiche la moyenne :

M. El Marraki

36

01/03/2007

Algorithmique, module I2
variables tableau Note[25],i,somme : entier moyenne : rel dbut /* saisir les notes */ pour i allant de 0 24 faire ecrire("entrer une note :") lire(Note[i]) finpour /* effectuer la moyenne des notes */ somme 0 pour i allant de 0 24 faire somme somme + Note[i] finPour moyenne = somme / 25 /* affichage de la moyenne */ ecrire("la moyenne des notes est :",moyenne) fin

SMP/SMC

Excution :
entrer une entrer une entrer une entrer une la moyenne note : 12 note : 10.5 note : 14 note : 08 des notes est :11.75

Une amlioration :
Constante Max 200 variables tableau Note[Max],i,somme,n : entier moyenne : rel dbut crire("entrer le nombre de notes :") lire(n) /* saisir les notes */ ecrire("entrer les ",n," notes :") pour i allant de 0 n-1 faire lire(Note[i] finpour /* effectuer la moyenne des notes */ somme 0 pour i allant de 0 n-1 faire somme somme + Note[i] finPour moyenne = somme / 25 /* affichage de la moyenne */ ecrire("la moyenne des ",n," notes est :",moyenne) fin

Remarque : - A la compilation la constante Max sera remplace par le nombre 200. - Ici le nombre de note nest pas fix 25, mais il est seulement infrieur 200.

M. El Marraki

37

01/03/2007

Algorithmique, module I2 -

SMP/SMC

Mme si on donne n la valeur 10, lordinateur rserver quand mme la place pour 200 variables de types rels. La saisie des notes est aussi amliore, puisque on rentre sur la mme ligne toutes les notes. Attention : si n=10, il faut rentrer 10 valeurs relles sparer par un espace, si vous rentrez moins de dix valeurs, lordinateur restera bloquer, et attend que vous rentrer les dix valeurs attendues. Si au contraire vous rentrez 11 valeurs au lieu de 10, lordinateur affectera les10 premires valeurs au tableau Note et gardera la 11-ime valeur pour une prochaine lecture, ce qui provoquera peut tre une erreur !!

4.1.3 Les caractristiques de lindice dun tableau


Lindice qui sert parcourir les lments dun tableau peut tre exprim directement comme un nombre ou une variable. La valeur dun indice doit toujours : - tre gale au moins 0 (dans le langage Pascal, le premier lment dun tableau porte lindice 1). Mais, nous avons choisi ici de commencer la numrotation des indices zro, comme cest le cas en langage C. Donc attention, Tab[2] est le troisime lment du tableau Tab ! - tre un nombre entier. Quel que soit le langage, llment Tab[3,1416] nexiste jamais. - tre infrieure ou gale au nombre dlments du tableau moins 1. Si le tableau Tab a t dclar comme ayant 10 lments, la prsence dans une ligne, sous une forme ou sous une autre, de Tab[10] dclenchera automatiquement une erreur. Remarques : 1. La dclaration : tableau Tab[10] : entier crera un tableau Tab de 10 lments, le plus petit indice tant 0 et le plus grand indice est 9. 2. Ne pas confondre lindice dun lment dun tableau avec le contenu de cet lment. La premire maison de la rue na pas forcment un habitant, et la dixime maison na pas dix habitants. En notation algorithmique, il ny a aucun rapport entre i et Tab[i].

Exercice 21 :
1. 2. Ecrivez un algorithme qui lit la taille n dun tableau T, il saisi les n lments du tableau T, il effectue la somme des n lments du tableau et il affiche cette somme. Ecrivez un algorithme qui lit la taille n de deux tableaux T1 et T2, il effectue la lecture de ces deux tableaux, ensuite il effectue la somme des tableaux T1 et T2 dans un tableau T et il affiche le tableau T. Exemple : pour n=8 T1=[4,5,8,-2,5,6,0,-5], T2=[1,-5,-7,0,-1, 3,-8,9], le tableau T obtenu est : T=[5,0,1,-2,4,9,-8,4],

M. El Marraki

38

01/03/2007

Algorithmique, module I2

SMP/SMC

Exercice 22 :
1. Ecrivez un algorithme qui permet lutilisateur de saisir les notes d'une classe, ensuite il renvoie le nombre de ces notes suprieures la moyenne de la classe. 2. Ecrivez un algorithme qui permet lutilisateur de saisir un tableau de taille n et

dafficher le plus grand et le plus petit lment du tableau.

Exercice 23 :
Que produit lalgorithme suivant ? Variable Tableau F[10], i : entier dbut F[0] 1 F[1] 1 crire(F[0],F[1]) pour i allant de 2 10 faire F[i] F[i-1]+F[i-2] crire(F[i]) finpour fin

4.1.4 Les tableaux dynamiques


Il arrive frquemment que lon ne connaisse pas lavance le nombre dlments que devra comporter un tableau. Bien sr, une solution consisterait dclarer un tableau gigantesque (10 000 lments) pour tre sr que "a rentre". Mais dune part, on nen sera jamais parfaitement sr (si le nombre n des lments du tableau dpasse 10 000, a provoquera une erreur), dautre part, en raison de limmensit de la place mmoire rserve (la plupart du temps non utilise), cest un gchis qui affectera la taille de notre algorithme, ainsi que sa rapidit. Pour rsoudre ce problme, on a la possibilit de dclarer le tableau sans prciser au dpart son nombre dlments. Ce nest que dans un second temps, au cours du programme, que lon va fixer ce nombre via une instruction dallocation : Allocation(nom,nombre,type), Dans la quelle il faut prciser le nom du tableau, le nombre dlments et le type des lments allouer. Notez que tant quon na pas prcis le nombre dlments dun tableau, dune manire ou dune autre, ce tableau est inutilisable. Il ne faut pas oublier de librer le tableau la fin de son utilisation avec linstruction : libre(nom). Exemple : on veut faire saisir des notes pour un calcul de moyenne, mais on ne sait pas combien il y aura de notes saisir. Lalgorithme sera :
variables tableau Note[], moyenne, somme : rels i, n : entiers dbut crire("entrer le nombre de notes saisir : ") lire(n) /* allouer n nombres de types rels */ allocation(Notes,n,rels) /* saisir les notes */ crire("entrer les ",n," notes :") pour i allant de 0 n-1 faire

M. El Marraki

39

01/03/2007

Algorithmique, module I2
lire(Note[i]) finpour /* effectuer la moyenne des notes */ somme 0 pour i allant de 0 n-1 faire somme somme + Note[i] finPour moyenne = somme / n /* affichage de la moyenne */ crire("la moyenne des ",n," notes est :",moyenne) /* librer le tableau Notes */ libre(Notes)

SMP/SMC

fin

Exercice 24 :
Refaire lExercice 21 prcdent en utilisant des tableaux dynamiques.

4.2 Tableaux deux dimensions


4.2.1 Introduction
Pour reprsenter par exemple les matrices dans un ordinateur, un tableau ne suffit pas, puisque chaque ligne de la matrice est en effet un tableau, donc une matrice nk peut par exemple tre reprsenter par n tableaux de k lments chacun. Mais cette reprsentation sera difficile grer, surtout si on veut implmenter un algorithme qui effectue la multiplication ou laddition de deux matrices. Linformatique nous offre la possibilit de dclarer des tableaux dans lesquels les valeurs ne sont pas repres par un indice seule, mais par deux indices. Cest la solution notre problme de reprsentation de matrice. Un tel tableau se dclare ainsi : tableau matrice[10][10] : entier Cette dclaration signifie : rserver un espace de mmoire pour 10 x 10 entiers, et quand jaurai besoin de lune de ces valeurs, je les reprerai par deux indices. matrice[i][j] est llment de la matrice qui se trouve lintersection de la ligne i et la colonne j. matrice[2][3] 5 Cette instruction signifie : mettre lemplacement qui se trouve lintersection de la deuxime ligne avec la troisime colonne la valeur 5. Dans la mmoire lordinateur reprsente un tableau matrice[10][10] par un seul tableau avec la taille 1010.

4.2.2 Initialisation de matrice :


Pour initialiser une matrice on peut utiliser par exemple les instructions suivantes : T1[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; T2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; T3[4][4] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; T4[4][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; Ces instructions initialisent quatre tableaux de la manire suivantes :

M. El Marraki

40

01/03/2007

Algorithmique, module I2

SMP/SMC

1 4 7

T1 2 3 5 6 8 9

1 4 7

T2 2 3 5 6 8 9

T3 1 4 7 0 2 5 8 0 3 6 9 0 0 0 0 0 1 5 9 0 2 6 0 0

T4 3 7 0 0

4 8 0 0

Remarque : Rappelons que ces reprsentations rectangulaires sont trs conventionnelles. Dans la
mmoire de lordinateur ces quatre tableaux sont plutt arrangs en lignes :

T1 T2 T3 T4

1 1 1 1

2 2 2 2

3 3 3 3

4 4 0 4

5 5 4 5

6 6 5 6

7 7 6 7

8 8 0 8

9 9 7 8 9 0 0 0 0 0 9 0 0 0 0 0 0 0

4.2.3 Lecture et criture dune matrice


Lecture dune matrice :
variable Tableau matrice[10][10],i,j,n,k : entiers dbut crire("donner le nombre de ligne de la matrice :") lire(n) crire("donner le nombre de colonne de la matrice :") lire(k) pour i allant de 1 n faire crire("donner les lments de la ",i," ligne:") pour j allant de 1 k faire lire(matrice[i][j]) finpour fipour fin

Ecriture dune matrice :


variables Tableau Mat[10][10],i,j,n,k : entier dbut pour i allant de 1 n faire pour j allant de 1 k faire crire(Mat[i][j]," ") finpour crire("\n") /* retour la ligne */ finpour fin

4.2.4 Exemples dutilisation dune matrice


Somme de deux matrices :
constante N 20 variables Tableau A[N][N],B[N][N],C[N][N],i,j,n : entier dbut crire("donner la taille des matrices(<20) :")

M. El Marraki

41

01/03/2007

Algorithmique, module I2
lire(n)

SMP/SMC

/* lecture de la matrice A */ pour i allant de 1 n faire crire("donner les lments de la ",i," ligne:") pour j allant de 1 n faire lire(A[i][j]) finpour fipour /* lecture de la matrice B */ pour i allant de 1 n faire crire("donner les lments de la ",i," ligne:") pour j allant de 1 n faire lire(B[i][j]) finpour fipour /* la somme de C = A + B */ pour i allant de 1 n faire pour j allant de 1 n faire C[i][j] A[i][j]+B[i][j] finpour fipour /* affichage de la matrice de C */ pour i allant de 1 n faire pour j allant de 1 n faire crire(C[i][j]," ") finpour crire("\n") /* retour la ligne */ finpour fin

Produit de deux matrices :


constante N 20 variables Tableau A[N][N],B[N][N],C[N][N],i,j,k,n,S : entier dbut crire("donner la taille des matrices(<20) :") lire(n) /* lecture de la matrice A */ pour i allant de 1 n faire crire("donner les lments de la ",i," ligne:") pour j allant de 1 n faire lire(A[i][j]) finpour fipour /* lecture de la matrice B */ pour i allant de 1 n faire crire("donner les lments de la ",i," ligne:") pour j allant de 1 n faire lire(B[i][j]) finpour fipour /* le produit de C = A * B */

M. El Marraki

42

01/03/2007

Algorithmique, module I2

SMP/SMC

pour i allant de 1 n faire pour j allant de 1 n faire S 0 pour k allant de 1 n faire S S + A[i][k]*B[k][j] finpour C[i][j] S finpour fipour /* affichage de la matrice de C */ pour i allant de 1 n faire pour j allant de 1 n faire crire(C[i][j]," ") finpour crire("\n") /* retour la ligne */ finpour fin

Exercice 25 :
1. Ecrire un algorithme qui effectue la lecture dune matrice carre A ainsi que sa taille n et affiche la trace de A (pour une matrice A(ai,j), Trace(A)=ai,i la somme des lments sur la diagonale). 2. Ecrire un algorithme qui effectue la lecture dune matrice carre A ainsi que sa taille n et affiche la matrice transpos tA de A (Pour une matrice A(ai,j), tA(aj,i) ).

Exercice 26 :
1. crivez un algorithme qui effectue la lecture de : - n un entier. - vect[] un tableau de n nombre rels, - mat[][] une matrice carre de nn nombre rels, il calcule et affiche le produit de la matrice mat par le vecteur vect. 2. crivez un algorithme qui effectue la lecture de deux matrices alloues dynamiquement et affiche le produit de ces deux matrices.

M. El Marraki

43

01/03/2007

Algorithmique, module I2

SMP/SMC

5.

Les fonctions

Lanalyse descendante consiste dcomposer le problme donn en sous problmes, et ainsi de suite, jusqu descendre au niveau des primitives. Les tapes successives donnent lieu des sousprogrammes qui peuvent tre considrs comme les primitives de machine intermdiaires, cest les fonctions en langage C. Beaucoup de langages distinguent deux sortes de sous-programmes : les fonctions et les procdures. Lappel dune fonction est une expression, tandis que lappel dune procdure est une instruction. O, si on prfre, lappel dune fonction renvoie un rsultat, alors que lappel dune procdure ne renvoie rien. En C on retrouve ces deux manires dappeler les sous-programmes, mais du point de la syntaxe le langage ne connat que les fonctions. Autrement dit, un sous-programme est toujours suppos renvoyer une valeur, mme lorsque celle-ci na pas de sens ou na pas t spcifie (void). La ralisation d'un programme passe par l'analyse descendante du problme : il faut russir trouver les actions lmentaires qui, en partant d'un environnement initial, nous conduisent l'tat final.

5.1

Dclaration des fonctions

Une fonction se dfinit par la construction :


fonction NomFonction(NomArg1 :TypeArg1, ..., NomArgk:TypeArgk) : TypeRetour dclarations des variables dbut Bloc dinstructions fin

Une fonction est connue dans le programme par son nom (NomFonction ) et il est ncessaire de connatre les lments qui vont permettre de lutiliser. Comme pour les variables il faut la dclarer. Cette dclaration se fera au moyen : Du type du rsultat (TypeRetour), ventuellement vide si la fonction ne rend pas de rsultat. Du nom de la fonction (NomFonction), identificateur standard. Entre parenthses, la liste des paramtres dappel (NomArgi) prcds de leur type (TypeArgi) et spars par une virgule. Si la liste est vide, on peut ne rien. Elle sera suivie des dclarations des variables et du corps de la fonction qui est constitu par une suite dinstructions, ventuellement une seule, mises entre dbut et fin. Exemple :
fonction somme( x : entier, y : entier) : entier debut retourne(x+y) fin

M. El Marraki

44

01/03/2007

Algorithmique, module I2

SMP/SMC

Cette fonction admet deux paramtres de type entiers et le rsultat est de mme type. La fonction somme() peut tre utilise par une autre fonction de la faon suivante : variables a, b, c, d : entiers a 7 b -2 c = somme(a,b) d = somme(a,somme(a,c)) crire(" la somme est = ",somme(a,b)) Contrairement dautres langages, en C on ne peut pas dfinir une fonction lintrieur dune autre : toutes les fonctions sont au mme niveau, cest--dire globales, on va adapter ici cette rstriction. Type de la fonction et des arguments : Len-tte de la fonction dfinit le type des objets quelle renvoie. Ce peut tre : tout type numrique ; tout type pointeur ; tout type struct ou union. Si le type de la fonction nest pas indiqu, le compilateur suppose quil sagit dune fonction qui ne retourne rien. Lorsquune fonction ne renvoie pas une valeur, cest--dire lorsquelle correspond plus une procdure qu une vraie fonction, il est prudent de la dclarer comme rendant un objet de type vide. Ce type est garanti incompatible avec tous les autres types : une tentative dutilisation du rsultat de la fonction provoquera donc une erreur la compilation.

5.2 Exemple complet


Calculer la somme des puissances p-ime des entiers Sp(n) : Sp(n) = 1p + 2p + 3p + + np On sait que : S1(n) = 1 + 2 + 3 + + n = n(n+1)/2 2 2 2 2 S2(n) = 1 + 2 + 3 + + n = n(n+1)(2n+1)/2 3 3 3 3 S3(n) = 1 + 2 + 3 + + n = n(n+1)/4 Ce calcul doit tre effectu n fois pour des valeurs de p qui pourront varier : on va fabriquer un outil, une fonction puissance(x,p), auquel lon donnera deux entiers x et p et qui restituera le nombre xp. La fonction puissance(x,p) : xp Analyse : Lalgorithme utilis est simple et utilise la proprit de rcurrence : pN* xp = x*xp-1 Conception :
z est un entier z 1 tant que p>0 faire z z*x

M. El Marraki

45

01/03/2007

Algorithmique, module I2
p p-1 fintantque retourne(z)

SMP/SMC

Ces instructions on les regroupant dans une fonction (puissance()) de la manire suivante :
puissance( x : entier, p :entier) : entier variables z : entier debut z 1 tant que (p>0) faire z z*x p p-1 fintantque retourne(z) fin

La dernire instruction, retourne(z) est le moyen dindiquer que le rsultat de la fonction est z. On peut maintenant crire le programme qui fait la somme des puissances p-ime des entiers compris entre 1 et n (le calcul de Sp(n)) :
/* la fonction qui calcule xp */ puissance( x : entier, p :entier) : entier variables z : entier debut z 1 tant que (p>0) faire z z*x p p-1 fintantque retourne(z) fin fonction menu () variables p, n, s, i : entiers dbut i 0 crire(" entrer la puissance p et lentier n :") lire(p,n) pour i allant de 1 n faire s = s + puissance(i,p) /* les variables i et p sont des paramtres rels, la fonction puissance(i,p)est appele pour effectuer le calcul de ip */ finpour crire(" La somme est : ",s) fin

Excution entrer la puissance p et lentier n : 1 10 La somme est : 55 ============================================ entrer la puissance p et lentier n : 2 10

M. El Marraki

46

01/03/2007

Algorithmique, module I2 La somme est : 1155 ============================================ entrer la puissance p et lentier n : 3 10 La somme est : 3025

SMP/SMC

La fonction peut tre mise nimporte o dans le programme mais, si lon veut que le compilateur puisse vrifier la correspondance entre paramtres formels et paramtres rels (nombre et type en particulier), il faut que la fonction soit place avant son utilisation. Prototype : pour viter cette restriction (et permettre aussi que deux fonctions puissent sappeler mutuellement), on peut utiliser un prototype de fonction. Un prototype est constitu par la partie dclaration de la fonction, on la place en gnral au dbut du programme. On pourra crire, par exemple :
/* prototypes */ fonction f(entier,entier):entier fonction g(chane de caractre, entier) ; /* corps de la fonction f */ fonction f(x:entier, y:entier) var message : chane de caractre dbut g(message,y) ; Fin /* corps de la fonction g */ fonction g(m :chane de caractre, y :entier) var a,b,c : entier dbut c f(a,b); fin

Lutilisation des prototypes nest pas obligatoire mais est fortement recommand pour un meilleur contrle des paramtres et pour une meilleure lisibilit du programme : les outils utiliss sont lists au dbut du texte. Rsultat dune fonction Pour retourner le rsultat dune fonction on utilise linstruction : retourne(valeur) ; o valeur doit tre du type prvu dans lentte de la fonction. Soit max() une fonction qui donne le plus grand de deux nombres entiers x et y, elle peut scrire : fonction max ( x : entier, y : entier) : entier /* maximum de x et y */ si (x<y) retourne(y) M. El Marraki 47 01/03/2007

Algorithmique, module I2

SMP/SMC

sinon retourne(x) } Linstruction retourne provoque la sortie immdiate de la fonction et le retour dans le programme appelant, les instructions qui suivent dans la fonction ne sont pas excutes, donc on peut ne pas mettre "sinon". fonction max ( x : entier, y : entier) : entier /* maximum de x et y */ si (x<y) retourne(y) retourne(x) }

5.3

Variables locales et globales

Il peut y avoir diffrents niveaux de dclaration de variables. - Les variables dfinies dans le programme hors des fonctions sont dites variables globales. Les variables globales sont connues de tout le programme. - Les variables dclares dans le corps dune fonction sont dites variables locales ou variables automatiques. Les variables locales sont connues uniquement lintrieur de la fonction, cest--dire quelles sont propres la fonction et invisibles de lextrieur. Cela permet dutiliser des variables de mme nom dans des fonctions diffrentes sans craintes dinterfrences fcheuses et "doublier" le corps de la fonction pour nen retenir que lessentiel, son mode demploi, qui figure dans sa dclaration : son nom, ses arguments et leur type, le type du rsultat. Exemple : /* localit des variables */ var a, b : entiers
fonction f(z:entier):entier var a,x,y : entier dbut fin

(1) a et b variables globales (2) z paramtre formel (3) a,x et y variables locales

fonction menu() var x,y : entier dbut fin

(4) x et y variables locales

M. El Marraki

48

01/03/2007

Algorithmique, module I2

SMP/SMC

Les variables a et b, (1) sont des variables globales, elles seront connues et utilisables dans toutes les parties du programme. La fonction menu() ne connat pas le nom des fonctions et le nombre et le type de leurs paramtres dappel. La fonction menu() ne pourra travailler que sur les variables globales a et b, et appeler la fonction f(). Une fonction connat ses propres variables, les paramtres formels, les variables globales dont le nom nest pas redfini dans la fonction, toutes les fonctions dfinies avant elle et, enfin, elle se connat elle-mme. La fonction f() pourra travailler avec les variables locales a, x, y, z et la variable globale b. La variable globale a est inaccessible de lintrieur de f(), toute utilisation de a fait rfrence la variable local. La fonction f() pourra sappeler elle-mme. La fonction menu() pourra travailler sur les variables locales x, y et les variables globales a et b la fonction menu() pourra appeler f().

5.4 Les paramtres dappels


Il y a deux types de passage de paramtres, le passage par valeur et le passage par adresse. Passage par valeur : Dans un appel par valeur le paramtre dappel est considr comme une variable locale, toutes les modifications se feront dans une case mmoire temporaire dans laquelle est range la valeur du paramtre dappel. En particulier, on peut appeler la fonction avec une expression qui sera value et dont la valeur sera le paramtre rel. Exemple : Soit le programme suivant :
fonction menu () var a,b,c : entier /* dclaration de dbut crire("entrer les valeurs de a et lire(a,b) crire(" avant lchange a = ",a," c a a b /* lchange */ b c crire(" aprs lchange a = ",a," fin a et b*/ b :") et b = ",b)

et b = ",b)

Lexcution :
entrer les valeurs de a et b : 5 avant lchange a=5 et b=7 aprs lchange a=7 et b=5 7

Ce programme effectue lchange des valeurs de a et b. On dsire maintenant crire une fonction echange() qui prend deux paramtres x et y et effectue lchange des valeurs de x et y (elle ne retourne rien cest une procdure). Passage par valeur : M. El Marraki 49 01/03/2007

Algorithmique, module I2

SMP/SMC

fonction echange(x:entier, y:entier) /* x,y:paramtre formel */ var tmp :entier /* tmp variable locale */ dbut tmp x x y /* lchange */ y tmp crire("dans la fonction echange(): x = ",x," et y = ",y) fin fonction menu() var a,b : entier /* dclaration de a et b*/ dbut crire("entrer les valeurs de a et b :") lire(a,b) crire(" avant lchange a = ",a," et b = ",b) echange(a,b) /* appel de echange() */ crire(" aprs lchange a = ",a," et b = ",b) fin

Excution :

entrer les valeurs de a et b : 5 7 avant lchange a=5 et b=7 dans la fonction echange() : x=7 et y=5 aprs lchange a=5 et b=7 Lchange na pas eu lieu !

Passage par adresse Si on veut modifier une variable lintrieur dune fonction et si lon dsire que cette modification soit effective dans la fonction appelante on fera un passage de paramtre par adresse. En C tous les arguments des fonctions sont des appels par valeur. Le seul moyen de modifier une variable externe une fonction est indirect : on transmet son adresse. Largument de la fonction doit donc tre une adresse cest--dire un pointeur. Exemple : passage par adresse
fonction echange( x:pointeur entier, y:pointeur entier) var tmp :entier dbut tmp contenu(x) contenu(x) contenu(y) /* lchange */ contenu(y) tmp crire("dans la fonction echange(): x = ",contenu(x)," et y = ",contenu(y)) fin fonction menu() var a,b : entier /* dclaration de a et b*/ dbut crire("entrer les valeurs de a et b :")

M. El Marraki

50

01/03/2007

Algorithmique, module I2

SMP/SMC

lire(a,b) crire(" avant lchange a = ",a," et b = ",b) echange(adr(a),adr(b)) /*on appel echange() avec les adresses de a et b*/ crire(" aprs lchange a = ",a," et b = ",b) fin Excution: entrer les valeurs de a et b : 5 7 avant lchange a=5 et b=7 dans la fonction echange() : x=7 et y=5 aprs lchange a=7 et b=5

Cest bien la solution souhaite. Commentaires sur le programme : Dans la fonction echange() : - les deux paramtres formels sont des pointeur sur des entiers (des adresses). - le contenu(x) est la valeur qui se trouve ladresse x (puisque x est une adresse). - linstruction tmp=contenu(x)signifie mettre dans la variable tmp (de type entier) la valeur de la variable qui se trouve ladresse x. Dans la fonction menu() : - linstruction echange(adr(a),adr(b))signifie quon appelle la fonction echange() en lui transmettant les adresses des variables x et y.

5.5 Exemples
Tous les algorithmes vus dans les chapitres 3 et 4 peuvent tre rcrit sous la forme de fonction : 1. La fonction suivante prend pour argument un entier n et retourne le nombre de chiffres qui compose n : Exemple : si n=1452635 la fonction retourne la valeur 7.
fonction NombreDeChiffres(n :entier) :entier var i, nb : entier dbut nb 0 tant que (n<>0) faire n n/10 nb nb+1 fintantque retourne(nb) fin

2. La fonction suivante prend pour argument un tableau Note[] (qui contient les notes dune classe) et n la taille du tableau (le nombre des notes) et elle retourne la moyenne de la classe :
Constante Max 200 fonction MoyenneClasse(tableau Note[Max]:rel, n:entier) :rel variables i : entier

M. El Marraki

51

01/03/2007

Algorithmique, module I2
somme, moyenne : rel dbut somme 0 pour i allant de 0 n-1 faire somme somme + Note[i] finPour moyenne somme / n retourne(moyenne) fin

SMP/SMC

3.

La fonction suivante prend pour argument deux entiers a et b et retourne leur pgcd :
fonction pgcd(a :entier, b :entier) : entier variables r : entier dbut tantQue b>0 faire r a%b a b b r finTanQue retourne(a) fin

4. On veut crire une fonction qui prend pour argument un tableau T[] dentiers, sa taille n et on veut quelle retourne le plus grand lment du tableau ainsi que sa position. Comme une fonction ne peut retourner quune valeur, alors on va passer les deux variables comme arguments de la fonction mais avec un passage par adresse pour rcuprer les valeurs de deux variables aprs lappelle de la fonction :
fonction PlusGrand(tableau T[Max]:entier,n:entier, pg:pointeur entier,pos: pointeur entier) var i : entier dbut contenu(pg) T[0] contenu(pos) 0 pour i allant de 1 n-1 faire si (T[i]>contenu(pos)) alors contenu(pg) T[i] contenu(pos) i finsi finpour fin

La fonction PlusGrand() peut tre appele de la faon suivante : si A est un tableau dentier de taille n et max et ind deux entiers
PlusGrand(A,n,adr max, adr ind)

les deux variables max et ind contiennent alors respectivement la plus grande valeur du tableau et sa position.

M. El Marraki

52

01/03/2007

Algorithmique, module I2

SMP/SMC

Remarque : dans cet exemple on pouvait faire retourner une variable par la fonction, mais la deuxime devrait obligatoirement passer par adresse :
fonction PlusGrand2(tableau T[Max]:entier,n:entier, pos: pointeur entier) : entier var i, pg : entier dbut pg T[0] contenu(pos) 0 pour i allant de 1 n-1 faire si (T[i]>contenu(pos)) alors pg T[i] contenu(pos) i finsi finpour retourne(pg) fin

La fonction PlusGrand2() peut tre appele de la faon suivante : si A est un tableau dentier de taille n et max et ind deux entiers max=PlusGrand2(A,n,adr ind) et les deux variables max et ind contiennent alors respectivement la plus grande valeur du tableau et sa position. Remarque : On peut aussi dclarer les deux variables max et ind comme variables globales, cest la plus mauvaise solution.

5.6 Fonctions rcursives


5.6.1 Introduction
Il arrive, en mathmatique, que des suites soient dfinies de la manire suivante : u0 = constante un = f(un-1) Exemple : La suite factorielle : n! = n(n-1)!, pour n1 avec 0!=1, peut scrire : f(0)=1 f(n)=n*f(n-1) Ce que lon peut traduire par : f(n) = (si n=0 alors 1 sinon n*f(n-1)). Cela peut se traduire en algorithmique par :
fonction factorielle1(n :entier) : entier dbut si (n=0) alors retourne(1) sinon retourne(n*factorielle1(n-1)) finsi fin

Dans la fonction factorielle1(), on constate que la fonction sappelle elle-mme. Ceci est possible, puisque la fonction factorielle1() est dclare avant son utilisation (cest len-

M. El Marraki

53

01/03/2007

Algorithmique, module I2

SMP/SMC

tte dune fonction qui la dclare). Que se passe-t-il lorsque on calcul factorielle1(3)? factorielle1(3) = 3 * factorielle1(2) = 3 * (2*factorielle1(1) = 3 * (2 * (1*factorielle1(0))) = 3 * (2 * (1 * (1))) = 3 * (2 * (1)) = 3 * (2) = 6

5.6.2 Dfinition de la rcursivit


La rcursivit est un concept fondamental en mathmatiques et en informatique. La dfinition la plus simple que lon puisse en donner consiste dire quun programme rcursif est un programme qui sappelle lui-mme. Pourtant, il faut bien quun programme cesse de sappeler lui-mme si lon veut viter la boucle infinie. Un programme rcursif doit contenir une condition de terminaison qui autorise le programme ne plus faire appel lui-mme. Les dfinitions rcursives de fonctions sont frquentes en mathmatiques ; le type le plus simple, portant sur des arguments entiers, est la relation de rcurrence. La fonction la plus familire de ce type est sans doute la fonction factorielle vue plus haut. La fonction factorielle1() illustre les caractristiques lmentaires de tout programme rcursif (elle sappelle elle-mme, avec une valeur infrieure de largument et elle contient une condition de terminaison dans laquelle elle calcule directement le rsultat), mais on ne peut cacher quil nest rien dautre quune boucle "pour". Cet exemple ne dmontre pas vraiment la puissance dun programme rcursif.
fonction factorielle2(n : entier) : entier variables fact, i : entier dbut fact 1 pour i allant de 2 n faire fact fact * i finpour retourne(fact) fin

5.6.3 La suite de Fibonacci


Une deuxime relation de rcurrence bien connue est celle qui dfinit la suite de Fibonacci : Fn = Fn-1 + Fn-2, pour n 2 avec F0=0 et F1=1. 1er algorithme de calcul de Fn : On a un programme rcursif simple associ cette relation :
fonction Fibo1(n entier) : entier dbut si (n<=1) alors retourne(1)

(1)

M. El Marraki

54

01/03/2007

Algorithmique, module I2
sinon retourne(Fibo1(n-1) + Fibo1(n-2)) finsi fin

SMP/SMC

Ce programme est rcursif puisquil sappelle lui-mme, avec des valeurs infrieures de largument et il contient une condition de terminaison. Il sagit dun mauvais exemple dutilisation de la rcursivit, puisque pour calculer Fibo1(n), on a besoin de calculer Fibo1(n-1) et Fibo1(n-2) ; voir larbre suivant : Fibo1(n)

Fibo1(n-1)

Fibo1(n-2)

Fibo1(n-2)

Fibo1(n-3)

Fibo1(n-3) ...

Fibo1(n-4)

Le nombre dappels ncessaires au calcul de Fn est gal au nombre dappels ncessaires au calcul de Fn-1 plus celui relatif au calcul de Fn-2, ceci correspond bien la dfinition de la suite de Fibonacci : le nombre dappels de la fonction Fibo1() pour calculer Fn est exactement le nombre Fn. Or Fn est exponentielle en fonction de n. La solution de la suite rcurrente (1) est :

5 o = le nombre dor 1.618 On a aussi Fn+1 / Fn

Fn =

n n

avec =

1+ 5 2

et =

1 5 2

(2)

Donc pour calculer Fibo1(n) on fait Fn appelle la fonction Fibo1(n), ce nest pas pratique du tout (inutilisable).
2me algorithme de calcul de Fn :

En revanche, il est trs facile de calculer Fn en utilisant un tableau :


constante : N = 26 fonction Fibo2(entier :n) : entier variable i: entier ; tableau F[N] : entier dbut F[0] 1 F[1] 1 pour i allant de 2 n faire F[i] F[i-1] + F[i-2] finpour retourne(F[n]) fin

M. El Marraki

55

01/03/2007

Algorithmique, module I2

SMP/SMC

Aprs excution pour n=25, on regroupe dans le tableau suivant les 26 premier termes de la suite de Fibonacci : n Fn n Fn n Fn 17 2584 0 1 1 1 2 2 15 987 18 4181 3 3 4 5 5 8 6 7 8 9 10 13 21 34 55 89 17 2584 20 10946 18 4181 21 17711 19 6765 22 28657 11 144 12 13 233 377 14 610 15 987 16 1597

16 1597 19 6765

20 10946 23 46368 24 75025 25 121393

F50 = 20365011074 F100 = 354224848179262000000 F500 = un nombre de 104 chiffres Dans ce cas, pour calculer Fn on stocke tous les termes F0, F1, , Fn-2 et Fn-1. Ce qui est inutile puisque pour calculer Fn on a besoin que des deux derniers termes Fn-2 et Fn-1. Donc lalgorithme peut tre amlior encore !

5.7 Exercices
Exercice 27 : 1. crivez une fonction qui prend pour argument un tableau dentiers T, sa taille n, une
valeur x, et il indique ensuite si llment x appartient ou non au tableau T.

2. crivez une fonction qui prend pour argument un tableau dentiers T et sa taille n, et nous
informe si les lments d'un tableau d'entiers sont tous conscutifs ou non. (Par exemple, si le tableau est : 7; 8; 9; 10, ses lments sont tous conscutifs. Si le tableau est : 7; 9 ; 10; 11, ses lments ne sont pas tous conscutifs).

Exercice 28 :
crivez une fonction qui prend pour arguments un tableau de rels T et sa taille n, et nous donne la plus grande et la plus petite valeur du tableau T.

Exercice 29 (un nombre parfait) :


Un nombre parfait est un entier positif suprieur 1, gal la somme de ses diviseurs ; on compte 1 comme diviseur, mais on ne compte pas comme diviseur le nombre lui-mme. Exemple : 6 est un nombre parfait puisque : 6 = 3 + 2 + 1. 1. Donner un nombre parfait diffrent de 6. 2. Donner la conception dun algorithme qui effectue la lecture dun entier n et affiche si n est parfait ou non. 3. Ecrire une fonction qui prend pour argument un nombre entier n et retourne si n est parfait ou non.

M. El Marraki

56

01/03/2007

Algorithmique, module I2

SMP/SMC

Exercice 30 :
Soit la fonction mystere() suivante :
Fonction mystere(x :entier, p :entier) :entier variable z :entier dbut z 1 Tant que p>0 faire si (p%2==0) alors x x*x p p/2 sinon z z*x p p-1 finsi fin tantque retourne(z) fin

1. Excuter cette fonction avec : a. x=2 et p=16 b. x=3 et p=31 c. x=a et p=30 2. Que fait la fonction mystere(x, p) ? (justifier votre rponse).

Exercice 31 :
On note par pgcd(a,b) le plus grand commun diviseur de a et b. Soit a et b deux entiers naturels, si b est non nul, on peut effectuer la division euclidienne de a par b. Il existe un couple unique dentiers (q,r) tels que : a = bq +r avec 0 r < b On a la formule suivante pgcd(a,b) = pgcd(b,r) A partir de cette formule dduisez une fonction pgcdRec(a,b) rcursive qui calcul le pgcd de a et b.

Exercice 32 :
1. Ecrire une procdure afficher_matrice() : qui prend pour arguments n et une matrice A, et elle affiche la matrice A. 2. Ecrire une procdure qui donne la transpose dune matrice A. 3. Ecrire une procdure qui vrifie si une matrice est symtrique. 4. Ecrire une procdure qui effectue la somme de deux matrices. 5. Ecrire une procdure qui effectue le produit de deux matrices. 6. Ecrire une fonction qui donne le dterminant dune matrice carre dordre n=2 ou 3. 7. Ecrire une procdure qui donne linverse dune matrice carre dordre n=2 ou 3.

Exercice 33 : I. Recherche dun lment dans un tableau.

M. El Marraki

57

01/03/2007

Algorithmique, module I2

SMP/SMC

1. Ecrire une procdure qui recherche un lment dans un tableau de faon squentiel. 2. On se place dans le cas o le tableau est ordonne et les lments du tableau sont deux deux distincts. Ecrire une procdure qui recherche un lment de faon dichotomique.

II. Insertion et suppression dun lment dun tableau.


1. Ecrire une procdure qui permet dinsrer un lment dans un tableau une position donne. 2. Ecrire une fonction qui permet dinsrer un lment dans un tableau dj trie une position donne. . 3. Ecrire une fonction qui permet de supprimer un lment dun tableau.

Exercice 34 : I. Algorithme dEuclide.


1. Ecrire une fonction qui donne le pgcd de deux entiers positifs a et b. 2. Ecrire une fonction qui donne le ppcm de deux entiers positifs a et b. 3. Comparer ces deux fonctions avec les fonctions igcd() et ilcm() de Maple (utiliser time()).

II. Dcomposition dun entier en facteurs premiers.


1. Ecrire une fonction qui stocke dans une liste les nombres premiers infrieur ou gale n. (on peut utiliser isprime()). 2. Ecrire une fonction qui construit la liste des facteurs premiers de lentier n, (on peut utiliser ifactor()). 3. Faire des testes avec des nombres de 10, 15 et 20 de chiffres (utiliser time()).

III. Suite de Fibonacci .


La suite de Fibonacci est donne par les quations :
u0 = 0 u1 = 1 un = un-1 + un-2 pour n 2

Ecrire une procdure qui affiche les n premiers termes de la suite de Fibonacci.

Exercice 35 : I. Implantation des algorithmes de tri simple.


1. Ecrire une fonction qui tri un tableau par la mthode dinsertion simple. 2. Ecrire une fonction qui tri un tableau par la mthode de slection. 3. Ecrire une fonction qui tri un tableau par la mthode de tri Bulles : Principe :

M. El Marraki

58

01/03/2007

Algorithmique, module I2

SMP/SMC

Lalgorithme de permutation simple est bas sur le principe de la comparaison et de lchange de couples dlments adjacents jusqu ce que tous les lments soient tris. Parcourir le tableau en comparant deux deux les lments successifs, permuter sils ne sont pas dans le bon ordre. Rpter tant que des permutations sont effectues.

II. Comparaison des algorithmes sur des exemples concrets. Comparer avec la fonction sort()
de Maple (utiliser time()).

Exercice 36:
La reprsentation dun nombre entier positif en binaire. 1. Ecrire une fonction qui converti un entier dcimal en binaire (utiliser la fonction convert() de Maple). 2. Ecrire une fonction qui converti un entier dcimal en binaire (sans utiliser la fonction convert() de Maple). 3. Ecrire une fonction qui converti un entier binaire en dcimal (utiliser la fonction convert() de Maple). 4. Ecrire une fonction qui converti un entier binaire en dcimal (sans utiliser la fonction convert() de Maple). 5. Ecrire une fonction qui donne le nombre de bits ncessaire pour coder un entier positif n en binaire. 6. Ecrire une fonction qui donne le nombre de bits gaux 1 dans sa dcomposition en binaire.

M. El Marraki

59

01/03/2007

Algorithmique, module I2

SMP/SMC

6.

Evaluation dun algorithme

6.1 Introduction
Quand on tente de rsoudre un problme, la question se pose souvent du choix dun algorithme. Quels critres peuvent guider ce choix ? Deux besoins contradictoires sont frquemment en prsence : lalgorithme doit 1. tre simple comprendre, mettre en uvre et mettre au point, 2. mettre intelligemment contribution les ressources de lordinateur, et plus prcisment, il doit sexcuter le plus rapidement possible. Si un algorithme ne doit servir quun petit nombre de fois, le premier critre est le plus important. Le temps employ concevoir le programme dpassera vraisemblablement de beaucoup celui de son excution, et le temps optimiser est celui pass crire le programme. Si la solution du problme traiter doit tre employe assez souvent, le temps dexcution risque dtre un facteur bien plus dterminant que le temps pass crire le programme. Dans ces conditions, il parat rentable de mettre en uvre un algorithme plus labor.

6.2 Mesure de la complexit algorithmique


Le temps dexcution dun algorithme dpend des facteurs suivants : 1. Les donnes entrant dans le programme, 2. La qualit du code gnr par le compilateur pour la cration du programme objet, 3. La nature et la vitesse dexcution des instructions du microprocesseur utilis pour lexcution du programme. 4. La complexit du programme. Le temps dexcution dun programme ne dpend pas de la nature prcise des donnes mais de leur taille. On note T(n) le temps dexcution ou la complexit algorithmique dun programme portant sur des donnes de taille n. Dans ce cours la complexit dun algorithme dsigne le nombre doprations lmentaires (affectations, comparaisons, oprations arithmtiques) effectues par lalgorithme. Elle sexprime en fonction de la taille n des donnes. On dfinit T(n) comme la complexit dans le pire des cas, cest--dire la mesure de la complexit maximum, sur tous les ensembles de donnes possible de taille n pour un programme donn. Il est aussi possible de dfinir la complexit en moyenne, Tmoy(n).

6.3 La notation de Landau "O"


Dfinition :
Une fonction T(n) est de lordre de f(n) ( ou O(f(n))) sil existe deux constantes c et n0 telles que : T(n) < cf(n), pour tout n>n0.

Exemples :
1. Soit la fonction T(n)=(n+1) pour n0, alors la fonction T(n) est un O(n) pour n0=1 et c=4. En effet, pour n1, on a (n+1)4n (il suffit dtudier le signe de (n+1) 4n).

M. El Marraki

60

01/03/2007

Algorithmique, module I2

SMP/SMC

2. La fonction T(n)= 3n+2n est O(n) avec n0=0 et c=5. En effet, 3n+2n-5n=2n(1-n)0 pour n0 ; par consquent T(n) est O(n). n n 3. La fonction T(n)=3 nest pas un O(2 ). En effet, par absurde, supposons que T(n) est un O(2n), cest--dire il existe deux constantes n0 et c telles que pour tout nn0, 3nc2n, donc on a 3n/2nc pour tout nn0. Mais (3/2)n est une suite gomtrique qui tend vers +, ce qui est absurde. Conclusion T(n) ne peut pas tre un O(2n) .

6.4 Les grandes classes de complexit


Les algorithmes usuels peuvent tre classs en un certain nombre de grandes classes de complexit : La plupart des instructions de la plupart des programmes sont excutes une fois ou au plus un petit nombre de fois. Si toutes les instructions dun programme ont cette proprit on dit quil a une complexit constante cest--dire O(1). Les algorithmes sub-linaires, dont la complexit est en gnral en O(log(n)). Cest le cas de la recherche dun lment dans un ensemble ordonn fini de cardinal n. Les algorithmes linaires en complexit O(n) ou en O(n log(n)) sont considrs comme rapides, comme lvaluation de la valeur dune expression compose de n symboles ou les algorithmes optimaux de tri. Plus lents sont les algorithmes de complexit situe entre O(n) et O(n), cest le cas de la multiplication des matrices et du parcours dans les graphes. Au del, les algorithmes polynomiaux en O(n ) pour k>3 sont considrs comme lents, sans parler des algorithmes exponentiels (dont la complexit est suprieure tout polynme en n) que lon saccorde dire impraticables ds que la taille des donnes est suprieure quelques dizaines dunits.
k

On a la classification suivante de ces fonctions :


log n << n
1/2

<< n << n(log n) << n2 << n3 << 2n << en << n!.

Voici une comparaison numrique entre ces fonctions, on notera la croissance tres rapides des fonctions exponentielles (2n, en, n!). A titre de comparaison, on estime le nombre de particules dans lunivers 1080.
log(n) n 1/2 n n(log n) n2 n3 2n en 3.3 3.1 10 33 100 103 103 2 104 6.6 10 100 664 10 32 1000 4 10 6 10 9 10 300 10 434 10

10 6 10 30 10 43 10

M. El Marraki

61

01/03/2007

Algorithmique, module I2
n! 3.6 10
6

SMP/SMC 10
158

10

2568

6.5 Evaluation dun algorithme


Pour valuer un algorithme, nous chercherons une borne suprieure, relativement toutes les excutions possibles, du nombre dactions lmentaires contenues dans lalgorithme, en fonction de paramtres correspondant la taille des donnes. Ceci nous permettra dobtenir lordre de grandeur du temps dexcution dans le pire des cas. En effet, supposons que lexcution faisant intervenir le maximum dactions lmentaires ncessite : n1 actions lmentaires de genre 1 (par exemple affectations) n2 actions lmentaires de genre 2 (par exemple additions) . nk actions lmentaires de genre k

Chaque ni demandant un temps ti. Le temps total pour cette excution sera :

t = ti ni
i

Pour une machine donne :

c1 ni T (n) c2 ni
i i

avec c1 = min ti , c 2 = max t i .


i

Donc T ( n) = O

( n ) est lordre de grandeur du temps de lalgorithme dans le pire des cas,


i

indpendamment de la machine utilise.

6.6 Exemples
La somme des entiers allant de 1 n (algorithme dj vu)
variables n, i, somme : entiers debut crire("Donner n :") lire(n) somme 0 pour i allant de 1 n /* instructions lmentaires */ /* /* /* /*

1 criture */ 1 lecture */ 1 affectation * 1 affectation, n comparaison, n additions, n affectation */ somme somme + i /* n additions, n affectations */ ecrire("la somme est :",somme) /* 1 criture */ fin

Total 5n+5 instructions lmentaires Supposons que : - laffectation, la lecture, lcriture et laddition prennent chacune un temps t1, - la comparaison prend un temps t2.

M. El Marraki

62

01/03/2007

Algorithmique, module I2 Le temps ncessaire pour la ralisation de cet algorithme est : (5+4n)t1 + nt2 = n(4t1+t2)+ 5t1. Dou la complexit T(n) est en O(n).
Schma de Hrner

SMP/SMC

Problme . On considre le polynme en x rel, coefficients rels, de degr n : n n-1 P(x)=anx + an-1x + + a1x + a0 On veut calculer sa valeur P ( x0 ) pour x = x 0 donn, en utilisant les seules oprations lmentaires : addition et multiplication. 1re mthode : On peut crire un algorithme qui calcule anx0n,an-1x0n-1,, a1x0 les unes aprs les autres et les additionne (ajouter a 0 ). Calculons en fonction de n le nombre doprations lmentaires qui seront effectues lors de lexcution de cet algorithme :

i nombre de multiplications pour un a x : i

- nombre de multiplications pour tous : - nombre dadditions : - Total : Donc cet algorithme est O(n).

1+2++(n-1) = n(n-1)/2 n n(n+3)/2.

2me mthode : P(x) peut scrire (schma de Hrner) : P(x)=(...(((anx + an-1)x + an-2)x + an-3)x +...+ a1)x+a0 Grce cette criture, on peut crire un algorithme qui calcule P(x0) de la manire suivante : Analyse : itrer n fois : - multiplier A par x0 et additionner le coefficient suivant - mettre le rsultat obtenu dans A commencer avec A=an Conception : Nom : Algorithme dHrner variables n, i : entier A, B, x: rels dbut crire("donner n et x : ") lire(n,x) crire("donner A: ") lire(A) pour i allant de 1 n faire lire(B) A A*x+B finpour crire(A) Fin

M. El Marraki

63

01/03/2007

Algorithmique, module I2

SMP/SMC

Test : Schema_Hrner
entrer entrer entrer entrer

1 1 1 la valeur du polynme en 2.0000 est : 7.0000 entrer les valeurs de n et X :5 2.5 entrer la valeur de A : -1 entrer la valeur de B : 1.5 entrer la valeur de B : 0 entrer la valeur de B : 3.2 entrer la valeur de B : 4 entrer la valeur de B : 1 la valeur du polynme en 2.50000 est : 306.656250
Complexit :

les valeurs de la valeur de A la valeur de B la valeur de B

n : : :

et X :2 2

Cet algorithme comporte n multiplications, n addition, n+3 lectures, n affectations, 1 criture. Il est en O(n). Il est donc meilleur que le prcdent en ce sens que pour les grandes valeurs de n, le temps dexcution du premier a pour ordre de grandeur le carr du deuxime. Tableau de comparaison (on ce place dans le cas dune machine qui effectue 106 oprations par seconde) :
N 103 106 1010 Algorithme naf 1 sec 106 sec 11.6 jours 1014 sec 3106 annes Algorithme dHrner 10-3 sec 1 sec 2h 45min

Remarques :
1. On peut se demander si a vaut le coup de se creuser la tte pour passer d'un algorithme un autre algorithme. Regardons donc quelques chiffres pour se convaincre que oui (pour une machine pouvant effectuer 106 oprations par seconde) :
Const 102 103 104 105 106 1s 1s 1s 1s 1s lg (N) 6.6s 9.9s 13.3s 16.6s 19.9s N 0.1ms 1ms 10ms 0.1s 1s N lg(N) 0.6ms 9.9ms 0.1s 1.6s 19.9s N2 10ms 1s 100s 2.7h 11.5j N3 1s 16.6min 11.5j 31ans 3104 ans eN 1016ans

M. El Marraki

64

01/03/2007

Algorithmique, module I2

SMP/SMC

2. Estimation de la taille maximale des donnes que l'on peut traiter par un algorithme de complexit donne (pour une machine pouvant effectuer 106 oprations par seconde) :
Const 1s 1min 1h 1j lg (N) N 10 6107 36108 86109
6

N lg(N) 6310 28105 13107 276108


3

N 3 10 7103 60103 29104

N 100 390 15102 44102

e 19 25 31 36

6.7 Applications
6.7.1 Les algorithmes de recherche dans un tableau
Problme : recherche dun lment dans un tableau.

Recherche squentielle Analyse :


Parcours squentiel du tableau Arrt lorsque la valeur est trouve Retour lindice correspondant La valeur nest pas trouve Retour dune valeur spciale

Conception :
Une fonction qui prend comme paramtre x (la valeur cherche), un tableau Tab[] (dans lequel on effectue la recherche, un entier n (la taille du tableau) et elle rend un entier.
fonction recherche(n:entier, Tab[]:entier, x:entier):entier variables i : entier dbut i 0 Tant que ( i < n et Tab[i] != x) faire i i + 1 fintantque si (i<n) alors retourne(i) sinon retourne(-1) fin

Test :
Si on prend n=10, Tab= 1 9 2 0 3 5 2 4 11 -1 et x=7 la fonction retourne -1 (puisque 7 ne se trouve pas dans Tab !) Si on prend n=10, Tab= 1 9 2 0 3 5 2 4 11 -1 et x=2 la fonction retourne 2 (puisque Tab[2]=2 , la premire position trouve)

M. El Marraki

65

01/03/2007

Algorithmique, module I2

SMP/SMC

Complexit :
On considre juste les comparaisons : le meilleur cas : 3 comparaison le pire cas : 2n+1 comparaisons en moyenne : (2+4++2n)/n=2(n+1)/2=n+1 Conclusion la complexit T(n) est O(n)

Recherche dichotomique
On se place dans le cas o le tableau est ordonn et les lments du tableau sont deux deux distincts.
Analyse : valRech : lment recherch, Tab : tableau ordonn, sans duplication, taille : la taille du tableau (le nombre dlments du tableau) mil : indice du milieu du tableau, si valRech = Tab[mil] alors retourne mil sinon si valRech < Tab[mil] alors recherche dans la 1re moiti du tableau (Tab[d mil-1]) sinon recherche dans la 2me moiti du tableau (Tab[mil+1 f]) finsi finsi retourne(-1) Conception : variables d, f, mil, entires dbut d 0 f taille 1 Tantque (d<=f) mil (d + f)/2 si (valRech = Tab[mil]) retourne mil si (valRech<Tab[mil]) f mil-1 sinon d mil + 1 fintantque retourne(-1) fin Test : Soit le tableau T[1..9] (ordonn et sans rptition) suivant : 0 1 2 3 4 5 6 2 6 8 11 17 18 22

7 45

8 102

M. El Marraki

66

01/03/2007

Algorithmique, module I2

SMP/SMC

On cherche llment 8.
d f mil 0 8 4 0 3 1 1 3 2

Au dbut : d=0, f=8 comme d<f on rentre dans la boucle "Tantque", mil=(0+8)/2=4 et comme valRech<Tab[mil] (8 <17) on a f=mil-1 (f=3), d=0, puisque d<f (0<3) on reste dans la boucle Tantque et on a mil =(0+3)/2=1 et comme valRech>Tab[mil] (8>6), donc d=mil+1=2 et f=3 par consquent d<f (2<3), alors on reste dans la boucle Tantque et mil=2, la valRech=Tab[mil] (8=Tab[2]) alors la fonction retourne la valeur 2 qui est bien la position que occupe la valRech=8.

Complexit :
A chaque tape : 1 addition, 1 division, entre 1 et 3 tests division par 2 de la taille du tableau, donc lg(n) tapes Conclusion : la complexit T(n) = O(lg(n)).
Comparaison des deux mthodes de recherche (squentielle et dichotomique) :

Taille 16 1024
21024

Recherche squentielle 16 1024=2 10 21024 10307

Recherche dichotomique 4 10 1024

Exercice 32 : Soit le tableau T[0..10] (ordonn et sans rptition) suivant :


-2 3 5 7 10 17 19 23 50 62 70

1. Chercher llment 3 dans le tableau T, par dichotomie. 2. Chercher llment 19 dans le tableau T, par dichotomie. 3. Chercher llment 56 dans le tableau T, par dichotomie.

6.7.2 Les algorithmes de tri


Problme : rarranger les lments dun tableau dans lordre croissant ou dcroissant pour rendre plus efficaces les oprations de recherche et, par consquent, les opration dinsertion, et de suppression, etc.

Tri par slection


Principe : Ranger le premier lment Trier le reste du tableau. Analyse :

M. El Marraki

67

01/03/2007

Algorithmique, module I2 Recherche le plus petit lment : ppe Permuter avec le premier lment du tableau Trier le tableau partir de llment suivant. Donnes : Entres : Tab : tableau trier, taille : la taille du tableau, Sorties : tableau tri Locales : le plus petit lment et son indice (ppe et indppe). Traitements : Boucle : trouver ppe (le plus petit lment) Permuter ppe et le premier lment, Trier partir de llment suivant. Conception : On prsente deux versions une itrative et lautre rcursive : 1re version : fonction Tri_par_selection(Tab[]:entier, taille:entier) variables ppe, indppe, i, j, tmp : entiers dbut pour i allant de 0 taille-2 faire ppe Tab[i] indppe i pour j allant de i+1 taille-1 faire si (Tab[j] < ppe) ppe = Tab[j] indppe = j finpour si (i != j) permuter(Tab,indppe, i) finpour fin Application : Excuter lalgorithme prcdent avec le tableau T suivant : 44 55 12 42 94 18 67 06

SMP/SMC

Dans le tableau : llment courant est soulign alors que le plus petit lment est en gras.
Complexit : Dans la fonction Tri_par_selection () on comptabilise les oprations de comparaisons, on a deux boucles imbriques, le total des comparaisons est 1+2++(n-1) = n(n-1)/2. Conclusion : la complexit T(n) = O(n).

M. El Marraki

68

01/03/2007

Algorithmique, module I2

SMP/SMC

Tri par insertion simple


Principe : Cette mthode est trs utilise lorsquon joue aux cartes. Les lments (les cartes) sont diviss en une suite destination a1 ai-1 et une suite source ai an. A chaque tape, en partant de i=2 et en augmentant i de 1, on prend le ime lment de la suite source et on linsre sa place dans la suite destination. Pour insrer llment couramment considr, on dplace simplement les lment qui lui sont suprieurs un cran vers la droite et on linsre dans la place laisse vacante. Analyse : Pour i allant de 2 n faire x Tab[i] insrer x la bonne place dans a1 ai-1 Conception : Tri_insertion_simple( Tab[] :entier, taille :entier) i, j, x : entiers dbut pour i allant de 2 taille-1 faire x Tab[i] j i Tant que (x<Tab[j-1]) faire Tab[j] Tab[j-1] j j-1 Tab[j] x fin

Application : Excuter lalgorithme prcdent avec le tableau suivant : 44


i=2 i=3 i=4 i=5 i=6 i=7 i=8 Commentaires sur le programme : Comme pour le tri par slection, les lments situs gauche de lindice i sont dans le bon ordre relatif pendant le tri, mais ne sont pas toujours dans leur position finale puisquils peuvent tre dplacs par la suite. Malgr tout, le tableau est entirement tri lorsque lindice atteint lextrmit droite. Il y a un point important remarquer : la fonction Tri_insertion_simple() est prise en dfaut la plupart du temps ! La boucle tantque provoquera le dpassement de lextrmit gauche lorsque x contient la valeur du plus petit lment du tableau. Pour viter ceci, on place dans

55

12

42

94

18

06

67

M. El Marraki

69

01/03/2007

Algorithmique, module I2

SMP/SMC

Tab[0] une "sentinelles" infrieure ou gale la plus petite valeur rencontre. Si, le recours une sentinelle nest pas recommand (parce quil est dur de dfinir la plus petite valeur du tableau), le test while( j>1 && x<Tab[j-1]) peut tre utilis.
Complexit : Pour chaque i de 1 n, il y a un change et n-i comparaisons, soit un total de n-1 changes et (n1) + (n-2) + + 2 + 1 = n(n-1)/2 comparaisons. Donc Le nombre de comparaisons effectues par le tri par slection est de lordre de n/2 et le nombre dchanges est de lordre de n. La complexit est donc T(n)=O(n).

Tris par permutation simple (tri bulles et tri shaker)


On va tudier une mthode dans laquelle la permutation de deux lments est la caractristique essentielle du processus de tri.

Tri bulles
Principe : Lalgorithme de permutation simple est bas sur le principe de la comparaison et de lchange de couples dlments adjacents jusqu ce que tous les lments soient tris. 1. Parcourir le tableau en comparant deux deux les lments successifs, permuter sils ne sont pas dans le bon ordre. 2. Rpter tant que des permutations sont effectues. Exemple : On veut trier le tableau :

44

55

12

42

94

18

06

67

On effectue des passes successives sur le tableau en faisant glisser chaque fois le plus petit lment de lensemble restant vers lextrmit gauche du tableau. Si, pour changer un peu, nous imaginons que le tableau est vertical et non horizontal, et que les lments sont comme des bulles dans un rservoir deau, les bulles dont le poids est trier, chaque passe sur le tableau conduit lascension dune bulle vers le niveau correspondant son poids, voir le tableau suivant. Cest pourquoi cette mthode est trs connue sous le nom de tri bulles.
i=1 44 55 12 42 94 18 06 67 2 06 44 55 12 42 94 18 67 3 06 12 44 55 18 42 94 67 4 06 12 18 44 55 42 67 94 5 06 12 18 42 44 55 67 94 6 06 12 18 42 44 55 67 94 7 06 12 18 42 44 55 67 94 8 06 12 18 42 44 55 67 94

M. El Marraki

70

01/03/2007

Algorithmique, module I2

SMP/SMC

Conception : fonction Tri_a_bulles ( Tab[] :entier, taille :entier) i, j, tmp : entiers dbut pour i allant de 2 n faire pour j allant de n i par 1 faire Si Tab[j-1]>Tab[j] alors tmp = Tab[j-1] Tab[j-1] = Tab[j] Tab[j] = tmp finsi finpour finpour fin Raffinement : Cet algorithme peut tre facilement amlior. Dans lexemple prcdent les trois dernires passes ne servent rien puisque les lments sont dj tris. Une manire vidente damliorer cet algorithme est donc de se souvenir quil y a eu ou non une permutation pendant une passe ; une dernire passe sans permutation est cependant ncessaire pour savoir que lalgorithme peut tre arrt. On peut encore faire mieux en se rappelant non seulement du fait quil y a eu permutation, mais encore de la position (lindice k) de la dernire permutation. Par exemple, il est clair que toutes les paires dlments adjacents en dessous de lindice k sont dans lordre dsir. Les balayages suivants peuvent donc se terminer k au lieu daller jusqu la limite prdtermine i. On remarque aussi une certaine asymtrie : une bulle "lgre" mal place dans la partie la plus "dense" du tableau trouvera sa place en une seule passe, alors quune bulle plus lourde place dans la partie la moins dense ne progressera que dune position vers sa place dfinitive. Cest ainsi que le tableau : 12 18 42 44 55 67 94 06 est tri par un tri bulles en une seule passe : 06 12 18 42 44 55 67 94 alors que le tableau : 94 06 12 18 42 44 55 67 ncessitera sept passes. 06 94 12 18 42 44 55 67 06 12 94 18 42 44 55 67 06 12 18 94 42 44 55 67 06 12 18 42 94 44 55 67 06 12 18 42 44 94 55 67 06 12 18 42 44 55 94 67 06 12 18 42 44 55 67 94

Cette asymtrie non naturelle nous suggre une autre amlioration : changer de direction chaque passe : cest ce quon appelle le tri shaker.

M. El Marraki

71

01/03/2007

Vous aimerez peut-être aussi