TAS (Heap) Tas Propriétés des Tas Suppression, insertion, construction Implémentation de Tas Implémentation de Files de priorité Une application: HeapSort 1 Min-Heap Un tas (heap) est un arbre binaire T qui emmagasine une collection de clés (ou paires clé-élément) comme nœuds internes et qui satisfait les deux propriétés suivantes: Propriété d ordre: clé(parent) clé(enfant) pour le tas-min clé(parent) clé(enfant) pour le tas-max - Propriété structurelle: arbre binaire complet 1
Min-Heap RAPPEL: Arbre binaire complet dans un arbre binaire complet tous les niveaux sont pleins, excepté le dernier niveau 6 1 9 0 16 1 1 11 8 3 Max-Heap clé(parent) clé(enfant) 0 3 6 1 19 1 0 1 13 1 1 11 8
Nous emmagasinons les clés comme nœuds internes seulement 1 9 16 Après ajouter les feuilles, l arbre résultant est plein Hauteur d un tas Un tas T qui emmagasine n clés a une hauteur h = O(log n) Preuve: Soit h la hauteur d'un tas stockant les n clés Puisque il y a i clés à la profondeur i = 0,, h - et au moins une clé à profondeur h - 1, nous avons n 1 + + + + h- + 1 Ainsi, n h-1, i.e., h log n + 1 profondeur 0 1 h- clés 1 h- h-1 Au moins 1 h 6 3
Remarque. Nous pourrions utiliser un tas pour implementer une file de priorité Nous emmagasinons un item (clé, élément) à chaque nœud interne removemin(): -> Enlever la racine (, Sue) -> Réarranger le tas (, Pat) (6, Mark) (9, Jeff) (, Anna) Suppression dans un Tas On supprime la clé racine La suppression de la clé racine laisse un trou Nous devons réparer le tas Remplacer le trou par la toute dernière clé du tas (l élément du dernier niveau le plus à droite) Ensuite, appliquez le procédure Downheap de manière que le tas garde ses propriétés 8
Procédure Downheap Downheap compare le parent avec son enfant le plus petit. Si cet enfant est plus petit que le parent, alors on les échange 9 Suite de Downheap 10
Suite de Downheap () 11 Fin de Downheap Downheap se termine quand la clé est plus petite que les clés de ses deux enfants ou quand on atteint le dernier niveau (#échanges total) (h - 1), qui est O(log n) 1 6
Insertion dans un tas 13 Insertion dans un tas Ajoutez la clé à la prochaine position disponible dans le tas: Si le dernier niveau est plein, ajouter l élément comme enfant gauche de l élément le plus à gauche du dernier niveau Sinon ajouter l élément après l élément le plus à droite du dernier niveau Réarranger le tas pour garder ses propriétés Procédure Upheap 1
Procédure Upheap Échangez (swap) les clés parent-enfant non-ordonnées 1 Suite de Upheap 16 8
Fin de Upheap Upheap se termine quand la nouvelle clé est plus grande que la clé de son parent ou quand le haut de tas est atteint (#échanges total) (h - 1), qui est O(log n) 1 Construction du Heap Nous pourrions insérer les articles un à la fois avec une séquence d'insertions dans un heap: n Σ log k = O(n log n) k=1 Mais nous pouvons faire mieux. O(n) avec construction ascendant du heap (bottom-up construction) 18 9
Construction ascendante du heap Nous pouvons construire un tas emmagasinant n clés données utilisant une construction ascendante du tas 19 Construction ascendante du heap Idée : Récursivement réarranger chaque sous-arbre dans le tas commençant avec les feuilles 6th th begin here th 3 rd nd 1 st begin here HEAP HEAP HEAP 0 10
Exemple 1 au tableau clés déjà dans l'arbre 1 Exemple (Max-Heap) --- les clés déjà dans l'arbre--- 3 10 8 6 1 9 6 3 6 3 Je ne dessine plus les feuilles ici maintenant 10 6 10 8 9 6 10 8 9 6 8 1 9 3 1 3 1 3 9 10 11
Exemple 10 9 6 8 1 3 9 Ceci n'est pas un tas! 9 9 1 1!! 9 10 6 1 3 8 3!! 9 10 6 8 1 3 Exemple Finalement: 10 10 8 10 8 8 10 9 8 6 1 3 1
clés données une à la fois Exemple Tas-Min (Min-Heap) {1,9,8,,,11,,16,1,,1,6,,3,0} 16 1 1 6 3 0 11 16 1 1 6 3 0 clés données une à la fois Exemple Tas-Min (Min-Heap) {1,9,8,,,11,,16,1,,1,6,,3,0} 1 6 0 16 1 11 3 9 8 1 6 0 16 1 11 3 6 13
clés données une à la fois Exemple Tas-Min (Min-Heap) {1,9,8,,,11,,16,1,,1,6,,3,0} 6 1 0 16 9 1 11 8 3 1 6 1 0 16 9 1 11 8 3 clés données une à la fois Exemple Tas-Min (Min-Heap) {1,9,8,,,11,,16,1,,1,6,,3,0} 6 1 9 0 16 1 1 11 8 3 8 1
Analyse de la construction du Heap (Nous ne considérons pas les noeuds bidones) Au max 3 échanges échanges h = 3 niveau 0 niveau 1 1 échange 3 10 8 niveau 0 échanges 1 9 6 niveau 3 Niveau i -------- h - i échanges max h est le niveau max 9 Analyse de la construction du Heap Numero d échanges level 0 1 Au niveau i le nombre d échanges est h h i pour chaque noeud Au niveau i il y a i nodes h Total: Σ(h i) i i=1 30 1
Soit j = h-i, alors i = h-j et h Σ(h i) i = Σj h-j = h Σ j -j i=1 h j=1 Considère Σ j -j : Σ j -j = 1/ + 1/ + 3 1/8 + 1/16 + = 1/ + 1/ + 1/8 + 1/16 + <= 1 + 1/ + 1/8 + 1/16 + <= 1/ + + 1/8 + 1/16 + <= 1/ h j=1 Σ j -j <= Alors h Σ j -j <=. h = n O(n) 31 h h Σj/ j j=1 h+1 Où h est O(log n) Donc, le nombre d échanges est O(n) 3 16
Implémentation d un heap avec un tableau Un tas peut être représenté par un vecteur (tableau) où le nœud au rang i a: 1 - l enfant de gauche au rang i et 3 - l enfant de droite au rang i + 1 6 8 Les feuilles n ont pas à être emmagasinées 1 3 6 8 33 Exemple 1 H D 3 I 6 B E L O 8 9 10 11 1 13 A C F G H N i i i+1 1 3 6 8 9 10 11 1 13 H D I B E L O A C F G H N 3 1
Rappel.. Enfant gauche de T[i] T[i] si i n Enfant droit de T[i] Parent de T[i] Le racine feuille? T[i] T[i+1] si i + 1 n T[i div ] si i > 1 T[1] si T 0 VRAI si i > n 1 n = 11 3 I 6 8 9 10 11 3 Réalisation d une File de Priorité avec un heap 36 18
(upheap) O(log n) O(1) O(log n) (enlève la racine+ downheap) 3 Application: Heap-Sort PriorityQueueSort où la PQ est implémentée avec un HEAP Algorithm PriorityQueueSort(S, P): Input: A sequence S storing n elements, on which a total order relation is defined, and a Priority Queue P that compares keys with the same relation Output: The Sequence S sorted by the total order relation while S.isEmpty() do e S.removeFirst() Build Heap P.insertItem(e, e) while P.isEmpty() do e P.removeMin() Remove from heap S.insertLast(e) 38 19
Application: tri Heap-Sort Construire le heap initial O(n) n fois Enlever la racine O(1) Réarranger O(log n) Enlever la racine O(1) réarranger L O(log (n-1)) M L 39 Quand il y a i nœuds dans la file à priorité: log i Tot Σ n log i i=1 = O(n log n) O(n log n) L'algorithme de heap-sort trie une séquence S de n éléments dans un temps O(n log n) Le temps d exécution O(n log n) d un tri heap-sort est bien meilleur que le temps d exécution O(n ) d un tri par sélection, ou par insertion. 0 0
Tri par tas sur place (in place heap-sort) Au lieu d utiliser une deuxième structure de données P (espace occupé en plus) pour trier une séquence S, on peut exécuter le tri par tas «sur place» (In-place heap sort) en divisant S en deux parties complémentaires: une représentant un tas-max et une autre représentant la séquence. L algorithme comporte deux phases: Phase 1: On commence avec une partie tas-max vide et on l étend à chaque étape i (i=1..n) en lui ajoutant l élément d indice i jusqu à couvrir tout le tableau S. La partie tas doit toujours garder ses propriétés Phase : On commence avec une partie séquence vide et on l étend à chaque étape en supprimant l élément max du tas et l ajoutant à la partie séquence jusqu à couvrir tout le tableau. A chaque étape i (i=1..n) on supprime le max de la partie tas et on l ajoute à l indice n-i. La partie tas doit toujours garder ses propriétés 1 Tri par tas sur place (in place heap-sort) Exemples au tableau. 1
Exemple. Partie tas max Partie séquence 3 3 3 3 3 3 3 3 3 3 3 Exemple. 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 Partie tas max Partie séquence 3 3 3
Avec Min-heap: Avec Max-Heap: removemin() est O(log n) removemax() est? removemin() est? removemax() est O(log n) Question: Si je veux implémenter une file de priorité à double sens?? removemin() ET removemax() 3