algorithmie - les tris
Post on 21-Mar-2022
14 Views
Preview:
TRANSCRIPT
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
Exemple : la suite de Fibonacci 3
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
Exemple : la suite de Fibonacci 4
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
Exemple : la suite de Fibonacci 5
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
Exemple : la suite de Fibonacci 6
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
Exemple : la suite de Fibonacci 7
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
Complexité Minimale
Algorithmes quadratiques
QuickSort
Heapsort
Recherche dans un tableau
12
Complexité minimale
La complexité minimale d’un algorithme est la complexité pourlaquelle une preuve existe qu’on ne peut pas faire mieux.
13
Complexité minimale
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
Complexité minimale : Arbre de tri
Exemple pour n = 3 et pour le tri à bulles : abc.
a>b yesnoabc bac
17
Complexité minimale : Arbre de tri
Exemple pour n = 3 et pour le tri à bulles : abc.
a>b
a>c
yesnoabc bac
abc cba
17
Complexité minimale : Arbre de tri
Exemple pour n = 3 et pour le tri à bulles : abc.
a>b
a>c
b>c
abc acb
yesnoabc bac
abc cba
17
Complexité minimale : Arbre de tri
Exemple pour n = 3 et pour le tri à bulles : abc.
a>b
a>c
b>c b>c
abc acb -- cba
yesnoabc bac
abc cba
17
Complexité minimale : Arbre de tri
Exemple pour n = 3 et pour le tri à bulles : abc.
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
Complexité minimale
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
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
Complexité Minimale
Algorithmes quadratiques
QuickSort
Heapsort
Recherche dans un tableau
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
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
Complexité Minimale
Algorithmes quadratiques
QuickSort
Heapsort
Recherche dans un tableau
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 : 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
Complexité Minimale
Algorithmes quadratiques
QuickSort
Heapsort
Recherche dans un tableau
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
Complexité Minimale
Algorithmes quadratiques
QuickSort
Heapsort
Recherche dans un tableau
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
top related