\begin{minipage}[t]{8in}
\begin{tabular}{ll}
BinomialHeapNode$<$Key,Item$>$*  & insert\index{BinomialHeap!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 HeapNode containing it.
	 $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & search\index{BinomialHeap!search}(const Key\&)
\end{tabular}\\
 
		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Searches the heap for the passed key. $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & searchItem\index{BinomialHeap!searchItem}(const Item\&)
\end{tabular}\\
 
		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Searches the heap for the passed item. $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{BinomialHeap!remove}(BinomialHeapNode$<$Key,Item$>$* n)
\end{tabular}\\
 
		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Removes {\em n} from the heap.  $O(\log n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{BinomialHeap!remove}(Item i)
\end{tabular}\\
 
		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Removes {\em n} from the heap by first searching for
		{\em i}, then removing the node containing it.  $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & extractMin\index{BinomialHeap!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{BinomialHeap!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}
BinomialHeapNode$<$Key,Item$>$*  & minimum\index{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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{BinomialHeap!sortedQ}()
\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{BinomialHeap!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  & changeKey\index{BinomialHeap!changeKey}(HeapNode* node, Key k)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Change 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  & decreaseKey\index{BinomialHeap!decreaseKey}(BinomialHeapNode$<$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  & merge\index{BinomialHeap!merge}(BinomialHeap$<$Key,Item$>$\& H)
\end{tabular}\\
 
	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Merges the contents of $H$ into the current heap.  $O(\log n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & scramble()\index{BinomialHeap!scramble()}
\end{tabular}\\
  
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Randomly permute the contents of the data structure
without losing the priority queue property.  Useful for testing. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & deleteKey\index{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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{BinomialHeap!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}


