-
1
1
TAS (Heap)
• Tas• Propriétés des Tas• Suppression, insertion, construction•
Implémentation de Tas• Implémentation de Files de priorité• Une
application: HeapSort
2
Min-Heap
Un tas (heap) est un arbre binaire T qui emmagasineune
collection de clés (ou paires clé-élément)comme nœuds internes et
qui satisfait les deuxproprié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
-
2
3
Min-Heap
4
6
207
811
5
9
1214
15
2516
RAPPEL: Arbre binaire complet dans un arbre binaire complet tous
les niveaux sontpleins, excepté le dernier niveau
4
Max-Heap
clé(parent) ≥ clé(enfant)
40
26
2017
811
35
19
1214
15
131
-
3
5
Nous emmagasinons les clés comme nœuds internesseulement
5
915
16
Après ajouter les feuilles , l’arbre résultant est plein
6
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 2i clés à la profondeur i = 0, … , h - 2 et au moins une
clé à profondeur h - 1, nous avons n ≥ 1 + 2 + 4 + … + 2h-2 + 1–
Ainsi, n ≥ 2h-1 , i.e., h ≤ log n + 1
1
2
2h-2
Au moins 1
clés0
1
h-2
h-1
profondeur
h
-
4
7
• Nous pourrions utiliser un tas pour implementerune file de
priorité
• Nous emmagasinons un item (clé, élément) àchaque nœud
interne
(2, Sue)
(6, Mark)(5, Pat)
(9, Jeff) (7, Anna)
removeMin(): -> Enlever la racine
-> Réarranger le tas
Remarque….
8
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 dernierniveau le plus à
droite)
• Ensuite, appliquez leprocédure ‘Downheap’ demanière que le tas
gardeses propriétés
-
5
9
Procédure DownheapDownheap compare le parent avec son enfant le
plus petit. Si cet enfantest plus petit que le parent, alors on les
échange
10
Suite de Downheap
-
6
11
Suite de Downheap (2)
12
Fin de Downheap
• Downheap se termine quand la clé est plus petite que les clés
de sesdeux enfants ou quand on atteint le dernier niveau
• (#échanges total) ≤ (h - 1), qui est O(log n)
-
7
13
Insertion dans un tas
14
Insertion dans un tasAjoutez 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
-
8
15
Procédure Upheap
• Échangez (swap) les clés parent-enfant non-ordonnées
16
Suite de Upheap
-
9
17
Fin de Upheap
• Upheap se termine quand la nouvelle clé est plus grande que la
clé deson parent ou quand le haut de tas est atteint
• (#échanges total) ≤ (h - 1), qui est O(log n)
18
Construction du Heap
Nous pourrions insérer les articles un à la fois avec une
séquence d'Insertions dans un heap:
Σ log k = O(n log n)k=1
n
Mais nous pouvons faire mieux ….
O(n) avec construction ascendant du heap(bottom-up
construction)
-
10
19
• Nous pouvons construire untas emmagasinant n clésdonnées
utilisant uneconstruction ascendante dutas
Construction ascendante du heap
20
Idée : Récursivement réarranger chaquesous-arbre dans le tas
commençant avecles feuilles
begin here
HEAP
HEAPHEAP
1st2nd3rd4th
5th6th
begin here
Construction ascendante du heap
-
11
21
Exemple 1 au tableauclés déjà dans l'arbre
22
Exemple (Max-Heap)
3 ↔ 6
2
4 5
10 87 3
1 9 6
6
3
2
4 5
10 87 6
1 9 3
2
4 5
10 89 6
1 7 3
7 ↔ 9 5 ↔ 10
Je ne dessine plusles feuilles ici maintenant
2
4 10
5 89 6
1 7 3
--- les clés déjà dans l'arbre---
-
12
23
Ceci n'est pas un tas!
4 ↔ 9
Exemple
9
4
1 7
9
7
1 4
4 ↔ 7
2
9 10
5 87 6
1 4 3
! !
2
4 10
5 89 6
1 7 3
24
Exemple
10
9 8
5 27 6
1 4 3
2
9 10
5 87 6
1 4 3
! !
Finalement: 2 ↔ 10
10
2
5 8
10
2
5 8
2 ↔ 8
-
13
25
1516 124 76 2023
25
1516
5
124
11
76
27
2023
Exemple 2 Tas-Min
(Min-Heap){14,9,8,25,5,11,27,16,15,4,12,6,7,23,20}
clés données une à la fois
26
15
2516
4
125
6
711
20
2723
9
15
2516
4
125
8
6
711
20
2723
Exemple 2 Tas-Min
(Min-Heap){14,9,8,25,5,11,27,16,15,4,12,6,7,23,20}
clés données une à la fois
-
14
27
4
15
2516
5
129
6
7
811
20
2723
4
15
2516
5
129
146
7
811
20
2723
Exemple 2 Tas-Min
(Min-Heap){14,9,8,25,5,11,27,16,15,4,12,6,7,23,20}
clés données une à la fois
28
5
15
2516
9
1214
46
7
811
20
2723
Exemple 2 Tas-Min
(Min-Heap){14,9,8,25,5,11,27,16,15,4,12,6,7,23,20}
clés données une à la fois
-
15
29
Analyse de la construction du Heap
(Nous ne considérons pas les noeuds bidones)
2
4 5
10 87 3
1 9 6
niveau 0niveau 1
niveau 2
niveau 3
3 échanges
Niveau i -------- h - i échanges max
h = 3
h est le niveau max
Au max
2 échanges
1 échange
0 échanges
30
level 01
hAu niveau i le nombre d’échanges est
≤ h – i pour chaque noeud
Au niveau i il y a ≤ 2i nodes
Total: ≤ Σ(h – i)·2ii=1
h
Numero d’échanges
Analyse de la construction du Heap
-
16
31
Soit j = h-i, alors i = h-j et
Σ(h – i)·2i = Σj 2h-j = 2h Σ j 2-j Considère Σ j 2-j :Σ j 2-j =
1/2 + 2 1/4 + 3 1/8 + 4 1/16 + … = 1/2 + 1/4 + 1/8 + 1/16 + …
-
17
33
Un tas peut être représenté par un vecteur (tableau) où le nœud
aurang i a:
- l’enfant de gauche au rang 2i et - l’enfant de droite au rang
2i + 1
Les feuilles n’ont pas à être emmagasinées
1 2 3 4 5 7
12 3
4 5 6 7
8
6 8
Implémentation d’un heap avecun tableau
34
Exemple
C
9
F
10
G
11
H
12
N
13
AOLEBIDH
87654321
1
32
4 5 6 7
8 9 10 11 12 13
H
D I
B E L O
A C F G H N
i
2i 2i+1
-
18
35
n = 111
2
4 5 6 7
8 9 10 11
I
3
Rappel…..
feuille? T[i]Le racine
Parent de T[i]
Enfant droit de T[i]
Enfant gauche de T[i] T[2i] si 2i ≤ n
T[2i+1] si 2i + 1 ≤ n
T[i div 2] si i > 1
T[1] si T ≠ 0
VRAI si 2i > n
36
Réalisation d’une File de Prioritéavec un heap
-
19
37
O(log n)
O(log n)O(1)
(enlève la racine+ downheap)
(upheap)
38
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() doe ← S.removeFirst()P.insertItem(e, e)
while ¬ P.isEmpty() doe ← P.removeMin()S.insertLast(e)
Application: Heap-Sort
PriorityQueueSort où la PQ est implémentée avec un HEAP
Build Heap
Remove from heap
-
20
39
Application: triHeap-Sort
Construire le heap initial O(n)
Enlever la racine O(1)
Réarranger O(log n)
Enlever la racine O(1)
réarranger O(log (n-1))
L M
L
n
fois
40
Quand il y a i nœuds dans la file à priorité: log i
O(n log n) L'algorithme de heap-sorttrie une séquence S de
néléments dans un temps O(nlog n)
Le temps d’exécution O(n log n) d’un tri heap-sort estbien
meilleur que le temps d’exécution O(n2) d’un tripar sélection, ou
par insertion.
i=1
n
Σ log i
= O(n log n)
Tot
-
21
41
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 «surplace» (In-place heap sort) en divisant S en deux
partiescomplémentaires: une représentant un tas-max et une
autrerepré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’à couvrirtout le tableau S. La partie tas doit toujours
garder ses propriétés
Phase 2: 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 à lapartie 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 partietas doit toujours garder ses
propriétés
42
Exemples au tableau.
Tri par tas sur place (in place heap-sort)
-
22
434343
4 7 2 5 3
4 7 2 5 3
4 7 2 5 3
Partie ‘tas max’Partie séquence
7 4 2 5 3
7 4 2 5 3
7 4 2 5 3
7 5 2 4 3
7 5 2 4 3
4
4
7
7
4
2
7
4 2
7
4
5
2
7
5
42
7
5
4 3
Exemple.
444444
Partie ‘tas max’Partie séquence
7 5 2 4 32
7
5
4 33 5 2 4 7 2
3
5
45 3 2 4 7
2
5
3
4
5 4 2 3 72
5
4
33 4 2 5 7
2
3
4
4 3 2 5 7
2
4
32 3 4 5 7
2
3
3 2 4 5 7 3
22 3 4 5 7
2
2 3 4 5 7
Exemple.
-
23
45
Question: Si je veux implémenter une filede priorité à double
sens ??
removeMin() ET removeMax()
Avec Min-heap:
removeMin() est O(log n)
removeMax() est ?
Avec Max-Heap:
removeMin() est ?
removeMax() est O(log n)