algorithmie - les tris

AlgorithmieLes tris

BOULCH Alexandre

Plan de la séance

Rappels

Complexité Minimale

Algorithmes quadratiques

QuickSort

Heapsort

Recherche dans un tableau

1

Les types de complexité

Deux complexités différentes

• La complexité en temps : le nombre d’opérationsélémentaires nécessaires pour effectuer l’algorithme

• La complexité en espace : la taille de la mémoire nécessaireà l’algorithme

2

Complexités classiques (en temps)

• 0(1) : accès aux éléments d’un tableau• 0(logN) : requête dans un arbre de recherche• 0(N) : parcours d’un tableau• 0(N logN) : tris rapides• 0(N2) : tris basiques• 0(2N) : problèmes difficiles

3

Exemple : la suite de Fibonacci

Dans le cours d’introduction au C++, on a vu deux méthodespour trouver les termes de la suite de Fibonnacci :{

f0 = f1 = 1fn = fn−1 + fn−2

4

Exemple : la suite de Fibonacci 2

La formulation du problème incite à l’utilisation de la récursivité.

i n t f i b 1 ( i n t n ){i f (n<2)

return 1 ;return f i b 1 (n−1)+ f i b 1 (n−2);

}

5


fib1(0) fib1(1)

fib1(2)

fib1(3)

fib1(1) fib1(0) fib1(1)

fib1(2)

fib1(4)

fib1(0) fib1(1)

fib1(2)

fib1(3)

fib1(1)

fib1(5)

6


Ici on assimile la complexité au nombre d’additions (environ lenombre d’appels à la fonction).

• fib1(0) : 0• fib1(1) : 0• fib1(2) : 1• fib1(3) : 2• fib1(4) : 4• fib1(5) : 7• fib1(6) : 12• fib1(12) : 20

7


Notant a(n) le nombre d’additions à faire au rang n :

2 ∗ a(n − 2) ≤ a(n) ≤ 2 ∗ a(n − 1)2 n

2 ≤ a(n) ≤ 2n

Ceci donne une complexité C(fib1) telle que :

O(2n2 ) ≤ C(fib1) ≤ O(2n)

Impossible à calculer pour des n grands.

8


Une seconde méthode, non récursive :

i n t f i b 2 ( i n t n ){i n t fnm2=1,fnm1=1 ;f o r ( i n t i =2; i<=n ; i++) {

i n t f n=fnm2+fnm1 ;fnm2=fnm1 ;fnm1=fn ;

}return fnm1 ;

}

9


Ici on a une seule boucle. La boucle se compose d’opérations entemps constant.

La complexité C(fib2) est O(n).

VerdictLe choix de la méthode d’implémentation peut beaucoup influersur la performance.

RemarqueLa récursivité n’est pas une mauvaise chose, elle est utile quandelle recalcule pas plusieurs fois la même chose.

10

Complexité exemples

https://fr.wikipedia.org/wiki/Analyse_de_la_complexit%C3%A9_des_algorithmes

11



Plan de la séance

Rappels



QuickSort

Heapsort


12

Complexité minimale

La complexité minimale d’un algorithme est la complexité pourlaquelle une preuve existe qu’on ne peut pas faire mieux.

13


ThéorèmeLa complexité minimale d’un algorithme de tri, d’une liste{a1, a2, ...an} à valeur dans un ensemble continu ou de grandcardinal est O(n log n).

14

Complexité minimale : preuve

• Tout algorithme de tri se base sur des comparaisons et destranspositions (le nombre de comparaisons est ici lacomplexité).

• Il doit être capable de trier quelque soit la liste en entrée, ie ildoit pouvoir envisager les n! permutations possibles

15

Complexité minimale : Arbre de tri

LemmeOn peut représenter un algorithme de tri sous la forme d’un arbreou chaque noeud correspond à une comparaison, les arètes auxrésultats des comparaisons et chaque feuille à une permutation.

Conséquences

• L’arbre est un arbre binaire, il a 2h feuilles (h est la hauteur del’arbre)

• L’arbre a au minimum n! feuilles• La hauteur de l’arbre est le nombre de comparaisonsnécessaires pour obtenir une liste triée

16


Exemple pour n = 3 et pour le tri à bulles : abc.

a>b yesnoabc bac

17



a>b

a>c

yesnoabc bac

abc cba

17



a>b

a>c

b>c

abc acb

yesnoabc bac

abc cba

17



a>b

a>c

b>c b>c

abc acb -- cba

yesnoabc bac

abc cba

17



a>b

a>c a>c

b>c b>c b>c b>c

abc acb -- cba bac bca cba--

yesnoabc bac

abc cba bac bca

17


On a donc la relation suivante :

n! ≤ 2h

En utilisant la formule de Stirling : n! ∼√2πn

(ne)n

On obtient :h = O(n log n)

18

Complexité minimale : exemple

Exemple du calcul de l’histogramme d’une image.

i n t h i s t o [ 2 5 6 ] ;f o r ( i n t i =0; i <256; i ++){

h i s t o [ i ] = 0 ;}f o r ( i n t x=0; x<image . width ( ) ; x++){

f o r ( i n t y=0; y<image . h e i g h t ( ) ; y++){h i s t o [ image ( x , y )]++;

}}

Complexité : O(n). La complexité minimale n’est pas liée àl’implémentation mais à la tâche à effectuer.

19

Plan de la séance

Rappels



QuickSort

Heapsort


20

Algorithmes quadratiques : tri à bulles

f o r ( i n t i=N; i >0; i−−){f o r ( i n t j =0; j<i −1; j++){

i f ( t [ j ] > t [ j +1]){swap ( t [ j ] , j [ j +1])

}}

}

ComplexitéOn fait (N − 1) + (N − 2) + . . .+ 1 = (N−1)(N−2)

6 comparaisons.La complexité du tri à bulles est en O(N2).

21

Plan de la séance

Rappels



QuickSort

Heapsort


22

QuickSort : principe

1. Prendre un élément (le pivot) et le placer à sa place dans letableau, de sorte qu’avant lui les éléments soient plus petits,et après lui plus grands.

2. On relance l’étape précédente sur chacune des parties dutableau.

23

QuickSort : placer le pivot

8

24


138

24


8 18 20 2 5 1 14 3 34 21 15 9 7 23 17 13

24


8 1820 2 5 1 14 3 34 21 15 97 23 17 13

24


8 18202 5 1 14 3 34 21 1597 23 17 13

24


8 18202 5 1 143 34 21 1597 23 17 13

24


8 18202 5 1 143 34 21 1597 23 1713

24

Complexité de Quicksort

Quicksort est un tri en O(N log(N)).

Démonstration dans le chapitre 3.

25

QuickSort : complexité - Pire des cas

Le parcours du tableau implique N − 1 comparaison. Donc :

CN = (N − 1) + Ci + CN−i−1

Si on suppose que i = N − 1 (déjà triée) :

CN = (N − 1) + CN−2

Au rang suivant :

CN = (N − 1) + (N − 2) + CN−3

Au final, on a un tri à bulles :

Cn = O(N2)

26

QuickSort : éviter le pire des cas

Pour eviter le pire des cas en moyenne on utilise généralement :

• un tirage du pivot au hasard• un pivot au milieu du tableau• un mélange de la liste au préalable

27

QuickSort : en pratique

• QuickSort est implémenté dans la STL (#include<algorithm>).

• Il existe des algorithmes en N logN quoi qu’il arrive(HeapSort, MergeSort ...), mais il sont moins rapide enmoyenne.

28

Plan de la séance

Rappels



QuickSort

Heapsort


29

File de priorité

La file de priorité est une structure de données :

• Accès à l’élément le plus prioritaire en O(1)• Ajout d’un élément en O(logN)• Retrait d’un élément en O(logN)

Étude au chapitre 4.

30

HeapSort

HeapSort remplit une file de priorité et puis retire les éléments unpar un.

void HeapSort ( s t d : : v e c to r<double> &v ){F i l e P r i o r i t e f ;f o r ( i n t i =0; i<v . s i z e ( ) ; i ++){

f . push ( v [ i ] ) ;}f o r ( i n t i =0; i<v . s i z e ( ) ; i ++){

v [ i ] = f . pop ( ) ;}

}

31

Conclusion

HeapSort est un tri en O(N logN) dans tous les cas. Cependant encomparaison à QuickSort, il utilise plus de mémoire et est plus longen moyenne.

En pratique c’est QuickSort le plus utilisé.

32

Heapsort : complexités à retenir

• Tri : O(N logN)• Recherche dans un tableau trié : O(logN)• Recherche dans un tableau non trié : O(N)

33

Plan de la séance

Rappels



QuickSort

Heapsort


34

Recherche dans un tableau non trié

Tableau non triéPas d’a priori sur la structure du tableau. Il faut regarder chaqueélément.

ComplexitéO(N)

35

Recherche dichotomique

Le fait de savoir que le tableau est trié permet de réduire lacomplexité de la recherche à O(log(N)).

i n t d i cho tom i e ( const s t d : : v e c to r <double>& V, double v a l ){i n t a=0, b=v . s i z e () −1;wh i l e ( a<b ){

i n t c = ( a+b ) / 2 ;i f (V[ c]== v a l )

r e t u r n c ;i f (V[ c ]< v a l )

a = c +1;e l s e

b = c −1;}r e t u r n (V[ a]== v a l ) ? a : −1;

}

36

Exemple - Tri à peigne

AlgorithmeComme le tri à bulle, mais on commence avec un intervalle de N(tri à bulle c’est 1). Puis on réduit l’intervalle par un facteur α (engénéral, empiriquement, α = 1.3).

• beaucoup plus efficace que le tri à bulles• tri en place (pas d’allocation de nouveau tableau)• complexité pire des cas : O(n2)• Meilleur des cas : O(n log n)

37

TP

Algorithmes de tri.

38

algorithmie - les tris

Documents