Quelle _Chapter_Heaps.xml Sprache: XML

<?xml version="1.0" encoding="UTF-8"?>


<Chapter Label="Chapter_Heaps">
<Heading>Heaps</Heading>

<P/>
<Section Label="Chapter_Heaps_Section_Introduction">
<Heading>Introduction</Heading>

<P/>
A <E>heap</E > is a tree datastructure  such that for any child <Math>C</Math> of a node <Math>N</Math>
it holds that <Math>C \leq N</Math>, according to some ordering relation <Math>\leq</Math>.
<P/>
The fundamental operations for heaps are Construction, <C>Push</C>ing data
onto the heap, <C>Peek</C>ing at the topmost item, and <C>Pop</C>ping the
topmost item off of the heap.
<P/>
For a good heap implementation these basic operations should not exceed
<Math>O(\log n)</Math> in runtime where <Math>n</Math> is the number of items on the heap.
<P/>
We currently provide two types of heaps: Binary Heaps <Ref Sect='Section_BinaryHeap'/> and
Pairing Heaps <Ref Sect="Section_PairingHeap" />.<P/>
<P/>
The following code shows how to use a binary heap.
<Example><![CDATA[
gap> h := BinaryHeap();
<binary heap with 0 entries>
gap> Push(h, 5);
gap> Push(h, -10);
gap> Peek(h);
5
gap> Pop(h);
5
gap> Peek(h);
-10
]]></Example>

<P/>
The following code shows how to use a pairing heap.
<Example><![CDATA[
gap> h := PairingHeap( {x,y} -> x.rank > y.rank );
<pairing heap with 0 entries>
gap> Push(h, rec( rank  := 5 ));
gap> Push(h, rec( rank  := 7 ));
gap> Push(h, rec( rank  := -15 ));
gap> h;
<pairing heap with 3 entries>
gap> Peek(h);
rec( rank := -15 )
gap> Pop(h);
rec( rank := -15 )
]]></Example>

</Section>

<Section Label="Chapter_Heaps_Section_API">
<Heading>API</Heading>

<P/>
For the purposes of the <Package>datastructures</Package>, we provide
a category <Ref Filt="IsHeap" Label="for IsObject"/> . Every
implementation of a heap in the category <Ref Filt="IsHeap" Label="for IsObject"/>
must follow the API described in this section.
<P/>
<ManSection>
  <Filt Arg="arg" Name="IsHeap" Label="for IsObject"/>
<Returns><K>true</K> or <K>false</K>
</Returns>
<Description>
The category of heaps. Every object in this category promises to
support the API described in this section.
</Description>
</ManSection>

<ManSection>
  <Func Arg="arg" Name="Heap" />
<Description>
Wrapper function around constructors
</Description>
</ManSection>

<ManSection>
  <Constr Arg="[filter, func, data]" Name="NewHeap" Label="for IsHeap, IsObject, IsObject"/>
<Returns>a heap
</Returns>
<Description>
Construct a new heap
<P/>
</Description>
</ManSection>

<ManSection>
  <Oper Arg="heap, object" Name="Push" Label="for IsHeap, IsObject"/>
<Description>
Puts the object <A>object</A> a new object onto <A>heap</A>.
<P/>
</Description>
</ManSection>

<ManSection>
  <Oper Arg="heap" Name="Peek" Label="for IsHeap"/>
<Description>
Inspect the item at the top of <A>heap</A>.
<P/>
</Description>
</ManSection>

<ManSection>
  <Oper Arg="heap" Name="Pop" Label="for IsHeap"/>
<Returns>an object
</Returns>
<Description>
Remove the top item from <A>heap</A> and return it.
</Description>
</ManSection>

<ManSection>
  <Oper Arg="heap1, heap2" Name="Merge" Label="for IsHeap, IsHeap"/>
<Description>
Merge two heaps (of the same type)
</Description>
</ManSection>

Heaps also support <Ref Filt="IsEmpty" BookName="ref"/> and
<Ref Oper="Size" BookName="ref"/>
</Section>

<Section Label="Section_BinaryHeap">
<Heading>Binary Heaps</Heading>

<P/>
A binary heap employs a binary tree as its underlying tree datastructure.
The implemenataion of binary heaps in <Package>datastructures</Package> stores
this tree in a flat array which makes it a very good and fast default choice for
general purpose use. In particular, even though other heap implementations have
better theoretical runtime bounds, well-tuned binary heaps outperform them
in many applications.
<P/>
For some reference see <URL>http://stackoverflow.com/questions/6531543</URL>
<ManSection>
  <Func Arg="[isLess, [data]]" Name="BinaryHeap" />
<Returns>A binary heap
</Returns>
<Description>
Constructor for binary heaps. The optional argument <A>isLess</A> must be a binary function
that performs comparison between two elements on the heap, and returns <K>true</K> if the first
argument is less than the second, and <K>false</K> otherwise.
Using the optional argument <A>data</A> the user can give a collection of initial values that
are pushed on the stack after construction.
</Description>
</ManSection>

</Section>

<Section Label="Section_PairingHeap">
<Heading>Pairing Heaps</Heading>

<P/>
A pairing heap is a heap datastructure with a very simple implementation in
terms of &GAP; lists.
<C>Push</C> and <C>Peek</C> have <M>O(1)</M> complexity, and <C>Pop</C> has an amortized
amortised O(log n), where <M>n</M> is the number of items on the heap.
<P/>
For a reference see <Cite Key="Fredman1986"/>.
<P/>
<ManSection>
  <Func Arg="[isLess, [data]]" Name="PairingHeap" />
<Returns>A pairing heap
</Returns>
<Description>
Constructor for pairing heaps. The optional argument <A>isLess</A> must be a binary function
that performs comparison between two elements on the heap, and returns <K>true</K> if the first
argument is less than the second, and <K>false</K> otherwise.
Using the optional argument <A>data</A> the user can give a collection of initial values that
are pushed on the stack after construction.
</Description>
</ManSection>

</Section>

<P/>
<Section Label="Chapter_Heaps_Section_Declarations">
<Heading>Declarations</Heading>

<ManSection>
  <Filt Arg="arg" Name="IsBinaryHeapFlatRep" Label="for IsHeap and IsPositionalObjectRep"/>
<Returns><K>true</K> or <K>false</K>
</Returns>
<Description>
<P/>
</Description>
</ManSection>

</Section>

<P/>
<Section Label="Chapter_Heaps_Section_Implementation">
<Heading>Implementation</Heading>

<ManSection>
  <Filt Arg="arg" Name="IsPairingHeapFlatRep" Label="for IsHeap and IsPositionalObjectRep"/>
<Returns><K>true</K> or <K>false</K>
</Returns>
<Description>
<P/>
</Description>
</ManSection>

</Section>

</Chapter>

quality94%

¤ Dauer der Verarbeitung: 0.23 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.