19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Priority Queues and Heapsort Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering

19. November 2012

ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

1/34

Definition Basis-Implementierungen

Priorit¨atswarteschlangen und Heapsort Was ist eine Priorit¨atswarteschlange? Es ist eine Warteschlange (queue) Es gibt eine Priorit¨atsregel, die zu jedem Zeitpunkt auf ein Element mit h¨ochster Priorit¨at verweist. Wird ein neues Element in die Warteschlange geschrieben, kann das ein neues dringendstes Element bedeuten. Oft ist der gr¨oßte Schl¨ ussel der mit der h¨ ochsten Priorit¨at; die Bedeutung des Schl¨ ussels bezieht sich dann auf die betreffende Anwendung. Definition Eine Priorit¨atswarteschlange ist eine Datenstruktur von Elementen mit Schl¨ usseln, die zwei grundlegende Operationen unterst¨ utzt: ein neues Element einf¨ ugen und das Element mit dem gr¨ oßten Schl¨ ussel l¨oschen. ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

2/34

Definition Basis-Implementierungen

Priorit¨atswarteschlangen (2) Priorit¨atswarteschlangen werden f¨ ur viele Algorithmen genutzt. Sehen wir uns zun¨achst ein Sortier-Algorithmus an. Wir wollen eine Datenstruktur erzeugen und pflegen, die Datens¨atze mit numerischen Schl¨ usseln (priorities) enth¨alt. Die Basisoperationene sind: Eine Priorit¨atswarteschlange aus N gegebenen Elementen erzeugen. Ein neues Element einf¨ ugen. Das Maximum Element l¨oschen. Sonstige Operationen sind: Die Priorit¨at eines willk¨ urlich festgelegten Elements ¨andern. Ein willk¨ urlich festgelegtes Element l¨oschen. Zwei Priorit¨atswarteschlangen zu einer großen verbinden. ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

3/34

1

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Definition Basis-Implementierungen

Basis-ADT Priorit¨atswarteschlange adt MaxPQ { MaxPQ () void insert ( it : Item ) Item getMax () // optional MaxPQ ( maxSize : int ) Item delMax () boolean isEmpty () int size () } Die meiste Operationen von Priorit¨atswarteschlangen sind im diesem ADT Interface. ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

4/34

Definition Basis-Implementierungen

Basis-Implementierungen Stacks und Warteschlangen: es gibt Operationen mit konstanter Zeit Operationen zum Einf¨ ugen UND L¨oschen des Maximums in konstanter Zeit sind schwieriger Sequenz geordnet halten: Maximum in konstanter Zeit l¨ oschen und finden; nicht f¨ ur Einf¨ ugen Sequenz nicht geordnet halten: in konstanter Zeit einf¨ ugen; nicht f¨ ur Maximum l¨oschen und finden Eifrig oder faul (eager/lazy): eine faule Implementierung wartet, bis die Arbeit notwendig wird Trade-off bei doppelt verketteten Listen: L¨ oschen in konstanter Zeit versus mehr Platz f¨ ur die Links

ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

5/34

Definition Basis-Implementierungen

Array Implementierung einer Priorit¨atswarteschlange (Algorithm 2.6) public class MaxPQ < Key extends Comparable < Key > > { private Key [] pq ; private int N = 0; public MaxPQ ( int maxN ) { pq = ( Key []) new Comparable [ maxN + 1]; } public void insert ( Key x ) { pq [++ N ] = x ; swim ( N ); } public Key delMax () { Key max = pq [1]; exch (1 , N - -); pq [ N +1] = null ; sink (1); return max ; } ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

6/34

2

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Definition Basis-Implementierungen

Worst case Kosten von Priorit¨atswarteschlange-Operationen Basis-Methoden: unsortierte Arrays und Listen Fortschrittlichere Methoden: Heap und Warteschlange.

ordered array: ordered list: unordered array: unordered list: heap: best in theory:

ODE/FHTBM

insert N N 1 1 lg(N) 1

remove max 1 1 N N lg(N) lg(N)

Priority Queues and Heapsort

find max 1 1 N N 1 1

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

7/34

Heap Datenstruktur Algorithmen f¨ ur Heaps

Heap-geordneter Baum und Heap Definition (heap ordered) Ein Baum ist als Heap geordnet, wenn der Schl¨ ussel jedes Knotens gr¨oßer oder gleich den Schl¨ usseln seiner Kind-Knoten ist (wenn es Kind-Knoten gibt). Definition (proposition O.) Der gr¨oßten Schl¨ usselwert in einen Heap-geordneter Bin¨arbaum findet man im Root. Der Heap-geordnete Baum sollte vollst¨andig sein: alle Levels bef¨ ullt, ausnahme das untere. Siehe n¨achste Folie. Definition (proposition P.) Die H¨ohe einer vollst¨andigen Bin¨arbaum mit N Knoten ist blg (N)c.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

8/34

Heap Datenstruktur Algorithmen f¨ ur Heaps

Beispiel eines Heap-geordneten Baums. X

T

O

G

A

S

E

R

M

A

N

I

Array Implementeierung (Level-Ordnung, Start ab Array-Index 1) 1 X ODE/FHTBM

2 T

3 O

4 G

5 S

6 M

7 N

8 A

Priority Queues and Heapsort

9 E

10 R

11 A

12 I

19. November 2012

9/34

3

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Heap Datenstruktur Algorithmen f¨ ur Heaps

Heap-geordneter Baum und Heap Wenn der Bin¨arbaum vollst¨andig ist, hat der Knoten an Position i (level-order) als Elternknoten den Knoten an [i/2]. Umgekehrt hat ein Knoten an Position i seine Kindknoten (wenn es welche gibt) an den Positionen 2 ∗ i und 2 ∗ i + 1.

Es ist eine Darstellung als Array m¨oglich, bei der es zwischen einem Knoten und seinem Eltern- und den Kindknoten keine Links geben muss, wie wir sie in einer verketteten Darstellung brauchen. Denken Sie daran, dass es auf allen Pfaden in einem vollst¨andigen Baum von N Knoten ungef¨ahr lg (N) Knoten gibt (N < 1 + 2 + 4 + ... + N/8 + N/4 + N/2) Number of levels = dlg (N)e.

ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

10/34

Heap Datenstruktur Algorithmen f¨ ur Heaps

Heapifying Die Heap-Bedingung erf¨ ullen: Heapifying oder den Heap reparieren. Die Heap-Bedingung ist ein sogenannter Invariant (etwas das sich nicht ¨andern darf), jede Operation auf einen Heap muss diesen Invariant erf¨ ullen. Wird der Schl¨ ussel eines Knotens gr¨oßer als der Schl¨ ussel seines Elternknotens, vertauschen Sie einfach den Knoten und seinen Elternknoten. Falls n¨otig, wiederholen Sie das. Wird der Schl¨ ussel eines Knotens kleiner als der Schl¨ ussel eines oder beider Kindknoten, vertauschen Sie einfach den Knoten und den Kindknoten mit dem gr¨ oßten Schl¨ ussel. Falls n¨otig, wiederholen Sie das. Swim and sink Methoden (siehe n¨achste Folie) bieten die Hilfsmittel zum Reparieren des Heaps, nachdem ein Element eingef¨ ugt oder seine Priorit¨at ge¨andert wurde. ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

11/34

Heap Datenstruktur Algorithmen f¨ ur Heaps

Bottum-up and bottum-down heapify help methods private void swim ( int k ) { while ( k > 1 && less ( k /2 , k )) { exch (k , k /2); k = k /2; } } private void sink ( int k , int N ) { while (2* k implements Iterable < Key > { private Key [] pq ; private int N ; private Comparator < Key > comparator ; public Heap ( Key [] keys ) { N = keys . length ; pq = ( Key []) new Object [ keys . length + 1]; for ( int i = 0; i < N ; i ++) pq [ i +1] = keys [ i ]; heapify (); } private void heapify () { for ( int k = N /2; k >= 1; k - -) sink ( k ); } ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

17/34

Heap Datenstruktur Algorithmen f¨ ur Heaps

Komplexit¨at der Algorithmen f¨ur Heaps Definition (Proposition Q.) 1

Die Operation insert f¨ ur den abstrakten Datentyp Priorit¨atswarteschlange lasst sich mit Heap-geordneten B¨aumen so implementieren, dass insert nicht mehr als 1 + lg (N) Vergleiche braucht.

2

Die Operation remove max f¨ ur den abstrakten Datentyp Priorit¨atswarteschlange l¨asst sich so mit Heap-geordneten B¨aumen implementieren dass nicht mehr als 2lg (N) Vergleiche n¨otig sind.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

18/34

6

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Sortieren mit Hilfe einer Priorit¨atswarteschlange Ein Array von Elementen kann man sortieren mit Hilfe einer Priorit¨atswarteschlange und die remove maximum Methode. Wenn die Priorit¨atswarteschlange ungeordnet ist, ¨ahnelt das Programm einem Selection Sort. Wenn die Priorit¨atswarteschlange geordnet ist, ¨ahnelt das Programm einem Insertion Sort. Die Implementierung im Code auf der n¨achste Folie ist nicht optimal: Es entstehen u ussige Kopien von Elementen. ¨berfl¨ N Einf¨ ugungen in Folge zum Erstellen des Heaps ist keine effiziente Methode.

ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

19/34

Sortieren mit einem Heap Heapsort Beispiel

Erstes Sortier-Programm mit Priorit¨atswarteschlange class HeapSort1 { void sort ( Item [] a , int l , int r ) { pqSort (a , l , r ); } void pqSort ( Item [] a , int l , int r ) { int k ; MaxPQ pq = new MaxPQ (r - l +1); for ( k = 1; k = l ; k - -) a [ k ] = pq . getMax (); } } ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

20/34

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Das Programm HeapSort1 funktioniert wie ein Selection Sort. Effizienter gehen wir durch den Heap, indem wir kleine Subheaps von unten nach oben erstellen. Jeder Knoten wird als die Wurzel eines Subheaps betrachtet, und sink funktioniert auch f¨ ur solche Heaps gut. Ein Knoten mit zwei Subheaps als seinen Kindern wird ein Heap, indem man sink f¨ ur diesen Knoten aufruft. Indem wir r¨ uckw¨arts f¨ ur jeden Knoten sink aufrufen, stellen wir induktiv die Heap-Bedingung her.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

21/34

7

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Algorithme 2.7 public void sort ( Comparable [] a ) { for ( int k = N /2; k >= 1; k - -) { sink (a , k , N ); } while ( N > 1) { exch (a , 1 , N - -); sink (a , 1 , N ); } }

Definition (Proposition R.) Sink-basierten Heap-Konstruktion ben¨otigt weniger als 2N Vergleiche und weniger als N Vertauschungen zum erstellen einer Heap aus N Elementen. ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

22/34

Sortieren mit einem Heap Heapsort Beispiel

Array-Indexen in heap Baum 1

2

3

4

8

N/2

5

9

10

11

N-1

7

N

N ist ungerade: letzte Knoten mit Kindknoten hat 2 KindKnoten. Knoten bei Index N/2 ist der letzte Knoten mit Kindknoten; auch wenn N gerade ist.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

23/34

Sortieren mit einem Heap Heapsort Beispiel

Array-Indexen in heap Baum (2) 1

2

3

4

8

N/2

5

9

10

N-1

7

N

N ist gerade: letzte Knoten mit Kindknoten hat 1 KindKnoten. Knoten bei Index N/2 ist der letzte Knoten mit Kindknoten; auch wenn N ungerade ist.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

24/34

8

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Sink-Methode mehr detailliert private void sink ( int k , int N ) { while (2* k N. 2 Start bei linker Knoten mit j. Als j == N dann j gerade: kein rechter Knoten. Genaue Behandlung von der letzte Knoten!

ODE/FHTBM

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

19. November 2012

25/34

Sortieren mit einem Heap Heapsort Beispiel

Sink-Methode mehr detailliert (2) private void sink ( int k , int N ) { while (2* k = 1; k - -) { sink (a , k , N ); } Knoten mit Index k = N/2 ist letzte Knoten mit Kinder (der letzte Elterknoten - parent). Von hier geht’s Levelorder aufwerts im Baum und heapify mittels sink.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

27/34

9

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Zweiten Teil of heapsort code while ( N > 1) { exch (a , 1 , N - -); sink (a , 1 , N ); } In-place sortierung: vertausche max Item (Index 1) mit letzte Knoten von unsortierten Teil des Baums (Index N). Funkioniert wie selection sort Allererst N mit 1 reduzieren und dann heapify durch Anruf von sink f¨ ur neue Wurzel.

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

28/34

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Beispiel (1) Zuerst bauen wir einen Heap von unten auf, in-place. for( int k=N/2; k>=1; k--) sink(k, N); 1 A A A A A A A X

2 S S S S S S X T

3 O O O O O P P P

4 R R R R R R R R

ODE/FHTBM

5 T T T X X X T S

6 I I P P P O O O

7 N N N N N N N N

8 G G G G G G G G

9 E E E E E E E E

10 X X X T T T S A

Priority Queues and Heapsort

11 A A A A A A A A

12 M M M M M M M M

13 P P I I I I I I

14 L L L L L L L L

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

15 E E E E E E E E

29/34

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Beispiel (2) 1 A A A A A A A A A X X X

ODE/FHTBM

2 S S S S S S S X X A T T

3 O O O O O P P P P P P P

4 R R R R R R R R R R R R

5 T T T X X X X S T T A S

6 I I P P P O O O O O O O

7 N N N N N N N N N N N N

Priority Queues and Heapsort

8 G G G G G G G G G G G G

9 E E E E E E E E E E E E

10 X X X T T T T T S S S A

11 A A A A A A A A A A A A

12 M M M M M M M M M M M M

13 P P I I I I I I I I I I

19. November 2012

14 L L L L L L L L L L L L

15 E E E E E E E E E E E E

30/34

10

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Heapified a[-, X, T, P, R, S, O, N, G, E, A, A, M, I, L, E ] X

T

P

R

G

S

E

A

O

A

N

M

I

L

E

N ist ungerade: letzte Knoten mit Kindknoten hat 2 KindKnoten. Knoten bei Index N/2 ist der letzte Knoten mit Kindknoten; auch wenn N gerade ist. ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

31/34

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Beispiel (3) Dann l¨osschen wir jedesmal das gr¨oßte element vor der Heap. Die fette Buchstaben stimmen u ¨berein mit dem schon sortierten Teil des Arrays. while(N>1) {exch(1,N); sink(1, --N);} 1 T S R P O N M

2 S R L L L L L

3 P P P O N M E

4 R L I I I I I

ODE/FHTBM

5 E E E E E E E

6 O O O M M A A

7 N N N N A A A

8 G G G G G G G

9 E E E E E E N

10 A A A A A O O

Priority Queues and Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

11 A A A A P P P

12 M M M R R R R

13 I I S S S S S

14 L T T T T T T

15 X X X X X X X

19. November 2012

32/34

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Beispiel (4) while(N>1) {exch(1,N); sink(1, --N);} 1 X

2 T

3 P

4 R

5 S

6 O

7 N

8 G

9 E

10 A

11 A

12 M

13 I

14 L

15 E

E T T

T E S

P P P

R R R

S S E

O O O

N N N

G G G

E E E

A A A

A A A

M M M

I I I

L L L

X X X

T

S

P

R

E

O

N

G

E

A

A

M

I

L

X

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

33/34

11

19. November 2012

Heapsort

Priorit¨ atswarteschlangen und Heapsort Heaps Heapsort

Sortieren mit einem Heap Heapsort Beispiel

Heapsort Eigenschaften Definition (Proposition S.) Heapsort bracht weniger als 2N · lg (N) Vergleichungen (und halb soviel Vertauschungen zum sortiern von N Elemente. Eigenschaft S und die In-place Eigenschaft sind aus praktischen Gr¨ unden wichtig: Heapsort garantiert das In-place-Sortieren von N Elementen in proportionaler Zeit zu N · lg (N). Es gibt keine worst case Eingabe, die Heapsort signifikant verlangsamt (anders als Quicksort). Heapsort braucht nicht mehr Speicherplatz (anders als Mergesort)

ODE/FHTBM

Priority Queues and Heapsort

19. November 2012

34/34

12