Chapitre iv algorithmes de tri

3,425 views
3,181 views

Published on

Published in: Education
0 Comments
6 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,425
On SlideShare
0
From Embeds
0
Number of Embeds
14
Actions
Shares
0
Downloads
255
Comments
0
Likes
6
Embeds 0
No embeds

No notes for slide

Chapitre iv algorithmes de tri

  1. 1. Université Saad Dahleb de Blida Faculté des Sciences Département d’Informatique Licence Génie des Systèmes Informatique (GSI) Semestre 5 (3ème année) ALGORITHMIQUE 02 CHAPITRE IV: ALGORITHMES DE TRI Cours n°7: 30 Octobre 2013 AROUSSI Sana Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
  2. 2. PLAN DU CHAPITRE IV  Introduction  Tri par Sélection  Tri par Insertion  Tri par Propagation  Tri par Fusion  Tri Rapide  Tri par ABR (Arbre Binaire de Recherche)  Tri par TAS  Conclusion 2
  3. 3. INTRODUCTION  Étant donné un tableau d’entiers T (n: sa taille), l’algorithme du trie permet d’organiser les éléments du tableau selon un ordre déterminé (croissant par exemple).  Plusieurs algorithmes de tri existent: tri par sélection, par insertion, par bulle, par fusion, rapide, par ABR et par TAS.  L’objectif de ce cours est de concevoir ces algorithmes de tri de manière récursive, ensuite, de calculer leur complexité. 3
  4. 4. TRI PAR SÉLECTION PRINCIPE  Le principe est de rechercher la plus petite valeur et la placer au début du tableau, puis la plus petite valeur dans les valeurs restantes et la placer à la deuxième position et ainsi de suite... 7 3 18 13 7 3 7 7 13 18 3 7 7 13 18 7 3 18 13 7 3 7 7 13 18 3 3 7 7 18 13 7 18 13 7 4
  5. 5. TRI PAR SÉLECTION ALGORITHME RÉCURSIF Tri_Selection (T: tableau, debut, fin : entier) Debut Si (debut < fin) alors min rechercher_min(T, debut, fin) Permuter (T, debut, min) Tri_Selection (T, debut + 1, fin) FSI Fin 5
  6. 6. TRI PAR SÉLECTION FONCTION « RECHERCHER_MIN » Rechercher_min (T: tableau, debut, fin : entier): entier Debut min debut Pour idebut +1 à fin faire Si (T[i] < T[min]) alors min  i; Rechercher_min  min; Fin 6
  7. 7. TRI PAR SÉLECTION COMPLEXITÉ DE LA FONCTION « RECHERCHER_MIN » Rechercher_min (T: tableau, debut, fin : entier): entier Debut min debut C1 Pour idebut +1 à fin faire Si (T[i] < T[min]) alors min  i; Nombre d’itération = Fin – debut = n-1 Rechercher_min  min; C3 Fin Tmin (n) = C1 + C2 (n-1) + C3 = C’ n + C’’  O(Tmin) = O (n) 7
  8. 8. TRI PAR SÉLECTION COMPLEXITÉ Tri_Selection (T: tableau, debut, fin : entier) T (n) tq n = fin – debut + 1 Debut Si (debut < fin) alors min rechercher_min(T, debut, fin) Permuter (T, debut, min) Tmin (n) C1 Tri_Selection (T, debut + 1, fin) T (n - 1) FSI Fin T (n) = T(n-1) + Tmin (n) + C O(T) = O (n2) 8
  9. 9. TRI PAR INSERTION PRINCIPE  Le principe est d’ordonner les deux premiers éléments et d’insérer le 3e élément de manière à ce que les 3 premiers éléments soient triés, ensuite d’ insérer le 4e élément à sa place et ainsi de suite. A la fin de la ie itération, les i premiers éléments de T sont triés et rangés au début du tableau T′ 7 3 18 13 7 3 7 18 13 7 3 7 7 3 7 7 13 18 13 18 3 3 7 7 18 13 7 13 18 7 9
  10. 10. TRI PAR INSERTION ALGORITHME RÉCURSIF Tri_Insertion (T: tableau, n : entier) Debut Si (n>1) alors Tri_Insertion(T,n-1); Insérer (T, n) // insérer le nème élément à sa place dans le tableau T[1..n-1] FSI Fin 10
  11. 11. TRI PAR INSERTION PROCÉDURE « INSÉRER » Inserer (T: tableau, n : entier) Debut in-1 Tant que (i>0 et T[i]>T[i+1]) faire DTQ Permuter (i+1, i) i i-1 FTQ FSI Fin 11
  12. 12. TRI PAR INSERTION COMPLEXITÉ DE LA PROCÉDURE « INSÉRER » Inserer (VAR T: tableau, n : entier) Debut in-1 Tant que (i>0 et T[i]>T[i+1]) faire DTQ Permuter (i+1, i) i i-1 Pire des cas que le nème élément contient la valeur la plus petite et dans ce cas on doit parcourir tous le tableau  Nombre d’itération maximal = n n-1 FTQ FSI Fin 12 Tinsérer (n) = C1 n + C2  O(Tinsérer) = O (n)
  13. 13. TRI PAR INSERTION COMPLEXITÉ Tri_Insertion (T: tableau, n : entier) T (n) tq n taille du tableau Debut Si (n>1) alors Tri_Insertion(T,n-1); T (n - 1) // insérer le n-ème élément dans le tableau T[1..n-1] : Insérer (T, n) Tinsérer (n ) FSI Fin 13 T (n) = T(n-1) + Tinsérer (n ) O(T) = O (n2)
  14. 14. TRI PAR PROPAGATION PRINCIPE  L'algorithme de tri par propagation (ou à bulles) consiste à faire remonter progressivement les plus grands éléments d'un tableau. Son principe est d’inverser deux éléments successifs s'ils ne sont pas classés dans le bon ordre et de recommencer jusqu'à ce qu’on ne peut plus permuter. 7 3 3 3 7 7 3 13 7 13 7 18 18 3 7 18 13 7 3 18 13 7 7 13 7 7 7 18 13 18 3 3 3 7 7 7 18 13 7 13 18 7 7 13 18 14
  15. 15. TRI PAR PROPAGATION ALGORITHME RÉCURSIF Tri_Propagation (T: tableau, n : entier) Debut Si non Trier (T, n) alors DSI Pour i 1 à n-1 faire Si T[i] > T[i+1] alors permuter (T[i], T(i+1)) // La dernière case contient toujours l’élément le plus grand Tri_Propagation (T, n-1) FSI Fin 15
  16. 16. TRI PAR PROPAGATION FONCTION « TRIER » Fonction Trier (T: tableau, n : entier) : Booléen; Debut Ok vrai; i 1; Tant que (i <n et non OK) faire DTQ Si T[i]>T[i+1] alors okfaux ii+1 FTQ Trier  OK Fin 16
  17. 17. TRI PAR PROPAGATION COMPLEXITÉ DE LA FONCTION « TRIER » Fonction Trier (T: tableau, n : entier) : Booléen; Debut Ok vrai; i 1; Tant que (i <n et non OK) faire DTQ Si T[i]>T[i+1] alors okfaux ii+1 Pire des cas que le tableau soit trié et dans ce cas on parcourt tous le tableau  Nombre d’itération maximal = n n-1 FTQ Trier  OK Fin 17 Ttrier (n) = C1 n + C2  O(Ttrier) = O (n)
  18. 18. TRI PAR PROPAGATION COMPLEXITÉ Tri_Propagation (T: tableau, n : entier) Debut T (n) tq n taille du tableau Ttrier (n) Si non Trier (T, n) alors DSI Pour i 1 à n-1 faire Si T[i] > T[i+1] alors permuter (T[i], T(i+1)) n-1 fois // La dernière case contient toujours l’élément le plus grand Tri_Propagation (T, n-1) T (n-1) FSI Fin 18 T (n) = T(n-1) + Ttrier (n) + c1(n-1) + c2 O(T) = O (n2)
  19. 19. TRI PAR FUSION PRINCIPE  Le principe est de trier deux tableaux de taille N/2 et ensuite de les fusionner de sorte à ce que le tableau final soit trié. 7 7 3 3 7 18 13 7 18 3 3 18 13 7 13 7 13 7 7 7 7 13 13 18 19 3 7 7 10 13 18
  20. 20. TRI PAR FUSION PARADIGME DIVISER POUR RÉGNER  DIVISER: Diviser le tableau en deux tableaux: T [debut..fin] = T1[debut..milieu] + T2[milieu+1..fin]  REGNER: trier (par fusion) les deux tableaux  COMBINER: combiner les 2 tableaux de telle manière que le tableau T reste trie 20
  21. 21. TRI PAR FUSION ALGORITHME RÉCURSIF Tri_Fusion (T: tableau, debut, fin : entier) Debut Si (debut<fin) alors milieu  (debut + fin) /2 Tri_Fusion(T, debut, milieu); Tri_fusion (T, milieu + 1, fin); Fusionner (T, debut, milieu, fin) FSI Fin 21
  22. 22. TRI PAR FUSION PROCÉDURE « FUSIONNER » Procédure fusionner(VAR T: tableau, debut, milieu, fin: entier) Debut Tmp: tableau temporaire du taille fin-debut+1 i debut; gauche  debut, droite  milieu + 1; Tant que (i<=fin) faire Si ((gauche<=milieu et T[gauche]<T[droite]) ou droite>fin) alors Tmp[i]T[gauche]; gauche++; Sinon Tmp [i]T[droite]; droite++; // recopier le tableau Pour idebut à fin faire T[i]=tmp[i] Fin 22
  23. 23. TRI PAR FUSION COMPLEXITÉ DE LA PROCÉDURE « FUSIONNER » Procédure fusionner(VAR T: tableau, debut, milieu, fin: entier) Tfusionner(n) tq n= fin – debut +1 Debut Tmp: tableau temporaire du taille fin-debut+1 i debut; gauche  debut, droite  milieu + 1; Tant que (i<=fin) faire Si ((gauche<=milieu n fois et T[gauche]<T[droite]) ou droite>fin) alors Tmp[i]T[gauche]; gauche++; Sinon Tmp [i]T[droite]; droite++; // recopier le tableau Pour idebut à fin faire T[i]=tmp[i] Fin n fois Tfusionner(n) = c1 * n + c2  O (Tfusionner) = O (n) 23
  24. 24. TRI PAR FUSION COMPLEXITÉ Tri_Fusion (T: tableau, debut, fin : entier) T (n) tq n taille du tableau Debut Si (debut<fin) alors milieu  (debut + fin) /2 Tri_Fusion(T, debut, milieu); T (n/2) Tri_fusion (T, milieu + 1, fin); T (n/2) Fusionner (T, debut, milieu, fin) Tfusionner(n) FSI Fin 24 T (n) = 2T(n/2) + Tfusionner(n) O(T) = O (n log2 n)
  25. 25. Université Saad Dahleb de Blida Faculté des Sciences Département d’Informatique Licence Génie des Systèmes Informatique (GSI) Semestre 5 (3ème année) ALGORITHMIQUE 02 CHAPITRE IV: ALGORITHMES DE TRI Cours n°8: 3 Novembre 2013 AROUSSI Sana Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
  26. 26. TRI RAPIDE PRINCIPE  Le principe est de choisir une valeur dans le tableau appelée pivot (par exemple la première valeur du tableau) et de déplacer avant elle toutes celles qui lui sont inférieures et après elle toutes celles qui lui sont supérieures. Réitérer le procédé avec la tranche de tableau inférieure et la tranche de tableau supérieure à ce pivot. 26
  27. 27. TRI RAPIDE PARADIGME DIVISER POUR RÉGNER  DIVISER: Diviser le tableau en deux tableaux selon le pivot choisi : T1[debut..pivot] et T2[pivot+1..fin]  REGNER: trier (par trie rapide) les deux tableaux  COMBINER: combiner les 2 tableaux: T [debut..fin] = T1[debut..pivot] + T2[pivot+1..fin] est trié 27
  28. 28. TRI RAPIDE ALGORITHME RÉCURSIF Tri_Rapide (T: tableau, debut, fin : entier) Debut SI debut < fin alors Pivotpartitionner(T, debut, fin , pivot) Tri_Rapide(T, debut, pivot) Tri_Rapide(T, pivot+1, fin) FSI Fin 28
  29. 29. TRI RAPIDE FONCTION « PARTITIONNER » Partitionner (T: tableau, debut, fin, pivot: entier): entier Debut permuter (T[pivot], T[fin]) j premier Pour i 1 à fin -1 faire SI T[i] <= T[fin] alors Permuter (T[i], T[j]) jj+1 FSI FP Permuter (T[fin] , T[j]) Partitionner  j Fin 29
  30. 30. TRI RAPIDE FONCTION « PARTITIONNER » Partitionner (T: tableau, debut, fin, pivot: entier): entier Debut permuter (T[pivot], T[fin]) j premier Pour i 1 à fin -1 faire SI T[i] <= T[fin] alors Permuter (T[i], T[j]) jj+1 FSI FP Permuter (T[fin] , T[j]) Partitionner  j Fin 30
  31. 31. TRI RAPIDE COMPLEXITÉ DE LA FONCTION « PARTITIONNER » Partitionner (T: tableau, debut, fin, pivot: entier): entier Debut permuter (T[pivot], T[fin]) Tpartitionner(n) tq n= fin – debut +1 j premier Pour i 1 à fin -1 faire Pire de cas: n-1 fois SI T[i] <= T[fin] alors Permuter (T[i], T[j]) jj+1 FSI FP Permuter (T[fin] , T[j]) Partitionner  j Fin Tpartitionner(n) = c1 * n + c2  O(Tpartitionner) = O (n) 31
  32. 32. TRI RAPIDE COMPLEXITÉ Tri_Rapide (T: tableau, debut, fin : entier) T(n)/ n= fin – debut +1 Debut SI debut < fin alors Pivotpartitionner(T, debut, fin , pivot) Tri_Rapide(T, debut, pivot) Tri_Rapide(T, pivot+1, fin) Tpartitionner(n) T(pivot-debut+1) T(fin-pivot) FSI Fin 32 T (n) = T(pivot-debut+1) + T(fin-pivot) + Tpartitionner(n)
  33. 33. TRI RAPIDE CHOIX DU PIVOT ET COMPLEXITÉ T (n) = T(pivot-debut+1) + T(fin-pivot) + Tpartitionner(n)  Cas 1: Pivot aléatoire. Le pire cas intervient quand le partitionnement produit une région à n-1 éléments et une région à un élément: T(n) = T(n-1) + T(1) + Tpartitionner(n) = T(n-1) + f(n)  O(T) = O(n2)  Cas 2: Pivot Arbitraire (premier élément, dernier 33 élément ou élément en milieu ). Même chose que le cas 1.
  34. 34. TRI RAPIDE CHOIX DU PIVOT ET COMPLEXITÉ T (n) = T(pivot-debut+1) + T(fin-pivot) + Tpartitionner(n)  Cas 3: Pivot optimal comme la valeur médiane qui permet de couper le tableau en deux parties égales de taille n/2 : T(n) = 2T(n/2) + Tpartitionner(n)  O(T) = O(n log2 n) 34
  35. 35. Université Saad Dahleb de Blida Faculté des Sciences Département d’Informatique Licence Génie des Systèmes Informatique (GSI) Semestre 5 (3ème année) ALGORITHMIQUE 02 CHAPITRE IV: ALGORITHMES DE TRI Cours n°9: 10 Novembre 2013 AROUSSI Sana Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
  36. 36. TRI PAR ABR DÉFINITION  Un Arbre Binaire de Recherche (ABR) est un arbre binaire, dans lequel chaque nœud contient un entier en respectant la propriété suivante :  Inférieur (ou égal) aux entiers de son sous-arbre gauche  Supérieur strictement aux entiers de son sous-arbre droit 36
  37. 37. TRI PAR ABR PRINCIPE 1. Insérer toutes les éléments du tableau dans un ABR 20 15 10 35 19 13 5 3 12 7 16 40 25 38 20 15 35 25 10 40 19 5 3 13 7 12 38 16 37
  38. 38. TRI PAR ABR PRINCIPE 2. Parcourir l’ABR en ordre infixé: fils gauche, nœud, 20 fils droit 15 35 25 10 40 19 5 3 3 5 7 13 7 12 38 16 10 12 13 15 16 19 20 25 35 38 40 38
  39. 39. TRI PAR ABR ALGORITHME ITÉRATIF Soit AR un arbre de recherche binaire Tri_ARB_IT (T: Tableau, n: entier) Debut // Construire ARB ARNil Pour i1 à n faire ARInsérer (AR, T[i]). Parcours_Infixe (AR, T); //Parcours Infixe Fin 39
  40. 40. TRI PAR ABR FONCTION « INSÉRER » Insérer (AR: nœud , x: entier): nœud Debut SI (AR=Nil) alors // L’arbre est vide AR Noeud(x,Nil,Nil) // Créer la racine (le premier nœud) SINON SI x ≤ valeur(AR) alors AR.FGInsérer(x, FG(AR)) // Insérer à gauche SINON AR.FDInsérer(x, FD(AR)) // Insérer à droite FSI Insérer  AR Fin 40
  41. 41. TRI PAR ABR TERMINOLOGIE  Si h est la hauteur d’un arbre binaire de recherche, et n le nombre des nœuds (ou la taille du tableau) h=0 20 h=1 19 10 h=2 h=3 h=4 35 15 5 3 13 7 12 16 25 h=4 40 n = 14 38 41
  42. 42. TRI PAR ABR COMPLEXITÉ DE LA FONCTION « INSÉRER » Insérer (AR: nœud , x: entier): nœud Tinsérer (h) tq h est la hauteur de l’arbre Debut SI (AR=Nil) alors // L’arbre est vide AR Noeud(x,Nil,Nil) // Créer la racine (le premier nœud) SINON SI x ≤ valeur(AR) alors AR.FGInsérer(x, FG(AR)) // Insérer à gauche Tinsérer (h +1) SINON AR.FDInsérer(x, FD(AR)) // Insérer à droite Tinsérer (h +1) FSI Insérer  AR Fin 42 Tinsérer (h+1) = Tinsérer (h) + c  O(Tinsérer ) = O (h)
  43. 43. TRI PAR ABR COMPLEXITÉ DE LA FONCTION « INSÉRER » O(Tinsérer) = O (h)  Pire de cas: un tableau déjà trié  Arbre mal équilibré  h = n-1  O(Tinsérer) = O(n-1) = O(n) h=0 25 h=1 18 25 15 5 2 15 h=2 h=3 h=4 18 5 2 43
  44. 44. TRI PAR ABR PARCOURS INFIXÉ Soit « indice » une variable globale initialisé à 1 Parcours_Infixe (AR: nœud, T: Tableau) Debut Si ( AR  Nil) alors //Arbre n’est pas vide Parcours_Infixe(FG(AR, T, indice)) T[indice]valeur (AR) //Écrire la valeur dans le tableau Indice  indice + 1; Parcours_Infixe(FD(AR), T, indice) FSI Fin 44
  45. 45. TRI PAR ABR COMPLEXITÉ DU PARCOURS INFIXÉ Soit « indice » une variable globale initialisé à 1 Parcours_Infixe (AR: nœud, T: Tableau) Tinfixe (n) tq n le nombre des nœuds Debut Si ( AR  Nil) alors //Arbre n’est pas vide Parcours_Infixe(FG(AR, T, indice)) Tinfixe (k) T[indice]valeur (AR) //Écrire la valeur dans le tableau Indice  indice + 1; Parcours_Infixe(FD(AR), T, indice) Tinfixe (n-k-1) FSI Fin 45 Tinfixe (n) = Tinfixe (k) + Tinfixe (n-k-1) + c
  46. 46. TRI PAR ABR COMPLEXITÉ DU PARCOURS INFIXÉ Tinfixe (n) = Tinfixe (k) + Tinfixe (n-k-1) + c  Évidemment, le parcours infixé passe par tous les nœuds de l’arbre, ainsi O(Tinfixe) = O(n)  Démonstration par récurrence  Cas évident n = 0, T(0) = 0  O(T) = O(0) = O (n) vérifiée  Hypothèse de récurrence pour k<n , on a O(T) = O (k)  T(k) = a k + b  Cas général: Tinfixe (n) = Tinfixe (k) + Tinfixe (n-k-1) + c Tinfixe (n) = a k + b + a (n-k-1) + b + c = a n + (2 b –a + c) Tinfixe (n) = a n + d  O(Tinfixe) = O(n) ..........................CQFD 46
  47. 47. TRI PAR ABR COMPLEXITÉ DE L’ALGORITHME ITÉRATIF Soit AR un arbre de recherche binaire Tri_ARB_IT (T: Tableau, n: entier) TARB (n) Debut // Construire ARB O(TARB)= n * O (n) + O (n) = O (n2) + O(n) ARNil Pour i1 à n faire n fois = O(n2) ARInsérer (AR, T[i]). Tinsérer (n) Parcours_Infixe (AR, T); //Parcours Infixe Tinfixe (n) Fin 47
  48. 48. TRI PAR ABR ALGORITHME RÉCURSIF Tri_ABR(T: Tableau, n: entier, AR: nœud) Debut SI (n>0) alors Insérer (ARB, T[n]) Tri_ABR(T, n-1, AR) SINON // n=0 l’arbre est construit en totalité Parcours_Infixe (AR, T); FSI Fin 48
  49. 49. TRI PAR ABR COMPLEXITÉ DE L’ALGORITHME RÉCURSIF Tri_ABR(T: Tableau, n: entier, AR: nœud) TARB (n) Debut SI (n>0) alors Insérer (ARB, T[n]) Tri_ABR(T, n-1, AR) Tinsérer (n) TARB (n-1) SINON // n=0 l’arbre est construit en totalité Parcours_Infixe (AR, T); Tinfixe (n) FSI Fin 49 TARB (n)= TARB (n – 1 ) + Tinsérer (n)  O (TARB ) = O(n2)
  50. 50. Université Saad Dahleb de Blida Faculté des Sciences Département d’Informatique Licence Génie des Systèmes Informatique (GSI) Semestre 5 (3ème année) ALGORITHMIQUE 02 CHAPITRE IV: ALGORITHMES DE TRI Cours n°10: 17 Novembre 2013 AROUSSI Sana Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
  51. 51. TRI PAR TAS DÉFINITION  Un TAS un arbre binaire qui vérifie les deux propriétés suivantes :  Propriété structurelle: arbre binaire complet (ou parfait), i.e. Tous les niveaux sont totalement remplis sauf le dernier qui est rempli de la gauche vers la droite.  Propriété d’ordre :  TASmin: valeur (père)  valeur (fils)  TASmax: valeur (père)  valeur (fils) 51
  52. 52. TRI PAR TAS TASMIN 4 Minimum 5 6 15 16 9 25 14 7 12 11 20 8 Maximum 52
  53. 53. TRI PAR TAS TASMAX 40 Maximum 35 15 1 26 19 13 14 17 12 11 20 8 Maximum 53
  54. 54. TRI PAR TAS HAUTEUR D’UN TAS  Théorème: Un tas de n nœud a une hauteur O(log2 n)  Démonstration  Soit h, la hauteur d’un tas de n nœud h=0 ; n0 = 20 h=1 ; n1 = 21 h=2 ; n2 = 22 h=3 ; n3 = 23 54
  55. 55. TRI PAR TAS HAUTEUR D’UN TAS  Théorème: Un tas de n nœud a une hauteur O(log2 n)  Démonstration  Soit h, la hauteur d’un tas de n nœud  Au niveau ih, ni=2i  Donc n = 20 + 21 + 22 + ....+ 2h-1 + c tel que , 0c<2h n = 2h + c  2h h  log2 n  O(h) = O(log2 n).  Conséquence: Les opérations proportionnelle à h sont O (log2 n) 55
  56. 56. REPRÉSENTATION PAR TABLEAU  Un tas se représente naturellement par un tableau:  Les sommets sont numérotés par un parcours en largeur, de gauche à droite.  Le sommet « i » est rangé dans la case d’indice i du tableau. 1 2 5 15 8 3 6 5 4 4 6 7 9 7 20 9 16 25 14 12 11 8 1 2 3 4 5 6 7 8 9 10 11 12 13 4 5 6 15 9 7 20 16 25 14 12 11 8 56
  57. 57. TRI PAR TAS REPRÉSENTATION PAR TABLEAU  Indice(racine)=1  Indice(FG)=2*Indice(Père)  Indice(FD)=2*Indice(Père)+1  Indice(Père)= [Indice (Fils)/2] 1 2 3 4 5 6 7 8 9 10 11 12 13 4 5 6 15 9 7 20 16 25 14 12 11 8 57
  58. 58. TRI PAR TASMIN INSERTION  Pour insérer une valeur « v » dans un TASmin 1. Insérer « v » à la fin du dernier niveau de l’arbre (à la fin du tableau). 2. Tant que la valeur du père de « v » est plus grande que « v », échanger la valeur du père de v avec « v ».  Exemple: insertion de 3 4 6 5 15 16 4 25 5 7 9 6 14 15 12 9 7 20 11 20 16 8 25 58 14 12 11 8
  59. 59. 4 4 6 5 15 16 4 25 5 6 7 9 15 14 9 7 12 20 16 20 11 25 8 14 15 11 8 3 4 25 5 6 7 9 16 3 12 6 5 15 14 9 12 7 3 16 3 5 4 14 9 12 11 7 7 6 6 15 12 16 11 25 8 20 3 5 9 15 14 20 4 15 25 8 4 5 16 11 25 3 3 14 8 12 20 11 8 16 20 4 25 5 3 7 9 15 14 9 7 12 6 16 6 11 25 14 8 12 20 11 8 20
  60. 60. TRI PAR TASMIN INSERTION Procédure Insérer_TAS (Tas: tableau, n, x: entier) Début nn+1 in Tas[i ]  x Tant que (i/2 > 0 et Tas[i/2] > x) faire Permuter (Tas, i, i/2) i  i/2 60 Fin
  61. 61. TRI PAR TASMIN   1. EXTRAIRE MINIMUM Le minimum se trouve à la racine. Pour supprimer la racine: Remplacer la racine par le dernier élément « v » (à la fin du tableau). 2. Tant que la valeur « v » est supérieure à celle de l’un de ses fils, échanger la valeur « v » avec celle du plus petit de ses fils.  Exemple : 4 6 5 15 16 4 25 5 7 9 6 14 15 12 9 7 11 20 16 20 61 26 25 14 12 11 8
  62. 62. 4 26 6 5 15 16 4 25 5 6 7 9 15 14 9 7 12 20 11 16 25 20 15 26 14 11 26 26 25 5 7 9 16 12 6 5 6 14 15 9 12 7 20 5 16 6 5 9 6 14 15 26 12 7 20 20 11 16 16 25 14 12 11 25 15 16 14 12 6 26 7 26 25 11 5 9 15 20 11 5 25 26 7 9 6 14 15 9 12 7 20 20 11 16 25 14 12 11 62
  63. 63. 5 5 6 9 15 16 25 5 7 26 9 6 14 15 12 26 7 20 20 11 16 15 16 25 14 12 6 26 11 5 25 26 7 9 6 14 15 9 12 7 20 20 11 16 25 14 12 11 5 6 9 15 16 5 25 9 7 26 6 14 15 12 26 7 20 20 11 16 25 14 26 11 63
  64. 64. TRI PAR TASMIN EXTRAIRE MINIMUM ExtraireMin (Tas: tableau, n : entier ) Début Tas [1]  T[n]; min  1; Sortie vrai TQ (non sortie) faire i min; g  2* i ; d  2 *i + 1 Si g < n et Tas[g] < Tas[min] alors min  g Si d < n et Tas[d] < Tas[min] alors min  d Si min  i alors Permuter (Tas, i, min) Sinon Sortie vrai Fin 64
  65. 65. TRI PAR TASMIN PRINCIPE 1. Transformer le tableau en un TASMIN 20 15 10 35 19 13 5 20 15 15 20 3 12 7 10 10 20 10 35 16 40 25 38 19 15 35 19 15 20 13 10 3 5 19 35 19 10 20 15 5 19 13 35 12 3 35 13 20 15 5 10 20 15 13 65
  66. 66. TRI PAR TASMIN PRINCIPE 1. Transformer le tableau en un TASMIN 20 15 10 35 19 13 5 3 12 7 16 40 25 38 3 3 5 12 35 20 19 5 10 7 15 10 12 13 35 7 19 20 15 16 40 13 25 38 66
  67. 67. TRI PAR TASMIN PRINCIPE 2. Extraire n fois le minimum du tas: 3 5 10 12 35 7 19 20 15 16 40 13 25 5 7 38 10 12 35 3 5 16 19 20 15 38 40 13 25 67
  68. 68. TRI PAR TASMIN PRINCIPE 2. Extraire n fois le minimum du tas: 7 12 10 19 16 15 13 10 35 25 38 20 40 12 13 19 35 3 5 7 10 16 25 20 15 40 38 68
  69. 69. TRI PAR TASMIN PRINCIPE 2. Extraire n fois le minimum du tas: 13 12 16 19 35 16 13 20 15 19 40 20 35 25 15 38 40 25 38 15 16 19 25 20 38 40 35 69 3 5 7 10 12 13 15
  70. 70. TRI PAR TASMIN PRINCIPE 2. Extraire n fois le minimum du tas: 16 19 35 19 20 25 20 38 40 35 38 25 35 40 38 25 35 40 38 20 35 40 38 25 40 38 40 40 3 5 7 10 12 13 15 16 19 20 25 35 38 40 70
  71. 71. TRI PAR TASMIN ALGORITHME ITÉRATIF Tri_TASmin (T: Tableau, n: entier) Début //Construire le TAS Pour i 1 à n faire Insérer_TAS (Tas, i-1, T[i]) // Extraire les minimums Pour i1 à n faire T[i]  TAS[1] Extraire_Minimum (TAS, n) Fin 71
  72. 72. TRI PAR TASMIN COMPLEXITÉ DE L’ALGORITHME ITÉRATIF Tri_TASmin (T: Tableau, n: entier) TTAS (n) tq n la taille du tableau Début //Construire le TAS Pour i 1 à n faire Insérer_TAS (Tas, i-1, T[i]) TInsérer ?? // Extraire les minimums Pour i0 à n-1 faire T[i+1]  TAS[1] Extraire_Minimum (TAS, n-i) Textraire?? Fin 72
  73. 73. TRI PAR TASMIN COMPLEXITÉ DE LA PROCÉDURE INSÉRER_TAS Procédure Insérer_TAS (Tas: tableau, n, x: entier) TInsérer(n) Début nn+1 Pire des cas: le n+1 ème élément du tableau est le minimum  in Tas[i ]  x le nombre d’itération de la boucle égale à log2(n+1) Tant que (i/2 > 0 et Tas[i/2] > x) faire Permuter (Tas, i, i/2) i  i/2 73 Fin TInsérer (n) = c1 log2(n+1) + c2  O(TInsérer ) = O(log2(n+1) )
  74. 74. TRI PAR TASMIN COMPLEXITÉ DE LA PROCÉDURE EXTRAIRE_MINIMUM Extraire_Minimum (Tas: tableau, n : entier ) TExtraire(n) Début Tas [1]  T[n]; min  1; Sortie vrai TQ (non sortie) faire i min; g  2* i ; d  2 *i + 1 Pire des cas: le dernier élément est le maximum  le nombre d’itération Si g < n et Tas[g] < Tas[min] alors min  g correspond à la hauteur de Si d < n et Tas[d] < Tas[min] alors min  d l’arbre donc égale à log2 n Si min  i alors Permuter (Tas, i, min) Sinon Sortie vrai Fin TExtraire (n) = c3 log2(n) + c4  O(TExtraire ) = O(log2(n) ) 74
  75. 75. TRI PAR TASMIN COMPLEXITÉ DE L’ALGORITHME ITÉRATIF Tri_TASmin (T: Tableau, n: entier) TTAS (n) tq n la taille du tableau Début //Construire le TAS Pour i 1 à n faire Insérer_TAS (Tas, i-1, T[i]) TInsérer (i-1) = log2(i) + c2  log2(i) // Extraire les minimums Pour i0 à n-1 faire T[i+1]  TAS[1] Extraire_Minimum (TAS, n-i) Textraire (n-i) = log2(n-i) + c4  log2(n-i) Fin 75 O(TTAS ) = O(nlog2(n) )
  76. 76. ALGORITHME RÉCURSIF i1; phase1 Tri_TASmin (T, TAS: Tableau, n, i, phase: entier) Début Si Phase = 1 alors //Construire le TAS Si (i<=n) alors Insérer_TAS (Tas, i-1, T[i]) Tri_TASmin (T, TAS, i++, n, phase) Sinon Tri_TASmin(T, TAS, 0, n, 2) // On passe à la phase 2 Sinon // Phase 2: Extraire les minimums Si (i<n) alors T[i+1]  TAS[1] Extraire_Minimum (TAS, n-i) Tri_TASmin (T, TAS, i++, n, phase) Fsi Fin 76
  77. 77. COMPLEXITÉ DE L’ALGORITHME RÉCURSIF i1; phase1 Tri_TASmin (T, TAS: Tableau, n, i, phase: entier) TTAS (m) tq m= n-i+1 la taille effective du tableau (m n) Début Si Phase = 1 alors //Construire le TAS Si (i<=n) alors Insérer_TAS (Tas, i-1, T[i]) O(TInsérer ) = O(log2(n-m+1)) Tri_TASmin (T, TAS, i++, n, phase) TTAS (m-1) Sinon Tri_TASmin(T, TAS, 0, n, 2) // On passe à la phase 2 Sinon // Phase 2: Extraire les minimums Si (i<n) alors T[i+1]  TAS[1] Extraire_Minimum (TAS, n-i) O(Textraire) = O(log2(m-1)) Tri_TASmin (T, TAS, i++, n, phase) TTAS (m-1) Fsi Fin O(TTAS ) = O(nlog2(n) ) 77
  78. 78. CONCLUSION Algorithme de Tri Complexité au Pire Tri par Sélection O(n2) Tri par Insertion O(n2) Tri par Propagation O(n2) Tri par ABR O(n2) Tri Rapide O(n2) O(nlog2(n)) Tri par Fusion O(nlog2(n)) Tri par TAS O(nlog2(n)) 78
  79. 79. EXERCICE  Réécrire les algorithmes de tri (vus précédemment) afin de pouvoir trier le tableau en ordre décroissant (plus grand au plus petit). 79
  80. 80. TP: TRI PAR ABRE  Un Arbre Binaire de Recherche Équilibré (ABRE), comme son nom indique, est un arbre :  binaire de recherche : chaque nœud possède au plus deux fils (gauche et droit), et la valeur du père est inférieur ou égale à la valeur de son fils gauche et supérieur strictement à la valeur de son fils droit.  Équilibré : possède un critère d'équilibre spécifique par exemple :  Dans TAS, l'arbre est complet, i.e. si sa hauteur est h, les niveaux inférieurs (0, 1, 2,...., h-1) sont entièrement remplis.  Dans un arbre AVL, les hauteurs du sous arbre gauche et celle du sous arbre droit diffèrent au plus de un.  Dans un arbre rouge-noir, la hauteur maximum est égale à 2 log2 (n + 1) où n est le nombre de nœuds.  ............. 80
  81. 81. TP: TRI PAR ABRE  Le but de ce TP est de proposer un algorithme de tri par un ABRE permettant de classer les éléments du tableau.  Pour ce faire, les étapes suivantes doivent être respectées : 1. Conception de l’algorithme : définir la structure de l’ABRE choisi, décrire le principe du tri, dérouler le principe sur un exemple, écrire l’algorithme (version itérative et récursive) et enfin calculer la complexité de l’algorithme. 2. Implémentation de l’algorithme : Développer une application sous Java permettant, entre autre, de:  Via une interface graphique :  Saisir manuellement le tableau (la taille et les éléments), ou  Importer le tableau à partir d’un benchmark (fichier .txt)  Afficher le tableau trié  Calculer le temps d’exécution. 81
  82. 82. TP: TRI PAR ABRE  Pour ce faire, les étapes suivantes doivent être respectées : 1. Conception de l’algorithme 2. Implémentation de l’algorithme 3. Test : Donner le temps d’exécution dans le cas où n=10, n=100, n=1000 (n présente la taille du tableau).  Le rapport (au maximum sur 10 pages) et l’application (code source + exécutable .Jar sur un CD-ROM) doivent être rendus un mois après la date de remise du TP. 82
  83. 83. SOURCES DE CE COURS  Frédéric Vivien, Algorithmique avancée, École Normale Supérieure de Lyon, 2002., pp. 93. Disponible sur http://perso.ens-lyon.fr/frederic.vivien/Enseignement/Algo2001-2002/Cours.pdf  Slim Msfar, Algorithmique et Complexité, 2012, pp 104. Disponible sur http://p835.phpnet.org/testremorque/upload/catalogue/coursalgorithmi.pdf  Algorithmes récursifs de tri, disponible sur http://foofish.blogspot.com/2007/01/algorithmes-rcursifs-de-tri.html  François Laroussinie Algorithmes de tri, Université Paris Diderot (Paris 7), 2010, pp 110. Disponible sur www.liafa.jussieu.fr/~francoisl/IREM/tri.pdf‎  Parcours d’un arbre binaire, disponible sur math.univ- lyon1.fr/irem/IMG/pdf/parcours_arbre_avec_solutions-2.pdf  Olivier Bournez, Cours 7: Arbres de recherche. Tas. Disponible sur http://www.enseignement.polytechnique.fr/informatique/INF421/Amphi-b/cours7handout2x2.pdf  Renaud Dumont, Algorithmique P2, HeapSort et files de priorité, 2010, pp 83 31, Disponible sur www.montefiore.ulg.ac.be/~dumont/pdf/ac7.pdf‎

×