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

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}If the current list is different from the passed list,
		 then remove any elements in the current list and iterate 
		 through the elements of the passed list, inserting them
		 into the current list. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & size\index{List!size}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the number of items stored in the current list.
		 In order to allow a smooth interface with Scheme, 
		 no element count is maintained. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


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

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Indicate whether item is in list or not. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & sortedQ\index{List!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}
ContainerNode*  & search\index{List!search}(Item\& item)
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Search for item and return a pointer to 
		the node which contains it. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & emptyQ\index{List!emptyQ}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return true if list is empty. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & get\index{List!get}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return first element in the of list and remove it. $O(1)$
		   {\em Caution:} If the list 
		   is empty, this routine returns an uninitialized 
		   {\em Item} object.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & first\index{List!first}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the first item. $O(1)$  
		   {\em Caution:} If the list 
		   is empty, this routine returns an uninitialized 
		   {\em Item} object.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & last\index{List!last}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the last item.  $O(n)$ {\em Caution} If the list 
		  is empty, this routine
		   returns an uninitialized {\em Item} object.\end{minipage}
\end{minipage}
\vspace{0.2in}



\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & prepend\index{List!prepend}(Item item)
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert the item at the beginning of list. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & insert\index{List!insert}(Item item)
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert the item at the beginning of the list. $O(1)$
			 The redundancy in naming is to maintain naming 
			 consistency with \Collection\ member functions.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & append\index{List!append}(Item item)
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Append the item to the back of list. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & insertBefore\index{List!insertBefore}(Item item, ContainerNode *n)
\end{tabular}\\

			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert the item before node n. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & insertAfter\index{List!insertAfter}(Item item, ContainerNode *n)
\end{tabular}\\

			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Insert the item after node n. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


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

			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove the item from list and delete the 
			 \ListNode\ which contained it. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & clear\index{List!clear}()
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove all items from the list and delete their
		   associated \ListNodes.\ $O(n)$  {\em Note:} This
		   will become $O(1)$ with the Scheme interface, since
		   periodic garbage collection cleans up memory\end{minipage}
\end{minipage}
\vspace{0.2in}



\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & predecessor\index{List!predecessor}(const ContainerNode *n)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the node preceding $n$ in list order. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ContainerNode*  & successor\index{List!successor}(const ContainerNode *n) const
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the node succeeding $n$ in list order. $O(1)$\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ostream\&  & display\index{List!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}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & rank\index{List!rank}(Item\& item)
\end{tabular}\\

	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the position of the item in the list. $O(n)$\end{minipage}
\end{minipage}
\vspace{0.2in}