ueb12 - oth

Algorithmen und Datenstrukturen
Übung 12: Binary Heap
Die Klasse BinaryHeap in Java1
Heap-Ordnung
Falls das kleinste Element am schnellsten gefunden werden soll, steht sinnvollerweise das kleinste
Element an der Spitze des Heap. In einem Heap sind dann immer die Daten der Vorgängerknoten
kleiner als die der Nachfolgeknoten.
Grundlegende Heap-Operationen
Einfügen
Eine Lücke wird geschaffen. Wenn das einzufügende Element ohne Verletzung der Heap-Ordnung in
die Lücke in die Lücke passt, dann ist alles bereits erledigt. Anderenfalls ist das Element, das den
Vorgänger zur Lücke markiert, mit dem Element, das in die Lücke aufgenommen werden soll, zu
tauschen, z.B. Aufnahme des Schlüssels mit dem Wert 14 in den Heap.
13
13
21
16
24
65
31
26
32
19
21
68
24
14
65
16
14
26
32
19
68
31
13
14
16
24
65
21
26
32
19
68
31
Die Strategie, die bei dem vorliegenden Einfügen verfolgt wird, ist ein aufwärts gerichtetes
Durchdringen bis ein geeigneter Punkt gefunden wird.
public void insert( Comparable x ) throws Overflow
{
if (istVoll( ) ) throw new Overflow( );
// Durchdringen nach oben
int luecke = ++aktGroesse;
for ( ; luecke > 1 && x.compareTo(feld[luecke / 2 ] ) < 0; luecke /= 2 )
1
pr13228
1
Algorithmen und Datenstrukturen
feld[ luecke ] = feld[ luecke / 2 ];
feld[ luecke ] = x;
}
Der zeitliche Aufwand liegt bei O(log N), falls das einzufügende Element das Minimum ist und bis zur
Wurzel durchdringen muß.
Löschen des kleinsten Werts
Das Löschen des kleinsten Element an der Spitze bedingt ein ähnliches Vorgehen wie beim Einfügen.
Falls der kleinste Schlüsselwert entfernt wird, entsteht eine Lücke, die von den nachfolgenden
Schlüsseln geschlossen werden muß, z.B.:
13
31
14
16
24
65
21
26
32
14
19
68
24
31
65
16
21
26
32
14
31
16
65
21
26
68
13
14
24
19
19
21
68
24
32
65
16
31
26
19
68
32
14
21
16
24
65
31
26
19
68
32
Die Strategie ist ein abwärts gerichtetes Durchdringen. Im schlimmsten Fall liegt der Aufwand bei
O(log N).
public Comparable loescheMin( )
2
Algorithmen und Datenstrukturen
{
if ( isEmpty( ) ) return null;
Comparable minItem = findMin( );
feld[ 1 ] = feld[ aktGroesse-- ];
durchdringeRunter( 1 );
return minItem;
}
private
{
/* 1*/
/* 2*/
/* 3*/
/*
/*
/*
/*
/*
/*
4*/
5*/
6*/
7*/
8*/
9*/
/*10*/
/*11*/
void durchdringeRunter( int luecke )
int kind;
Comparable tmp = feld[ luecke ];
for( ; luecke * 2 <= aktGroesse; luecke = kind )
{
kind = luecke * 2;
if ( kind != aktGroesse &&
feld[ kind + 1 ].compareTo( feld[ kind ] ) < 0 )
kind++;
if( feld[ kind ].compareTo( tmp ) < 0 )
feld[ luecke ] = feld[ kind ];
else
break;
}
feld[ luecke ] = tmp;
}
}
Andere Heap-Operationen
macheHeap(): N Elemente werden in einen leeren Heap platziert. Das kann über N
aufeinanderfolgende Einfügevorgänge geschehen. Da jedes Einfügen im Schnitt zwischen O(1) und
O(log N) Aufwendungen benötigt, liegt die totale Laufzeit des Algorithmus bei O(N), im schlechtesten
Fall bei O(NlogN).
Generell sind N Elemente in dem Baum gemäß der einem Heap zugeordneten Struktur-Eigenschaft
anzuordnen. Bewerkstelligen tut dies durchdringeRunter(i). Die Methode durchdringt vom
Knoten i aus das Feld und erzeugt einen im Sinne eines Heap geordneten Baum.
private void macheHeap( )
{
for (int i = aktGroesse / 2; i > 0; i-- )
{
durchdringeRunter( i );
}
}
Bsp.: Im folgenden Beispiel ist der Baum nicht im Sinne eines Heap geordnet. Die aktuelle Belegung
des Felds mit Elementen liegt bei 15. Aufgerufen wird im ersten Schritt zur Herstellung der HeapEigenschaft durchdringeRunter(7). Es ergibt sich bis zum Erreichen eines vollständig
eingerichteten Heap:
3
Algorithmen und Datenstrukturen
150
80
30
100
40
10
20
90
70
60
50
110
120
140
130
Abb.: Ausgangsituation
150
80
30
100
40
10
20
90
70
60
50
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(7)
150
80
30
100
40
10
20
90
50
60
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(6)
4
Algorithmen und Datenstrukturen
150
80
30
100
40
10
20
90
50
60
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(5)
150
80
20
100
40
10
30
90
50
60
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(4)
150
80
20
100
40
10
30
90
50
60
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(3)
5
Algorithmen und Datenstrukturen
150
10
20
100
40
60
30
90
50
80
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(2)
10
20
30
100
40
60
150
90
50
80
70
110
120
140
130
Abb.: Nach Aufruf von durchdringeRunter(1)
Zur Berechnung der Laufzeit von macheHeap() muß die Anzahl der gestrichelten Linien festgestellt
werden. Das kann durch Bestimmung der Summe aller Höhen der Knoten im Heap geschehen. Das
wäre die maximale Größe von gestrichelten Linien.
Ein perfekt ausgeglichener Binärbaum der Höhe h umfasst 2 h+1-1 Knoten, die Summe der Höhen der
Knoten liegt bei 2h-1-(h+1). Aus dieser Summe folgt für das Leistungsverhalten O(N), wobei N die
Anzahl der Knoten ist.
6
Algorithmen und Datenstrukturen
Heap-Algorithmen der STL in C++
Die folgenden Heap-Eigenschaften bilden die Voraussetzubg für die Anwendung der HeapAlgoithmen:
- Die n Elemente eines Heap liegen in einem Array auf den Positionen 0 bis n – 1.
- Die Art der Anordnung der Elemente im Array entspricht einem vollständigen binären Baum, bei dem
alle Ebenen besetzt sind. Die einzige mögliche Ausnahme bildet die unterste Ebene, in der alle
Elemente auf der linken Seite erscheinen.
99
[0]
33
56
[1]
[2]
21
[3]
11
[7]
h[0]
99
30
20
48
[4]
[5]
[6]
9
25
1
10
17
40
[8]
[9]
[10]
[11]
[12]
[13]
[1]
33
[2]
56
[3]
21
[4]
30
[5]
20
[6]
48
[7]
11
[8]
9
[9]
25
[10]
1
[11]
10
[12]
17
[13]
40
Abb.: Array-Repräsentation eines Heap
Das Element h[0] ist die Wurzel, jedes Element h[j] , j > 0 hat einen Elternknoten h[(j1)/2]
- Jedem Element h[j] ist eine Priorität zugeordnet, die größer oder gleich der Priorität der Kindknoten
h[2j+1] und h[j+2] ist2.
- Ein Array h mit n Elementen ist genau dann ein Heap, wenn h[(j-1)/2] >= h[j] für 1<=j<=n gilt. Daraus
folgt automatisch, dass h[0] das größte Element ist. Eine Priorityqueue entnimmt einfach das oberste
Element eines Heap. Anschließend wird er rekonstruiert, d.h. das nächstgrößte Element rückt an die
Spitze.
Die C++-Standardbibliothek bietet 4 Heap-Algorithmen an, die auf alle Container, auf die mit RandomAccess-Iteratoren zugegriffen werden kann, anwendbar sind:
pop_heap() entfernt das Element mit der höchsten Priorität
template <class RandomAccessIterator>
void pop_heap(RandomAccessIterator first,RandomAccessIterator last);
template <class RandomAccessIterator>
void pop_heap(RandomAccessIterator first,RandomAccessIterator last,
Compare comp));
2
Große Zahlen bedeuten hohe Prioritäten
7
Algorithmen und Datenstrukturen
Das Entfernen besteht in einem Vertauschen des Werts mit der höchsten Priorität, der an der Stelle
first steht, mit dem Wert an der Stelle last – 1.
push_heap() fügt ein Element in einen vorhandenen Heap
template <class RandomAccessIterator>
void push_heap(RandomAccessIterator first,RandomAccessIterator last);
template <class RandomAccessIterator>
void push_heap(RandomAccessIterator first,RandomAccessIterator last,
Compare comp));
make_heap() sorgt dafür, dass die Heap-Bedingung für alle Elemente innerhalb eines Bereichs gilt.
template <class RandomAccessIterator>
void make_heap(RandomAccessIterator first,RandomAccessIterator last);
template <class RandomAccessIterator>
void make_heap(RandomAccessIterator first,RandomAccessIterator last,
Compare comp));
Die Komplexität ist proportional zur Anzahl der Elemente zwischen first und last.
sort_heap() verwandelt einen Heap in eine sortierte Sequenz. Die Sortierung ist nicht stabil, die
Komplexität ist O(NlogN), wenn N die Anzahl der sortierten Elemente ist.
template <class RandomAccessIterator>
void sort_heap(RandomAccessIterator first,RandomAccessIterator last);
template <class RandomAccessIterator>
void sort_heap(RandomAccessIterator first,RandomAccessIterator last,
Compare comp));
Die Sequenz ist aufsteigend sortiert. Elemente hoher Priorität kommen an das Ende der Sequenz.
8
Algorithmen und Datenstrukturen
Lösungen
// BinaryHeap class
//
// Erzeugung mit optionaler Angabe zur Kapazitaet (Defaultwert: 100)
//
// ******************PUBLIC OPERATIONEN**********************************
// void insert( x )
--> Einfuegen x
// Comparable loescheMin( )--> Rueckgabe und entfernen des kleinsten
//
Elements
// Comparable findMin( )
--> Rueckgabe des kleinsten Elements
// boolean isEmpty( )
--> Rueckgabe: true, falls leer; anderenfalls
//
false
// boolean isFull( )
--> Rueckgabe true, falls voll; anderenfalls
// false
// void makeEmpty( )
--> Entfernen aller Elemente
// ******************ERRORS*******************************************
// Auswurf Overflow, Falls die Kapazitaet ueberschritten wird
public class BinaryHeap
{
/*
* Implementiert einen binaeren Heap.
* Vergleiche benutzen die Methode compareTo.
*/
// Konstante, Variable
private static final int DEFAULT_CAPACITY = 100;
private int aktGroesse;
// Anzahl der elemente im Heap
private Comparable [ ] feld;
// Der Heap-Container
// Konstruktoren
/*
* Erzeugen binaeren Heap.
*/
public BinaryHeap( )
{
this(DEFAULT_CAPACITY);
}
/*
* Erzeugen binaeren Heap.
* Parameter: Kapazitaet des binaeren heap.
*/
public BinaryHeap(int capacity )
{
aktGroesse = 0;
feld = new Comparable[ capacity + 1 ];
}
public BinaryHeap(int [] x)
{
this(x.length);
for (int i = 0; i < x.length; i++)
{
feld[++aktGroesse] = new Integer(x[i]);
}
System.out.println("Feld ohne Heap-Ordnung");
for (int i = 1; i < aktGroesse; i++)
System.out.println(feld[i] + " ");
macheHeap();
System.out.println("Feld mit Heap-Ordnung");
for (int i = 1; i < aktGroesse; i++)
System.out.println(feld[i] + " ");
}
// Methoden
/*
* Einfuegen in die prioritaetsgesteuerte Warteschlange
9
Algorithmen und Datenstrukturen
* unter Wahrung der Heap-Order.
* Duplikate sind zugelassen.
* Parameter x enthaelt das einzufuegende Element.
* Exception, falls der Behaelter voll ist.
*/
public void insert( Comparable x ) throws Overflow
{
if (istVoll( ) ) throw new Overflow( );
// Durchdringen nach oben
int luecke = ++aktGroesse;
for ( ; luecke > 1 && x.compareTo(feld[luecke / 2 ] ) < 0; luecke /= 2 )
feld[ luecke ] = feld[ luecke / 2 ];
feld[ luecke ] = x;
}
/*
* Finde das kleinste Element in der prioritaetsgesteuerten
* Warteschlange.
* Rueckgabe: kleinstes Element, oder null, falls leer.
*/
public Comparable findMin( )
{
if( isEmpty( ) ) return null;
return feld[ 1 ];
}
/*
* Entferne das kleinste Element aus der prioritaetsgest. Warteschlange.
* Rueckgabe: das kleinste Element, oder null, falls leer.
*/
public Comparable loescheMin( )
{
if ( isEmpty( ) ) return null;
Comparable minItem = findMin( );
feld[ 1 ] = feld[ aktGroesse-- ];
durchdringeRunter( 1 );
return minItem;
}
/*
* Einrichten der Heap-Ordnung aus einer gegebenen Menge von Merkmalen
* Ablaufgeschw. linear mit der Zeit.
*/
private void macheHeap( )
{
for (int i = aktGroesse / 2; i > 0; i-- )
{
durchdringeRunter( i );
}
}
/*
* Test ob die prioritaetsgesteuerte Schlange logisch leer ist
* Rueckgabe: true, falls leer, andernfalls false.
*/
public boolean isEmpty( )
{
return aktGroesse == 0;
}
/*
* Test, ob die prioritaetsgest. Schlange voll ist.
* Rueckgabe true, falls voll, anderenfalls false.
*/
public boolean istVoll( )
{
return aktGroesse == feld.length - 1;
}
10
Algorithmen und Datenstrukturen
/*
* Mache die prioritaetsgest. Schlange leer
*/
public void makeEmpty( )
{
aktGroesse = 0;
}
// Private Methoden
/*
* Interne Methode zum Durchdringen nach unten in den Heap.
* Parameter luecke: Index an dem das Durchdringen beginnt.
*/
private void durchdringeRunter( int luecke )
{
/* 1*/ int kind;
/* 2*/ Comparable tmp = feld[ luecke ];
/* 3*/ for( ; luecke * 2 <= aktGroesse; luecke = kind )
{
/* 4*/
kind = luecke * 2;
/* 5*/
if ( kind != aktGroesse &&
/* 6*/
feld[ kind + 1 ].compareTo( feld[ kind ] ) < 0 )
/* 7*/
kind++;
/* 8*/
if( feld[ kind ].compareTo( tmp ) < 0 )
/* 9*/
feld[ luecke ] = feld[ kind ];
else
/*10*/
break;
}
/*11*/ feld[ luecke ] = tmp;
}
}
11