class vector { public: explicit vector( int theSize = 0 ) : currentSize( theSize ) { objects = new Object[ currentSize ]; } vector( const vector & rhs ) : objects( NULL ) { operator=( rhs ); } ~vector( ) #ifndef WIN32 { delete [ ] objects; } #else { if( currentSize != 0 ) delete [ ] objects; } #endif size( ) const Master your int semester with Scribd { return currentSize; } Object & operator[]( int index & The New York Times const vector & vector::operator=( const vector & rhs ) { if( this != &rhs ) { #ifdef WIN32 if( currentSize != 0 ) #endif delete [ ] objects; currentSize = rhs.size( ); objects = new Object[ currentSize ]; for( int k = 0; k < currentSize; k++ ) objects[ k ] = rhs.objects[ k ]; } return *this; } vector::resize( int newSize & The New{void York Times class List; // Incomplete declaration. template class ListItr; // Incomplete declaration. template class ListNode { ListNode( const Object & theElement = Object( ), ListNode * n = NULL ) : element( theElement ), next( n ) { } Object element; ListNode *next; friend class List; friend class ListItr; }; class List { public: List( ); List( const List & rhs ); ~List( ); zeroth( ) const; class ListItr { public: ListItr( ) : current( NULL ) { } bool isPastEnd( ) const { return current == NULL; } void advance( ) { if( !isPastEnd( ) ) current = current->next; } const Object & retrieve( ) const { if( isPastEnd( ) ) throw BadIterator( ); return current->element; } private: ListNode *current; *theNode ) : current( theNode ) { } friend class List; // Grant access to constructor }; #include "LinkedList.cpp" #endif Special offer for students: Only $4.99/month. List::List( ) List::~List( ) { makeEmpty( ); delete header; } /** * Test if the list is logically empty. * return true if empty, false otherwise. */ template bool List::isEmpty( ) const { return header->next == NULL; } /** * Make the list logically empty. */ template void List::makeEmpty( ) { while( !isEmpty( ) ) remove( first( ).retrieve( ) ); } /** * Return an iterator representing the header node. */ template ListItr List::zeroth( ) const { return ListItr( header ); } Read Free Foron 30this Days Sign up to vote title /** Useful Not useful * Return an iterator representing the first node in the list. Cancel anytime. Special offer for students: Only $4.99/month. * This operation is valid for empty lists. */( x, p.current- ListItr List::find( const Object & x ) const { /* 1*/ ListNode *itr = header->next; /* 2*/ /* 3*/( itr ); } ListItr List::findPrevious( const Object & x ) const { /* 1*/ *itr = header;( itr ); } Not useful Useful void List::remove( const Object & x anytime. ) Cancel Special offer for students: Only $4.99/month. { ListItr p = findPrevious( x ); & List::operator=( const List & rhs ) { ListItr ritr = rhs.first( ); ListItr itr = zeroth( ); if( this != &rhs ) { makeEmpty( ); for( ; !ritr.isPastEnd( ); ritr.advance( ), itr.advance( ) ) insert( ritr.retrieve( ), itr ); } return *this; } #include "LinkedList.h" // Simple print method template void printList( const List & theList ) { if( theList.isEmpty( ) ) cout << "Empty list" << endl; else { ListItr itr = theList.first( ); for( ; !itr.isPastEnd( ); itr.advance( ) ) cout << itr.retrieve( ) << " "; } cout << endl; theList; ListItr theItr = theList.zeroth( ); list2; list2 = theList; printList( list2 ); return 0; } #include "vector.h" class Polynomial { enum { MAX_DEGREE = 100 }; friend int main( ); // So I can do a quick test. public: Polynomial( ); void zeroPolynomial( ); Polynomial operator+( const Polynomial & rhs ) const; Polynomial operator*( const Polynomial & rhs ) const; void print( ostream & out ) const; int highPower; Special offer for students: Only $4.99/month. }; class ListItr; // Incomplete declaration. template class List { public: List( ); List( const List & rhs ); ~List( );; friend class ListItr; }; const List & operator=( const List & rhs ); private: int header; static vector cursorSpace; static void initializeCursorSpace( ); static int alloc( ); static void free( int p ); friend class ListItr; }; class ListItr { public: ListItr( ) : current( 0 ) { } Read Free Foron 30this Days Sign up to vote title bool isPastEnd( ) const Useful Not useful { return current == 0; } Cancel anytime. Special offer for students: Only $4.99/month. void advance( ) { if( !isPastEnd( ) ) current = void List::initializeCursorSpace( ) { static int cursorSpaceIsInitialized = false; if( !cursorSpaceIsInitialized ) { cursorSpace.resize( 100 ); for( int i = 0; i < cursorSpace.size( ); i++ ) cursorSpace[ i ].next = i + 1; cursorSpace[ cursorSpace.size( ) - 1 ].next = 0; cursorSpaceIsInitialized = true; } } /** * Allocate a CursorNode */ template int List::alloc( ) { int p = cursorSpace[ 0 ].next; cursorSpace[ 0 ].next = cursorSpace[ p ].next; return p; } /** * Free a CursorNode */ template Read Free Foron 30this Days Sign up to vote title void List::free( int p ) { Useful anytime. Not useful cursorSpace[ p ].next = cursorSpace[Cancel 0 ].next; Special offer for students: Only $4.99/month. cursorSpace[ 0 ].next = p; } List::List( const List & rhs ) { initializeCursorSpace( ); header = alloc( ); cursorSpace[ header ].next = 0; *this = rhs; } /** * Destroy the list */ template List::~List( ) { makeEmpty( ); free( header ); } /** * Test if the list is logically empty. * return true if empty, false otherwise. */ template bool List::isEmpty( ) const { return cursorSpace[ header ].next == 0; } /** * Make the list logically empty. */ template void List::makeEmpty( ) { while( !isEmpty( ) ) Read Free Foron 30this Days Sign up to vote title remove( first( ).retrieve( ) ); Useful Not useful } Cancel anytime. Special offer for students: Only $4.99/month. /**( cursorSpace[ header ].next ); void List::insert( const Object & x, const ListItr & p ) { if( p.current != 0 ) { int pos = p.current; int tmp = alloc( ); cursorSpace[ tmp ] = CursorNode( x, cursorSpace[ pos ].next ); cursorSpace[ pos ].next = tmp; } } /** * Return iterator corresponding to the first node containing an item x. * Iterator isPastEnd if item is not found. */ template ListItr List::find( const Object & x ) const { /* 1*/ int itr = cursorSpace[ header ].next; /* 2*/ /* 3*/( itr ); } ListItr List::findPrevious( const Object & x )::remove( const Object & x ) { ListItr p = findPrevious( x ); int pos = p.current; if( cursorSpace[ pos ].next != 0 ) { int tmp = cursorSpace[ pos ].next; cursorSpace[ pos ].next = cursorSpace[ tmp ].next; free ( tmp ); } } const List & List::operator=( const List & rhs ) { ListItr ritr = rhs.first( ); ListItr itr = zeroth( ); if( this != &rhs ) { makeEmpty( ); for( ; !ritr.isPastEnd( ); ritr.advance( ), itr.advance( ) ) insert( ritr.retrieve( ), itr ); } return *this; } Useful Not useful #include "CursorList.h" Special offer for students: Only $4.99/month.::CursorNode> List::cursorSpace; int main( ) { List theList; ListItr theItr = theList.zeroth( ); int i; printList( theList ); for( i = 0; i < 10; i++ ) { theList.insert( i, theItr ); printList( theList ); theItr.advance( ); } for( i = 0; i < 10; i += 2 ) theList.remove( i ); for( i = 0; i < 10; i++ ) if( ( i % 2 == 0 ) != ( theList.find( i ).isPastEnd( ) ) ) cout << "Find fails!" << endl; cout << "Finished deletions" << endl; printList( theList ); return 0; } class Stack { public: explicit Stack( int capacity = 10 ); bool isEmpty( ) const; bool isFull( ) const; const Object & top( ) const; void makeEmpty( ); void pop( ); void push( const Object & x ); Object topAndPop( ); private: vector theArray; int topOfStack; }; #include "StackAr.cpp" #endif Stack::Stack( int capacity ) : theArray( capacity ) { topOfStack = -1; } Special offer for students: Only $4.99/month. bool Stack::isEmpty( ) const { void Stack::makeEmpty( ) { topOfStack = -1; } /** * Get the most recently inserted item in the stack. * Does not alter the stack. * Return the most recently inserted item in the stack. * Exception Underflow if stack is already empty. */ template const Object & Stack::top( ) const { if( isEmpty( ) ) throw Underflow( ); return theArray[ topOfStack ]; } /** * Remove the most recently inserted item from the stack. * Exception Underflow if stack is already empty. */ template void Stack::pop( ) { if( isEmpty( ) ) throw Underflow( ); topOfStack--; } /** * Insert x into the stack, if not already full. * Exception Overflow if stack is already full. */ Read Free Foron 30this Days Sign up to vote title template Useful Not useful void Stack::push( const Object &Cancel x )anytime. Special offer for students: Only $4.99/month. { if( isFull( ) ) #include "StackAr.h" int main( ) { Stack s; for( int i = 0; i < 10; i++ ) s.push( i ); while( !s.isEmpty( ) ) cout << s.topAndPop( ) << endl; return 0; } /** * Construct the stack. */ template Stack::Stack( ) { topOfStack = NULL; } Special offer for students: Only $4.99/month. /** bool Stack::isFull( ) const { return false; } /** * Test if the stack is logically empty. * Return true if empty, false otherwise. */ template bool Stack::isEmpty( ) const { return topOfStack == NULL; } /** * Make the stack logically empty. */ template void Stack::makeEmpty( ) { while( !isEmpty( ) ) pop( ); } /** * Get the most recently inserted item in the stack. * Return the most recently inserted item in the stack * or throw an exception if empty. */ Read Free Foron 30this Days Sign up to vote title template Useful Not useful const Object & Stack::top( ) const Cancel anytime. Special offer for students: Only $4.99/month. { if( isEmpty( ) ) Object Stack::topAndPop( ) { Object topItem = top( ); pop( ); return topItem; } /** * Insert x into the stack. */ template void Stack::push( const Object & x ) { topOfStack = new ListNode( x, topOfStack ); } /** * Deep copy. */ template const Stack & Stack:: operator=( const Stack & rhs ) { if( this != &rhs ) { makeEmpty( ); if( rhs.isEmpty( ) ) return *this; Read Free Foron 30this Days Sign up to vote title ListNode *rptr = rhs.topOfStack; Useful Not useful ListNode *ptr = new ListNode( rptr->element ); Cancel anytime. Special offer for students: Only $4.99/month. topOfStack = ptr; int int int Queue::Queue( int capacity ) : theArray( capacity ) { makeEmpty( ); } /** * Test if the queue is logically empty. * Return true if empty, false otherwise. */ template bool Queue::isEmpty( ) const { return currentSize == 0; } /** * Test if the queue is logically full. * Return true if full, false otherwise. */ Read Free Foron 30this Days Sign up to vote title template bool Queue::isFull( ) const Useful Not useful Cancel anytime. { Special offer for students: Only $4.99/month. return currentSize == theArray.size( ); } const Object & Queue::getFront( ) const { if( isEmpty( ) ) throw Underflow( ); return theArray[ front ]; } Object Queue::dequeue( ) { if( isEmpty( ) ) throw Underflow( ); currentSize--; Object frontItem = theArray[ front ]; increment( front ); return frontItem; } /** * Insert x into the queue. * Throw Overflow if queue is full */ template void Queue::enqueue( const Object & x ) { if( isFull( ) ) throw Overflow( ); increment( back ); Read Free Foron 30this Days Sign up to vote title theArray[ back ] = x; Useful Not useful currentSize++; Cancel anytime. Special offer for students: Only $4.99/month. } q; for( int j = 0; j < 5; j++ ) { for( int i = 0; i < 5; i++ ) q.enqueue( i ); while( !q.isEmpty( ) ) cout << q.dequeue( ) << endl; } return 0; } class BinarySearchTree; template class BinaryNode { Comparable element; BinaryNode *left; BinaryNode *right; BinaryNode( const Comparable & theElement, BinaryNode *lt, BinaryNode *rt ) : element( theElement ), left( lt ), right( rt ) { } Read Free Foron 30this Days Sign up to vote title friend class BinarySearchTree; }; Useful Not useful class BinarySearchTree { public: explicit BinarySearchTree( const Comparable & notFound ); BinarySearchTree( const BinarySearchTree & rhs ); ~BinarySearchTree( ); *root; const Comparable ITEM_NOT_FOUND; const Comparable & elementAt( BinaryNode *t ) const; void insert( const Comparable & x, BinaryNode * & t ) const; void remove( const Comparable & x, BinaryNode * & t ) const; * findMin( BinaryNode *t ) const; * findMax( BinaryNode *t ) const; Comparable & x, Master your semester with Scribd * find( const BinaryNode *t ) const; Read Free Foron 30this Days Sign up to vote title void makeEmpty( BinaryNode * & t ) const; & The New York Times useful Useful *t )Notconst; void printTree( BinaryNode Cancel anytime. * clone( BinaryNode *t ) const; BinarySearchTree::BinarySearchTree( const Comparable & notFound ) : root( NULL ), ITEM_NOT_FOUND( notFound ) { } BinarySearchTree:: BinarySearchTree( const BinarySearchTree & rhs ) : root( NULL ), ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND ) { *this = rhs; } /** * Destructor for the tree. */ template BinarySearchTree::~BinarySearchTree( ) { makeEmpty( ); } /** * Insert x into the tree; duplicates are ignored. */ template void BinarySearchTree::insert( const Comparable & x::findMin( ) const Comparable & BinarySearchTree::findMax( ) const { return elementAt( findMax( root ) ); } /** * Find item x in the tree. * Return the matching item or ITEM_NOT_FOUND if not found. */ template const Comparable & BinarySearchTree:: find( const Comparable & x ) const { return elementAt( find( x, root ) ); } /** * Make the tree logically empty. */ template void BinarySearchTree::makeEmpty( ) { makeEmpty( root ); } const BinarySearchTree & BinarySearchTree:: operator=( const BinarySearchTree & rhs ) { if( this != &rhs ) { makeEmpty( ); root = clone( rhs.root ); } return *this; } /** * Internal method to get element field in node t. * Return the element field or ITEM_NOT_FOUND if t is NULL. */ template const Comparable & BinarySearchTree:: elementAt( BinaryNode *t ) const { if( t == NULL ) return ITEM_NOT_FOUND; else return t->element; } /** * Internal method to insert into a subtree. * x is the item to insert. * t is the node that roots the tree. * Set the new root. */ Read Free Foron 30this Days Sign up to vote title template Useful Not useful void BinarySearchTree:: Cancel anytime. Special offer for students: Only $4.99/month. insert( const Comparable & x, BinaryNode * & t ) const void BinarySearchTree:: remove( const Comparable & x, BinaryNode * & t ) *oldNode = t; t = ( t->left != NULL ) ? t->left : t->right; delete oldNode; } } /** * Internal method to find the smallest item in a subtree t. * Return node containing the smallest item. */ template BinaryNode * BinarySearchTree::findMin( BinaryNode *t ) const { if( t == NULL ) return NULL; Read Free Foron 30this Days Sign up to vote title if( t->left == NULL ) Useful Not useful return t; Cancel anytime. Special offer for students: Only $4.99/month. return findMin( t->left ); } BinaryNode * BinarySearchTree:: find( const Comparable & x, BinaryNode *t ) const { if( t == NULL ) return NULL; else if( x < t->element ) return find( x, t->left ); else if( t->element < x ) return find( x, t->right ); else return t; // Match } /****** NONRECURSIVE VERSION************************* template BinaryNode * BinarySearchTree:: find( const Comparable & x, BinaryNode *t ) const { while( t != NULL ) if( x < t->element ) t = t->left; else if( t->element < x ) t = t->right; else return t; // Match return NULL; void BinarySearchTree::printTree( BinaryNode *t ) const { if( t != NULL ) { printTree( t->left ); cout << t->element << endl; printTree( t->right ); } } /** * Internal method to clone subtree. */ template BinaryNode * BinarySearchTree::clone( BinaryNode * t ) const { if( t == NULL ) return NULL; else return new BinaryNode( t->element, clone( t->left ), clone( t->right ) ); } #include "BinarySearchTree.h" t( ITEM_NOT_FOUND ); Special offer for students: Only $4.99/month. int NUMS = 4000; const int GAP 37; t2( ITEM_NOT_FOUND ); t2 = t; for( i = 2; i < NUMS; i+=2 ) if( t2.find( i ) != i ) cout << "Find error1!" << endl; for( i = 1; i < NUMS; i+=2 ) { if( t2.find( i ) != ITEM_NOT_FOUND ) cout << "Find error2!" << endl; } Read Free Foron 30this Days Sign up to vote title class AvlTree; Useful Not useful Cancel anytime. template Special offer for students: Only $4.99/month. class AvlNode { class AvlTree { public: explicit AvlTree( const Comparable & notFound ); AvlTree( const AvlTree & rhs ); ~AvlTree( ); const Comparable & findMin( ) const; const Comparable & findMax( ) const; const Comparable & find( const Comparable & x ) const; bool isEmpty( ) const; void printTree( ) const; void makeEmpty( ); void insert( const Comparable & x ); void remove( const Comparable & x ); const AvlTree & operator=( const AvlTree & rhs ); private:with Scribd Master your semester AvlNode *root; Read Free Foron 30this Days Sign up to vote title const Comparable ITEM_NOT_FOUND; & The New York Times Useful Not useful Cancel anytime. *t ) const; * & k2 ) const; void rotateWithRightChild( AvlNode * & k1 ) const; void doubleWithLeftChild( AvlNode * & k3 ) const; void doubleWithRightChild( AvlNode * & k1 ) const; }; #include "AvlTree.cpp" #endif /** * Implements an unbalanced Avl search tree. * Note that all "matching" is based on the compares method. * @author Mark Allen Weiss */ /** * Construct the tree. */ template AvlTree::AvlTree( const Comparable & notFound ) : ITEM_NOT_FOUND( notFound ), root( NULL ) { } /** * Copy constructor. */ template AvlTree::AvlTree( const AvlTree & rhs ) Read Free Foron 30this Days Sign up to vote title : ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND root( NULL ) Useful Not useful ), Cancel anytime. { Special offer for students: Only $4.99/month. *this = rhs; }::insert( const Comparable & x ) { insert( x, root ); } /** * Remove x from the tree. Nothing is done if x is not found. */ template void AvlTree::remove( const Comparable & x ) { cout << "Sorry, remove unimplemented; " << x << " still present" << endl; } /** * Find the smallest item in the tree. * Return smallest item or ITEM_NOT_FOUND if empty. */ template
