\begin{minipage}[t]{8in}
\begin{tabular}{ll}
BinaryHeapNode$<$Key,Item$>$*  & insert\index{BinaryHeap!insert}(Key k, Item i)
\end{tabular}\\
 
	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert item $i$ with key $k$
	 into the heap, returning a pointer to the node containing it.
	 $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{BinaryHeap!remove}(Item i)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}This does nothing.  It is defined with an empty
		body to provide a definition for the 
		{\em Container::remove(Item)} method.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & extractMin\index{BinaryHeap!extractMin}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Removes the node with minimum key from the
		heap and returns the information stored within. $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & get\index{BinaryHeap!get}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Calls {\em extractMin()}. $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
BinaryHeapNode$<$Key,Item$>$*  & minimum\index{BinaryHeap!minimum}()
\end{tabular}\\
 
		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return a pointer to the node containing the 
		minimum item in the heap, but do not remove it. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & min\index{BinaryHeap!min}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Call {\em minimum()}, then extract the Item from the 
		 returned node. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & size\index{BinaryHeap!size}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the number of items stored in the heap. An
		 element count is always stored. $O(1)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & emptyQ\index{BinaryHeap!emptyQ}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Is the heap empty? $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & fullQ\index{BinaryHeap!fullQ}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Is the heap full? $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & memberQ\index{BinaryHeap!memberQ}(const Item\&)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Is the item in the heap? $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & sortedQ\index{BinaryHeap!sortedQ}() const
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return FALSE.  $O(1)$.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & clear\index{BinaryHeap!clear}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove all the elements from the priority queue. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & decreaseKey\index{BinaryHeap!decreaseKey}(BinaryHeapNode$<$Key,Item$>$* node, Item k)
\end{tabular}\\
 
	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Decreases the value of the key
in {\em node} to the new key value {\em k}. $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & deleteKey\index{BinaryHeap!deleteKey}(ContainerNode* node)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Remove the entry in {\em noda} from the heap. $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ostream\&  & display\index{BinaryHeap!display}(ostream\&)
\end{tabular}\\
 
	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Produce a human-readable display of the data structure. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
friend ostream\&  & operator$<$$<$\index{BinaryHeap!operator$<$$<$}(ostream\& s, Heap$<$Item$>$\& h)
\end{tabular}\\


 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Output {\em h} to output stream s.
This is the inverse operation of $>$$>$.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ObjectType  & type\index{BinaryHeap!type}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}What type/implementation of priority queue is this?\end{minipage}
\end{minipage}
\vspace{0.2in}

