Quelle  _Chapter_Heaps.xml   Sprache: XML

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

<!-- This is an automatically generated file. -->
<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>