Algorithmique IN102-01

(1)

Algorithmique IN102-01

Michel Mauny

ENSTA

Pr´[email protected]

Michel Mauny (ENSTA) Algorithmique IN102-01 Pr´[email protected] 1 / 1

1 Pr´eliminaires Organisation

Evaluation, supports de cours´ Objectifs

2 Cours 1 – Notions de complexit´e

Algorithmes et mesures de complexit´e Suite de Fibonacci

Algorithmes de tri Efficacit´e

(2)

Groupes

Deux types de groupes : Groupes «A» et «B»

Mêmes exigences, même évaluation Seuls les TD/PC diffèrent

Les groupes B_1,2 (resp. B_3,4) dans des salles attenantes

Programme

02/12 Complexit´e [PC]

09/12 Structures de donn´ees simples 16/12 Recherche en table [PC]

— —

06/01 Arbres 13/01 Graphes

20/01 Analyse syntaxique [PC]

27/01 Contrˆole

(3)

Evaluation, supports de cours ´

Contrˆole de 3 heures le 27 janvier 2006

petits exercices (fonctions de 10 lignes — voir `a la fin du poly) documents de cours autoris´es

Supports de cours

Poly de Guillaume Poupard Planches

Sujets de PC/TP

Page web `a http://www.mauny.net/cours/ensta/algo/

Objectifs

Motivation : prendre du recul par rapport `a la programmation identification du probl`eme

recherche d’un algorithme analyse de complexit´e mise en œuvre

D´efinition du terme «algorithme»

Suite d’opérations élémentaires constituant un schéma de calcul ou de résolution d’un problème

(Petit Larousse)

(4)

Complexit´ e d’algorithmes

But : mesurer l’efficacité intrinsèque d’un algorithme en fonction de la taille des données à traiter

par dénombrement d’opérations élémentaires représentatives mesure asymptotique

complexit´e dans le cas le pire ou en moyenne complexit´e temporelle ou spatiale

Exemple classique : le tri

But : trier un tableau de n entiers d´enombrement des comparaisons

performance des algorithmes ´el´ementaires : «de l’ordre de» n² comparaisons

algorithmes plus sophistiqu´es font passer de n² `a n×log(n)

(5)

Notations de complexit´ e

D´efinitions :

f(n) = O(g(n)) ssi 0 ≤ f(n) ≤ c×g(n)

f(n) = Θ(g(n)) ssi c×g(n) ≤ f(n) ≤ c⁰×g(n) Exemples :

n² + 3n+ 1 = Θ(n²) = Θ(50n² + 12345) n/ln(n) = O(n)

50n¹⁰ = O(n^10,01) 2ⁿ = O(exp(n)) exp(n) = O(n!)

Hi´ erarchie de fonctions

On peut ´etablir une hi´erarchie entre les fonctions usuelles : log(n) √

n n n² n³ 2ⁿ exp(n) n!

log(n) 3,3 6,6 10

p(n) 3,1 10 32

n 10 100 1000

n×log(n) 33 664 10⁴

n² 100 10⁴ 10⁶

n³ 10³ 10⁶ 10⁹

2ⁿ 10³ 10³⁰ 10³⁰⁰ exp(n) 2×10⁴ 10⁴³ 10⁴³⁴

n! 3,6×10⁶ 10¹⁵⁸ 10²⁵⁶⁸

Note : nombre de particules dans l’univers ≈ 10⁸⁰.

(6)

Suite de Fibonacci, version 1

F₀ = F₁ = 1

F_n = F_n−1 +F_n−2 si n > 1 1, 1, 2, 3, 5, 8, 13, 21, 34, . . .

Code r´ ecursif en C

int fibo₁ (int n) { if (n ≤ 1)

return 1;

else

return fibo1(n−1)+fibo1(n−2);

}

Complexit´e : Θ(((1 +√

5)/2)ⁿ)

Suite de Fibonacci, version 1

Calcul de F

₅

.....................

........

......

K F0

F1

F2

.....................

........

......

K

.....................

........

......

K

F0

F1

F2

F3

F1

@

@@ I

.....................

........

......

K

.....................

........

......

K *

H HH H Y F4

F1 F0

F2 F1

F5

F3

Complexit´e : Θ(((1 +√

5)/2)ⁿ)

(7)

Suite de Fibonacci, version 2

Calcul de F

₈

F₀ F₁ F₂ F3 F4 F5 F₆ F₇ F₈

1 1 2 3 5 8 13 21 34

Complexit´e Θ(n)

Complexit´e spatiale Θ(n)

Suite de Fibonacci, version 2

Code it´ eratif en C, avec tableau auxiliaire

int fibo2 (int n) {

int ∗t; int i, int res;

t = new int[n+1];

t[0] = 1; t[1] = 1;

for (i=2; i≤n; i++) t[i] = t[i−1]+t[i−2];

res=t[n]; free(t);

return res;

}

Complexit´e Θ(n)

Complexit´e spatiale Θ(n)

(8)

Suite de Fibonacci, version 3

Calcul de F

₈

-

- -

1 1 2

F2 F3 F4

2 3 5

1 2 3 F5 F₆ F₇ F₈

8 13 21 34

5 3

F4

Complexit´e Θ(n)

Complexit´e spatiale Θ(1) (constante)

Suite de Fibonacci, version 3

Code it´ eratif en C, espace constant

int fibo₃ (int n) { int f₁, f₂, t, i;

f₁=1; f₂=1;

for (i=2; i≤n; i++) { t=f2; f₂=f1+f2; f₁=t;

}

return f2; }

Complexit´e Θ(n)

Complexit´e spatiale Θ(1) (constante)

(9)

Suite de Fibonnacci, version 4

F_n+1 = 1×F_n + 1×F_n−1 F_n = 1×F_n + 0×F_n−1

F_n

F_n−1

=

1 1

1 0

×

F_n−1

F_n−2

=

1 1

1 0

n−1

×

F₁

F₀

On se ramène à un problème «d’exponentiation matricielle» (voir PC)

Complexit´e : Θ(log(n))

Complexit´e spatiale : Θ(1) (constante)

Pratique et th´ eorie sont d’accord

Temps de calcul

n 40 5.10⁷ 2.10⁸ 2.10⁹ fibo₁(n) 31 s calcul irr´ealisable fibo₂(n) 0 s 18 s erreur d’ex´ecution fibo3(n) 0 s 4 s 19 s 3 min 15 s fibo₄(n) 0 s 0 s 0 s 0 s

(10)

Le tri

But : trier un tableau de n éléments (entiers, par exemple) Dénombrement de comparaisons

Algorithmes ´el´ementaires en O(n²)

Algorithmes plus sophistiqu´es font passer de O(n²) `a O(n×log(n))

Tri par insertion

Tri du tableau

tab

de n entiers

void triInsertion(int ∗tab, int n) { int i,j, clef;

for (i=1; i<n; i++) { clef = tab[i]; j = i−1;

while ( (j≥0) && (tab[j]>clef) ) { tab[j+1] = tab[j]; j = j−1; } tab[j+1]=clef; }

}

L’élément au rang k est rangé parmi ses k−1 prédécesseurs.

Complexité Θ(n²) dans le cas le pire : tableau inversement trié Complexité Θ(n²) en moyenne.

(11)

Le tri par fusion

Diviser,

(diviser, (...), et fusionner)

, et fusionner

......

R

. .. .. .. .. .. .. .. . .. .. ..

. .. .. .. .. .. .. .. . .. .. .. ......

R

@

@@R

.. . .. .. .. .. . .. .. .. .. .

.. . .. .. .. .. . .. .. .. .. ...... .

R

......

R

@@R

Tri r´ecursif ... ...

...

Fusion

r (p+r)/2

p

p r

Tri par fusion

Tri du tableau

tab

entre les indices

p

et

r

void triFusion(int ∗tab, int p,r) { if (p<r) {

int q = (p+r)/2;

triFusion(tab, p, q);

triFusion(tab, q+1, r);

fusion(tab, p, q, r);

}

(12)

Tri rapide (quicksort)

Quicksort : tri r´ecursif bas´e sur un partitionnement.

Tri du tableau

tab

entre les indices

p

et

r

void triRapide(int ∗tab, int p,r) { if (p<r) {

int q = partitionner(tab, p, r);

triRapide(tab, p, q−1);

triRapide(tab, q+1, r);

}

Complexit´e dans le cas le pire : Θ(n²) Complexit´e en moyenne : Θ(n×log(n))

Complexit´ e compar´ ee

Algorithme Cas le pire En moyenne Tri par insertion

Tri `a bulle Θ(n²) Θ(n²)

Tri rapide Θ(n²) Θ(n×log(n)) Tri par fusion Θ(n×log(n)) Θ(n×log(n))

(13)

Th´ eorie et pratique sont d’accord

Temps de calcul :

Th´ eorie et pratique sont d’accord

(14)

Th´ eorie et pratique. . .

(15)

Exemple : produit matriciel

But : multiplier 2 matrices n×n

Dénombrement des additions et multiplications entre éléments de base Algorithmes élémentaires en O(n³)

Algorithmes tr`es sophistiqu´es en O(n^2,376)

Qu’est-ce qu’un algorithme efficace ?

Complexit´e en moyenne

Complexit´e dans le pire des cas Facilit´e de mise en œuvre

Efficacit´e en pratique Algorithmes hybrides