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)
Top Related