\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Heap$<$Item$>$\&  & operator=\index{PriorityQueue!operator=}(Heap$<$Item$>$$<$Key$>$\& h)
\end{tabular}\\


 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Copies the contents of one heap into another.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
HeapNode*  & insert\index{PriorityQueue!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.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{PriorityQueue!remove}(HeapNode* p)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Removes the node {\em p} from the heap.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
HeapNode*  & minimum\index{PriorityQueue!minimum}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return a pointer to the minimum item in the
heap, but do not remove it.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & removeMinimum\index{PriorityQueue!removeMinimum}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the minimum item in heap, and remove it.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & size\index{PriorityQueue!size}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the number of items in the heap.\end{minipage}
\end{minipage}
\vspace{0.2in}


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


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


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


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & changeKey\index{PriorityQueue!changeKey}(HeapNode* node, Item 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}.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & decreaseKey\index{PriorityQueue!decreaseKey}(HeapNode* 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}.
Faster than {\em changeKey} in certain implementations.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & merge\index{PriorityQueue!merge}(Heap \&H)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Merges the contents of $H$ into the current heap.
Presumably destroys the original heap.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & heapify\index{PriorityQueue!heapify}(Collection c)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Create a heap from the contents of
the collection.
Faster than repeated insertion for certain implementations.
WHAT ABOUT THE INFO FIELD??.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & scramble()\index{PriorityQueue!scramble()}
\end{tabular}\\
  
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Randomly permute the contents of the data structure
while leaving it functionally unchanged.
Useful for testing.\end{minipage}
\end{minipage}
\vspace{0.2in}


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


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
friend ostream\&  & operator$<$$<$\index{PriorityQueue!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}
friend istream\&  & operator$>$$>$\index{PriorityQueue!operator$>$$>$}(istream\& s, Heap$<$Item$>$\& h)
\end{tabular}\\


 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Read {\em h} from input stream {\em s}.
This is the inverse operation of $<$$<$.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ObjectType  & type\index{PriorityQueue!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}