Algorithmique 1 -...

Algorithmique 1

Licence d’informatique

Licence de mathematiques

2eme annee

2017 - 2018

Francois Denis, Stephane Grandcolas, Yann Vaxes

Chapitre 0

Introduction.

Ce cours constitue une introduction a l’algorithmique. Il est destine auxetudiants de deuxieme annee de la licence d’informatique de l’universited’Aix-Marseille, supposes avoir deja des bases solides en programmation. Ilest egalement propose en option aux etudiants de la licence de mathema-tiques.

0.1 Contenu du cours

Le premier chapitre est une introduction a l’analyse des algorithmes et enparticulier, aux notions fondamentales de preuves et de complexite des algo-rithmes. Le second chapitre est consacre aux structures de donnees lineaires(tableaux, listes, piles, files et tables de hachage). Le troisieme chapitre estdedie aux principaux algorithmes de tris et a l’etude de leur complexite. Lequatrieme chapitre est consacre aux arbres binaires de recherche. Le cin-quieme chapitre introduit la notion de programmation dynamique qui per-met de resoudre e�cacement certains problemes d’optimisation. Le sixiemeet dernier chapitre est consacre aux graphes qui interviennent dans la re-presentation de nombreux problemes, et pour lesquels un grand nombred’algorithmes ont ete developpes, notamment pour le calcul de plus courtschemins.

Ce cours est largement inspire de “Introduction a l’algorithmique” deT. Cormen, C. Leiserson, R. Rivest et C. Stein (2010, editions DUNOD)qui est la reference pour les cours algorithmique 1 et algorithmique 2 de lalicence d’informatique (et au dela).

Ce support de cours correspond aux cours magistraux ; ils sont completespar des travaux diriges et des travaux pratiques. Les algorithmes sont donnes

3

4 CHAPITRE 0. INTRODUCTION.

en pseudo-code, ce qui permet de s’abstraire de details d’implementation(voir section suivante), ou en C, langage utilise dans les travaux pratiques.

0.2 Description des algorithmes en pseudo-code

Un algorithme

1 est la description d’un calcul e↵ectue sur des donnees

discretes. On distingue les donnees fournies en entree a l’algorithme et cellesqu’il calcule en sortie.

Un algorithme est decrit par un pseudo-code su�samment precis pourpouvoir etre implemente dans tout langage de programmation, et en C enparticulier. Cela permet de ne pas s’encombrer de details syntaxiques lies aun langage de programmation particulier.

Conventions retenues pour le pseudo-code :

1. utilisation d’indentations pour identifier les blocs d’instructions ;

2. les tests usuels (=, <,>,,�) sont disponibles ainsi que les connec-teurs logiques de base (ET, OU, NON) 2 ;

3. les structures de controles conditionnelles usuelles, si ...alors ...

et si ...alors ...sinon ..., sont disponibles ;

4. les structures iteratives usuelles tant que, pour, repeter ... jus-

qu’a, sont disponibles ;

5. l’a↵ectation de variable est notee := ;

6. il est possible de definir et d’utiliser des fonctions et procedures ; lespassages de parametres se font par valeur

3 ; les appels recursifs sontpossibles ;

7. les commentaires sont precedes du caractere #.

0.3 Premiers exemples d’algorithmes

L’algorithme 1 decrit une methode simple de tri qui consiste a parcourirun tableau, du second indice jusqu’au dernier, et a inserer l’element courantparmi les elements precedents, en preservant leur ordre. On utilise une bouclepour car le nombre d’iterations a e↵ectuer est connu au debut de l’iteration.

1. d’apres le nom du mathematicien perse Al Khawarizmi (783-850).

2. on supposera, comme c’est le cas en C, que l’evaluation de la proposition p ET q

(resp. p OU q) commence par p et s’arrete si p est evaluee a FAUX (resp. a VRAI).

3. les valeurs des parametres sont connues au moment de l’appel d’une fonction et ce

sont ces valeurs qui sont utilisees dans le calcul de la fonction.

0.3. PREMIERS EXEMPLES D’ALGORITHMES 5

L’algorithme 2 realise l’insertion d’un element dans un tableau trie, enpreservant l’ordre. On utilise une boucle tant que car le nombre d’iterationsa e↵ectuer depend de la valeur des donnees.

La division de l’algorithme de tri en deux algorithmes rend sa comprehen-sion, et donc sa verification, plus simple. Remarquez que dans la conditiond’arret de la boucle de l’algorithme 2, T [i] n’est pas evalue si i = 0 puisquedans ce cas, la conjonction est fausse.

Algorithme 1: TriParInsertion

entree : T [1, n] est un tableau d’entiers, n � 1.resultat : les elements de T sont ordonnes par ordre croissant.debut

pour j := 2 a n faireInsertionOrdonnee(T[j],T[1, j-1])

Algorithme 2: InsertionOrdonnee

entree : x est un entier ; T [1, n] est un tableau d’entiers trie parordre croissant.

sortie : T [1, n+ 1] contient les elements de T [ {x} ordonnes parordre croissant.

debuti := n # i est l’indice de l’element courant du tableau Ttant que i > 0 ET T [i] > x faire

# l’element courant est superieur a xT [i+ 1] := T [i] # decalage pour laisser de la place a xi := i� 1 # passage a l’element precedent

T [i+ 1] := x # insertion de x dans T .

L’algorithme 3 decrit la recherche d’un element x dans un tableau trieT [m,n] : il commence par comparer x a l’element qui se trouve au centre dutableau puis, selon les cas, arrete la recherche ou la continue sur l’une desdeux moities du tableau : la premiere si x est plus petit que l’element central,et la seconde si x est plus grand. On parle de recherche dichotomique. Cetalgorithme suit la methode diviser pour regner ( divide and conquer), quiconsiste a diviser le probleme initial en sous-problemes de tailles inferieures,a resoudre ces sous-problemes puis a combiner leurs solutions pour trouver lasolution du probleme initial. C’est un algorithme recursif puisqu’il comportedes appels a lui-meme.

6 CHAPITRE 0. INTRODUCTION.

Algorithme 3: rechercheDichotomique (T,m, n, x)

entree : T [m,n] est un tableau d’entiers trie par ordre croissant,1 m n ; x est un entier.

sortie : 0 si x 62 T et i si T [i] est la premiere occurrence de x dansT [m,n].

debutsi m = n alors

si T [m] = x alorsretourner m

sinonretourner 0

sinonk := bm+n

2

c a # on a m k < nsi T [k] < x alors

retourner rechercheDichotomique(T, k + 1, n, x)sinon

retourner rechercheDichotomique(T,m, k, x)

a. partie entiere : voir paragraphe 8.1.

Chapitre 1

Analyse des algorithmes

Analyser un algorithme consiste a calculer les ressources qui seront ne-cessaires a son execution. Mais avant cela, il faut d’abord s’assurer que l’al-gorithme est correct, c’est-a-dire qu’il calcule bien ce pourquoi il a ete ecrit.

1.1 Preuves de la correction d’un algorithme

Comment s’assurer qu’un algorithme calcule bien ce qu’il est cense cal-culer ? Comment s’assurer qu’un algorithme termine quelle que soit les don-nees qui lui seront fournies en entree ? Les algorithmes sont su�sammentformalises pour qu’on puisse prouver qu’ils possedent les proprietes atten-dues de correction ou de terminaison. Les preuves sont facilitees lorsque lesalgorithmes sont bien ecrits, et en particulier s’ils sont decomposes en denombreux sous algorithmes courts et bien specifies.

Ce sont bien evidemment les structures iteratives et les appels recursifsqui necessitent le plus de travail.

1.1.1 Preuve de la correction d’une structure iterative

Considerons le schema d’algorithme suivant :

7

8 CHAPITRE 1. ANALYSE DES ALGORITHMES

Algorithme 4: Structure iterative generique

resultat : Rdebut

Initialisation# Point Atant que Condition faire

# Point B1Instructions# Point B2

fintq# Point C

fin

Un invariant de boucle est une propriete ou une formule logique,

— qui est verifiee apres la phase d’initialisation,— qui reste vraie apres l’execution d’une iteration,— et qui, conjointement a la condition d’arret, permet de montrer que

le resultat attendu est bien celui qui est calcule.

Exemple 1 Pour l’algorithme 2 du chapitre precedent, qui insere un ele-ment x dans un tableau trie T [1, n], considerons la propriete I suivante :

« la juxtaposition des tableaux T [1, i] et T [i+2, n+1] 1 est egale

au tableau initial et x est plus petit que tous les elements du

deuxieme tableau

2 ».

1. La propriete est verifiee apres l’initialisation (point A) puisque T [1, i]est egal au tableau initial (i = n), et que le second tableau T [i+2, n+1] est vide.

2. Si la propriete I est vraie au debut d’une iteration (point B1), elle estvraie a la fin de cette iteration (point B2) puisque le dernier elementT [i] du premier tableau passe en tete du second (l’ordre n’est pasmodifie), et puisque l’on a x < T [i] et que l’indice est modifie enconsequence.

Si la condition reste vraie, alors la propriete est donc verifiee au debutde l’iteration suivante.

3. Si la condition est fausse (point C), on peut montrer que

x est � a tous les elements du premier tableau.

En e↵et,

1. si m > n, T [m,n] designe un tableau vide.

2. propriete vraie si le deuxieme tableau est vide.

1.1. PREUVES DE LA CORRECTION D’UN ALGORITHME 9

— c’est vrai si i = 0, car le premier tableau est vide,— c’est vrai si i > 0 et x � T [i], car le tableau T [1, i] est trie.

Comme l’invariant est vrai, x est a la fois � a tous les elements deT [1, i] et < a tous les elements de T [i+2, n+1]. Il su�t donc d’ecrireT [i+ 1] = x pour obtenir le resultat attendu.

Remarque : Pour prouver la correction d’une boucle Pour, on peutremarquer que

Pour i:=1 a n faire

Instructions

equivaut a

i:=1

Tant que i<= n faire

Instructions

i:=i+1

et utiliser la technique precedente.

Exemple 2 Pour prouver la correction de l’algorithme 1, on considerel’invariant de boucle suivant :

« T [1, j � 1] est trie ».

1. Apres l’initialisation, la propriete est vraie puisque j = 2 et que letableau T [1, j � 1] ne contient qu’un seul element.

2. Supposons que T [1, j � 1] soit trie au debut d’une iteration. Apresappel de l’algorithme 2, le tableau T [1, j] est trie. Apres l’incremen-tation de j, le tableau T [1, j � 1] est trie.

3. Si la condition devient fausse, c’est que j = n+ 1. Le tableau T [1, n]est donc trie.

1.1.2 Preuve de correction d’un algorithme recursif

On prouve la correction d’un algorithme recursif au moyen d’un raison-nement par recurrence.

Exemple 3 Pour prouver la correction de l’algorithme 3, on e↵ectue unerecurrence sur le nombre N = n�m+ 1 d’elements du tableau.

— si N = 1, alors m = n et on verifie que l’algorithme est correct dansce cas ;


— soit N � 1. Supposons que le programme soit correct pour touttableau de longueur N et considerons un tableau T [m,n] de N +1elements : n�m+1 = N +1. En particulier, m 6= n puisque N � 1.Soit k = bm+n

2

c. On a m k < n. En e↵et,

m < n ) m <m+ n

2< n ) m bm+ n

2c = k < n.

Donc, les deux tableaux passes en argument des appels recursifs ontau plus N elements. En e↵et, le premier a k � m + 1 elements etk � m + 1 n � m N ; le second a n � k elements et n � k n�m N . Par hypothese de recurrence, quelque soit le resultat dutest T [k] < x, l’algorithme donnera une reponse correcte.

1.1.3 Exercices

1. Recherche du plus grand element d’un tableau (version iterative) :

Algorithme 5: rechercheMaxIter

entree : T [1, n] est un tableau d’entiers.sortie : le plus grand element de T [1, n].debut

Max := T [1]pour i := 2 a n faire

si T [i] > Max alorsMax := T [i]

retourner Max

(a) Remplacez la structure iterative Pour par un Tant que.

(b) Trouvez l’invariant de boucle.

(c) Prouvez la correction de l’algorithme.

2. Recherche du plus grand element d’un tableau (version recursive) :

Algorithme 6: rechercheMaxRec

entree : T [1, n] est un tableau d’entiers.sortie : le plus grand element de T [1, n].debut

si n = 1 alorsretourner T [1]

sinonretourner max(T [n],MaxRec(T [1, n� 1]))

1.2. COMPLEXITE DES ALGORITHMES 11

(a) Prouvez la correction de l’algorithme par recurrence sur le nombred’elements du tableau.

1.2 Complexite des algorithmes

En plus d’etre correct, c’est-a-dire d’e↵ectuer le calcul attendu, on de-mande a un algorithme d’etre e�cace, l’e�cacite etant mesuree par le tempsque prend l’execution de l’algorithme ou plus generalement, par les quan-tites de ressources necessaires a son execution (temps d’execution, espacememoire, bande passante, . . . ).

Le temps d’execution d’un algorithme depend evidemment de la tailledes donnees fournies en entree, ne serait-ce que parce qu’il faut les lire avantde les traiter. La taille d’une donnee est mesuree par le nombre de bitsnecessaires a sa representation en machine. Cette mesure ne depend pas dumateriel sur lequel l’algorithme sera programme.

Mais comment mesurer le temps d’execution d’un algorithme puisqueles temps de calcul de deux implementations du meme algorithme sur deuxmachines di↵erentes peuvent etre tres di↵erents ? En fait, quelle que soit lamachine sur laquelle un algorithme est implemente, le temps de calcul duprogramme correspondant est egal au nombre d’operations elementaires ef-fectuees par l’algorithme, a un facteur multiplicatif constant pres, etce, quelle que soit la taille des donnees d’entree de l’algorithme. Par opera-tions elementaires on entend les evaluations d’expressions, les a↵ectations,et plus generalement tous les traitements en temps constant ou independantde l’algorithme (entrees-sorties, . . . ). Le detail de l’execution de ces ope-rations au niveau du processeur par l’intermediaire d’instructions machinedonnerait des resultats identiques a un facteur constant pres.

Autrement dit, pour toute machine M, il existe des constantes m etM telles que pour tout algorithme A et pour toute donnee D fournie enentree de l’algorithme, si l’on note T (D) le nombre d’operations elementairese↵ectuees par l’algorithme avec la donnee D en entree et TM(D) le tempsde calcul du programme implementant A avec la donnee D en entree,

mT (D) TM(D) MT (D).

Soit, en utilisant les notations de Landau (voir section 8.2),

T = ⇥(TM).

On peut donc definir la complexite en temps d’un algorithme comme lenombre d’operations elementaires T (n) e↵ectuees lors de son execution surdes donnees de taille n. Il s’agit donc d’une fonction. On distingue


— la complexite dans le pire des cas (worst case complexity) : Tpire

(n)est le nombre d’operations maximal calcule sur toutes les donnees detaille n ;

— la complexite dans le meilleur des cas (best case complexity) : Tmin

(n)est le nombre d’operations minimal calcule sur toutes les donnees detaille n ;

— la complexite en moyenne (average case complexity) : Tmoy

(n) lenombre d’operations moyen calcule sur toutes les donnees de taille n,en supposant qu’elles sont toutes equiprobables.

Analyser un algorithme consiste a evaluer la ou les fonctions de com-plexite qui lui sont associees. En pratique, on cherche a evaluer le comporte-

ment asymptotique de ces fonctions relativement a la taille des entrees (voirsection 8.2). En considerant le temps d’execution, dans le pire des cas ou enmoyenne, on parle ainsi d’algorithmes

— en temps constant : T (n) = ⇥(1),— logarithmiques : T (n) = ⇥(log n),— polylogarithmiques : T (n) = ⇥((log n)c) pour c > 1,— lineaires : T (n) = ⇥(n),— quasilineaires : T (n) = ⇥(n log n),— quadratiques : T (n) = ⇥(n2),— polynomiaux : T (n) = ⇥(nk) pour k 2 N,— exponentiels : T (n) = ⇥(kn) pour k > 1.

Si un traitement elementaire prends un millionieme de seconde, le tableausuivant decrit les temps d’executions approximatifs de quelques classes deproblemes en fonction de leurs tailles.

Taille n/ T (n) log2

n n n log2

n n2 2n

10 0.003ms 0.01ms 0.03ms 0.1ms 1ms

100 0.006ms 0.1ms 0.6ms 10ms 1014 siecles

1000 0.01ms 1ms 10ms 1 s

104 0.013ms 10ms 0.1 s 100 s

105 0.016ms 100ms 1.6 s 3heures

106 0.02ms 1 s 20 s 10 jours

D’un autre point de vue, le tableau ci-dessous donne la taille des problemesde complexite T que l’on peut traiter en une seconde en fonction de larapidite de la machine utilisee (F est le nombre d’operations elementairesexecutees par seconde).


F/T (n) 2n n2 n log2

n n log2

n

106 20 1.000 63.000 106 10300.000

107 23 3.162 600.000 107 103.000.000

109 30 31.000 4.107 109

1012 40 106 3.1010

En pratique, un algorithme est constitue d’instructions agencees a l’aidede structures de controle sequentielles, conditionnelles ou iteratives (nousverrons plus tard comment traiter le cas particulier des fonctions recursives).

— Le cout d’une sequence de traitements est la somme des couts dechaque traitement.

— Le cout d’une structure iterative est la somme des couts des trai-tements e↵ectues lors des passages successifs dans la boucle. Parexemple il arrive frequemment que l’on e↵ectue n fois une boucleavec des couts degressifs (Cn, C(n� 1),. . . , C). Dans ce cas

T (n) = C(n+(n�1)+(n�2)+. . .+1) = C

nX

i=1

i = Cn(n+ 1)

2= ⇥(n2).

— Le cout d’un embranchement (si test alors traitement1 sinon

traitement2) est le cout du plus couteux des deux traitements.

1.2.1 Exemples d’analyse d’algorithmes

Taille d’un tableau

Un tableau de n constantes de taille k (entiers, reels, . . .) a une taillede kn. Par ailleurs, on peut montrer que si g est constante, logarithmique,lineaire, quasilineaire, quadratique, polynomiale ou exponentielle, la fonctionn ! g(kn) est dans la meme classe de complexite. On pourra donc supposer,dans les calculs de complexite, que la taille d’un tableau de n elementsconstants est n.

L’algorithme d’insertion d’un element dans un tableau trie

Dans le pire des cas, celui ou l’entier a inserer est plus petit que tous leselements du tableau, l’algorithme 2 requiert

— 2n+ 2 a↵ectations,— 2n+ 1 comparaisons d’entiers,— n soustractions et n+ 1 addition,


— n+ 1 evaluations d’une expression booleenne

pour un tableau de n elements.

En supposant de plus que chaque instruction elementaire s’execute en untemps constant, on en deduit que T

pire

(n) = ⇥(n). L’algorithme d’insertion

ordonnee est lineaire dans le pire des cas : a des constantes additives etmultiplicatives pres, le temps d’execution est egal au nombre d’elements dutableau.

On voit facilement que Tmin

(n) = ⇥(1) : en e↵et, dans le meilleur descas, l’element a inserer est plus grand que tous les elements du tableau et laboucle n’est pas executee.

Si l’on suppose que l’element a inserer et un element pris au hasard dansle tableau, son insertion necessitera en moyenne n/2 comparaisons. On auradonc, T

moy

(n) = ⇥(n), soit une complexite moyenne du meme ordre que lacomplexite du pire des cas.

L’algorithme de tri par insertion

Dans le pire des cas, celui ou le tableau en entree est deja trie, mais parordre decroissant, l’algorithme necessite

— n�1 comparaisons et a↵ectations pour la condition de la boucle Pour— n � 1 appels a l’algorithme d’insertion ordonnee, pour des tailles de

tableaux variant de 1 a n� 1.

A des constantes additives et multiplicatives pres, le temps d’executiondans le pire des cas de l’algorithme de tri par insertion est donc egal a

(n� 1) + 1 + 2 + . . .+ (n� 1) = n� 1 +n(n� 1)

2= ⇥(n2)

soit en appliquant la remarque sur l’egalite a des constantes additives etmultiplicatives pres de la taille des donnees et du nombre d’elements dutableau,

Tpire

(n) = ⇥(n2).

On voit facilement que Tmin

(n) = ⇥(n), cas ou le tableau est deja or-donne par ordre croissant. En e↵et, chaque appel a l’algorithme d’insertionordonnee est execute en temps constant.

Si tous les elements du tableau en entree sont tires selon la meme loide probabilites, on peut montrer que T

moy

(n) = ⇥(n2). Autrement dit, s’ilpeut arriver que le temps d’execution soit lineaire, il y a beaucoup plus dechance qu’il soit quadratique en la taille des donnees en entree.


L’algorithme de recherche dichotomique

Si le tableau contient un seul element, l’algorithme executera 2 compa-raisons (cout total : c

1

).Si le tableau contient n > 1 elements, l’algorithme executera— 3 operations arithmetiques, une a↵ectation et une comparaison entre

2 entiers (cout total : c2

), et— un appel recursif sur un tableau possedant dn/2e ou bn/2c elements,

soit dn/2e dans le pire des cas.On en deduit que si n > 1,

Tpire

(n) = Tpire

(dn/2e) + c2

.

Cette equation est simple a resoudre lorsque n est egal a une puissancede 2 :

Tpire

(2h) = Tpire

(2h�1) + c2

= Tpire

(2h�2) + 2c2

= . . . = c1

+ hc2

.

Dans le cas general, soit

n = ah

2h + . . .+ a1

21 + a0

l’ecriture de n en base 2 : ah

= 1 et 0 ai

1 pour 0 i < h. On a

2h n < 2h+1 et donc 2h�1 dn/2e 2h.

On en deduit que

c1

+ hc2

Tpire

(n) c1

+ (h+ 1)c2

.

En remarquant que h = ⇥(log2

n), on en deduit que Tpire

(n) = ⇥(log2

n).La recherche dichotomique d’un element dans un tableau trie se fait doncen temps logarithmique.

L’analyse d’algorithmes conduit souvent a des equations recursives de laforme

T (n) = aT (dn/be) + f(n) ou aT (bn/bc) + f(n) (1.1)

ou b > 1, a > 0 et f est une fonction. Le theoreme 1 de la section 8.4 donnela solution de ces equations dans le cas general. Dans l’exemple precedent,on se trouve dans le cas (2) du theoreme, avec a = 1 et b = 2 : on retrouveque T

pire

(n) = ⇥(log2

n).Il est essentiel de savoir utiliser ce theoreme mais il est aussi utile de

pouvoir retrouver rapidement le resultat cherche. Nous decrivons ci-dessousquelques calculs approximatifs, a partir de l’equation simplifiee

T (n) = aT (n/b) + f(n), (1.2)

qui recouvrent un grand nombre de cas courants.


Calculs “a la main”de la complexite d’une fonction definie par unerelation de recurrence

— Nombre d’iterations : si l’on itere k fois l’equation 1.2, l’argument deT devient n/bk. On a n/bk = 1 ssi k = log

b

n. Il faut donc environlog

b

n iterations pour trouver la constante de reference T (1).— On en deduit le developpement suivant :

T (n) = f(n) + af(n/b) + · · ·+ ak�1f(n/bk�1) +⇥(alogb n).

1. Si a = 1, on a

T (n) = f(n) + f(n/b) + · · ·+ f(n/bk�1).

(a) Si f(n) = c,T (n) = kc = ⇥(log

b

n).

(b) Si f(n) = n,

T (n) = n(1 +1

b+ · · ·+ 1

bk�1

) = nb� 1

b

k

b� 1= ⇥(n).

2. Si a = b, on a

T (n) = f(n) + bf(n/b) + · · ·+ bk�1f(n/bk�1) +⇥(n).

(a) Si f(n) = c,

T (n) = c(1 + b+ · · ·+ bk�1) +⇥(n) =n� 1

b� 1+⇥(n) = ⇥(n).

(b) Si f(n) = n,

T (n) = n(1 + 1 + · · ·+ 1) +⇥(n) = nk +⇥(n) = ⇥(n logb

n).

3. Si a > b, on peut ecrire a = bh avec h > 1. On a

T (n) = f(n) + af(n/b) + · · ·+ ak�1f(n/bk�1) +⇥(nh).

(a) Si f(n) = c,

T (n) = 1 + a+ · · ·+ ak�1 +⇥(nh) =nh � 1

a� 1+⇥(nh) = ⇥(nh).


(b) Si f(n) = n,

T (n) = n(1+a/b+· · ·+(a/b)k�1)+⇥(nh) = n(a/b)k � 1

a/b� 1+⇥(nh) = ⇥(nh).

Ce que l’on peut resumer dans le tableau suivant,

T (n) a = 1 a = b a = bh

f(n) = c logb

n n nh

f(n) = n n n logb

n nh

Pour les autres cas, utilisez le theoreme.

Le tri par fusion

Le tri par fusion est un algorithme qui applique la strategie “diviser pourregner”. Le tableau a trier est divise en deux sous-tableaux de meme taille(a un element pres), l’algorithme est appele recursivement sur chacun de cessous-tableaux, et les tableaux resultants sont alors fusionnes.

Algorithme 7: TriFusion

entree : T [1, n] est un tableau d’entiers, n � 1.resultat : les elements de T sont ordonnes par ordre croissant.debut

si n > 1 alorsT1

:= triFusion(T [1, bn/2c])T2

:= triFusion(T [bn/2c+ 1, n])T := Fusion(T

1

, T2

)

On peut montrer que l’algorithme de fusion est lineaire en fonction dunombre n d’elements. Soit T (n) la complexite de l’algorithme en fonction den. L’equation de recurrence correspondante est

T (n) = T (dn/2e) + T (bn/2c) + n+ c.

Methode generale (voir le theoreme 1 de la section 8.4). On est dansle cas 2 puisque : f(n) = n+ c, a = b = 2, log

b

a = 1 et f(n) = O(n). DoncT (n) = ⇥(n log

2

n).

Solution en developpant directement la recurrence.


On peut considerer l’equation plus simple suivante : T (n) = 2T (n/2)+n.On a :

T (n) = 2T (n/2) + n = 4T (n/4) + 2n = · · · = 2kT (n/2k) + kn.

Les appels recursifs se terminent lorsque n ' 2k, soit k ' log2

(n) : il y aau plus log

2

(n) appels recursifs imbriques. On en deduit que

T (n) ' nc+ n log2

(n).

Le terme dominant etant n log2

(n), on en deduit que

T (n) = ⇥(n log2

(n)).

hauteur : dlog2

ne n

2x

n2x

n2x

n

n/2 n/2

n/4n/4n/4n/4

n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8

1 1 1 ....

log

n

Figure 1.1 – Arbre des appels recursifs pour l’algorithme de tri par fusion.

Solution intuitive.Si l’on pressent que la complexite de la fonction T verifiant T (n) =

2T (n/2) + n est ⇥(n log2

n), on peut essayer de verifier que cette intuitionest juste, c’est-a-dire, s’il existe une fonction T verifiant a la fois l’equationde recurrence et T (n) = ⇥(n log

2

n).Posons

T (n) = a · n log2

n+ bn+ c

et essayons ensuite de fixer les constantes au moyen de l’equation de recur-rence. On a :

T (n) = a · n log2

n+ bn+ c

= 2T (n/2) + n

= 2[a · n/2 log2

n/2 + bn/2 + c] + n

= a · n log2

n� an+ bn+ 2c+ n.

On en deduit que a = 1 et c = 0, b n’etant pas contraint. La fonctionT (n) = n log

2

n verifie donc l’equation T (n) = 2T (n/2) + n.


1.2.2 Exercices

Exercice 1 Montrez que

1. n log n = O(n2),

2. n log n = ⌦(n),

3. n+ sin(n) ⇠ n.

4. A t-on 2n = ⇥(en) ?

5. A t-on elog2 (n+1) = !(n) ?

Exercice 2 Quelles sont les classes de complexite des fonctions suivantes :

1. f(n) = 2n3 + 4n2 + 23,

2. f(n) = log (n2 + 3n� 1),

3. f(n) = 2log

2

(n2

+1)

2 .

Exercice 3 Quelle est la complexite de l’algorithme suivant :

Algorithme 8:

debutpour i := 1 a n ⇤ n faire

u := itant que u > 1 faire

u := u/2

Exercice 4 Calculez la complexite de la fonction qui calcule le produit dedeux matrices carrees A et B de n lignes et n colonnes.

Exercice 5 Prouvez la correction de l’algorithme recursif suivant :

Algorithme 9: expo

entree : x est un reel et n est un entiersortie : xn.debut

si n = 0 alorsretourner 1

si n = 1 ou x = 0 alorsretourner x

si n est pair alorsretourner expo(x ⇤ x, n/2)

sinonretourner x ⇤ expo(x ⇤ x, (n� 1)/2)


Combien de multiplications faut-il e↵ectuer pour calculer x20 ? pour cal-culer x2

p? pour calculer x2

p�1 ?Quelle est la complexite de l’algorithme - en terme de nombre de multi-

plications ?

Exercice 6 Ecrivez un algorithme qui prend en entree une matrice carreen ⇥ n et retourne la liste des coordonnees des cases dont la valeur est ala fois maximale sur leur ligne et minimale sur leur colonne. Quelle est lacomplexite de cet algorithme ?

Exercice 7 : Calcul de l’element majoritaire d’un tableau.Etant donne un ensemble E de n elements, on dit qu’un element e est

majoritaire dans E si le nombre d’occurrences de e est strictement superieura n/2.

1. Quel est la complexite d’un algorithme qui teste si un element e estmajoritaire ou non dans E ?

On cherche maintenant a savoir s’il existe un element majoritaire, etsi oui, a le determiner.

2. Proposez un algorithme de complexite quadratique.

3. On considere maintenant l’approche suivante, basee sur le principediviser pour regner : pour rechercher l’element majoritaire eventueldans l’ensemble E, on repartit les n elements de E dans deux en-sembles (approximativement) de meme taille E

1

et E2

. Montrez quesi un element est majoritaire dans E, alors il est majoritaire dans E

1

ou dans E2

.

Ecrivez une procedure de calcul correspondant a cette idee. Quelleest sa complexite ?

Une troisieme methode sera proposee au prochain TD.

Algorithmique 1 -...

Documents

Transcript of Algorithmique 1 -...