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


 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Allocate space large enough to hold the elements of {\em a}, then 
 copy its contents.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode *  & insert\index{Array!insert}(Item item)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert {\em item} into the 0'th
cell of \Array,\ shifting one cell forward any contiguous block of 
elements starting with that cell.
If this operation would extend the active range of cells beyond the current
allocation, reallocate the \Array\ and recopy the elements.
Note:  The return type is {\em ContainerNode*} so that this method may
be called from \Container\ pointers or references.  However, since there
is no packaging node structure in \Array,\ a NULL pointer is returned. 
$O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode *  & append\index{Array!append}(Item item)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}The same as insert(Item item), 
	except that the new item is added to the empty cell adjacent to
	the cell in the array's active range of largest index.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{Array!remove}(Item item)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove the item from \Array\ if it is there. Shift the elements of
	 larger index to fill in the vacancy left by the removal. $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & start\index{Array!start}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Returns the address of the 0'th element of the \Array. 
		   $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & get\index{Array!get}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the last element in the active range of the array 
	 and remove it. $O(1)$
                   {\em Caution:} If the \Array stores no elements,
                   this routine returns an uninitialized
                   {\em Item} object.\end{minipage}
\end{minipage}
\vspace{0.2in}



\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & clear\index{Array!clear}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove all items from the active range of the \Array.
		   $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & memberQ\index{Array!memberQ}(Item\& item)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Is item in the array or not? $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & sortedQ\index{Array!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}
int  & order\index{Array!order}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the number of cells allocated in the array. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & size\index{Array!size}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the active range of elements, defined to be 
		 ($m-0$, where $m$ is the largest index of a referenced 
		cell. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item\&  & operator[] \index{Array!operator[] }(int ix)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return item of index ix. Bounds checking
 				is done, and the element count is 
				updated if the cell referenced has a
				larger index than that of any previous
				reference. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & search\index{Array!search}(Item)
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Search for an item in the active range of the array and 
	return its index if it is found.  Return -1 otherwise $O(n)$ .\end{minipage}
\end{minipage}
\vspace{0.2in}

			

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & min\index{Array!min}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}The \Container\ method is redefined since faster iteration
	 	 is possible in this class. $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & max\index{Array!max}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}The \Container\ method is redefined since faster iteration
	 	 is possible in this class. $O(n)$ \end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ostream\&  & display\index{Array!display}(ostream\& os)
\end{tabular}\\

                
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Output the list to the output stream {\em os}.  Uses
                 {\em Container::displayItem(...)} to display each
                 element.  $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}

