Esempio n. 1
0
void Graph::unweighted( const string & startName )
{
    clearAll( );

    const MapEntry & match = vertexMap.find( MapEntry( startName ) );
    if( match == ITEM_NOT_FOUND )
    {
        cout << startName << " is not a vertex in this graph" << endl;
        return;
    }

    Vertex *start = match.storedVertex;
    Queue<Vertex *> q( numVertices );
    q.enqueue( start ); start->dist = 0;

    while( !q.isEmpty( ) )
    {
        Vertex *v = q.dequeue( );

        ListItr<Vertex *> itr;
        for( itr = v->adj.first( ); !itr.isPastEnd( ); itr.advance( ) )
        {
            Vertex *w = itr.retrieve( );
            if( w->dist == INFINITY )
            {
                w->dist = v->dist + 1;
                w->path = v;
                q.enqueue( w );
            }
        }
    }
}
//template <class Object>
void RunList(ifstream& stream){
   char iord;
   int number;
   
   //string dummy;
   //getline(stream, dummy);
  
   char dummy[256];
   stream.getline(dummy, 256); 
   
   List<int> list;
   ListItr<int> listItr = list.zeroth();
   
   while(stream >> iord >> number){
      if(iord == 'i'){
      list.insert(number, listItr);
      listItr.advance();
      //cout << "Inserted " << number << endl;
      }
      
      else /*if(iord == 'd')*/{
      list.remove(number);
      //cout << "Deleted " << number << endl;
      }
   }
   
   stream.clear();
   stream.seekg(0, ios::beg); 
}
        int main( )
        {
            List<int>    theList;
            ListItr<int> 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 );

            List<int> list2;
            list2 = theList;
            printList( list2 );

            return 0;
        }
        void HashTable<HashedObj>::insert( const HashedObj & x )
        {
            List<HashedObj> & whichList = theLists[ hash( x, theLists.size( ) ) ];
            ListItr<HashedObj> itr = whichList.find( x );

            if( itr.isPastEnd( ) )
                whichList.insert( x, whichList.zeroth( ) );
        }
 const HashedObj & HashTable<HashedObj>::find( const HashedObj & x ) const
 {
     ListItr<HashedObj> itr;
     itr = theLists[ hash( x, theLists.size( ) ) ].find( x );
     if( itr.isPastEnd( ) )
         return ITEM_NOT_FOUND;
     else
         return itr.retrieve( );
 }
Esempio n. 6
0
//Removes the first occurrence of x
void List::remove(int x){
    ListItr *l = new ListItr(find(x));

    if (!l->isPastEnd())
    {
         l -> current -> previous -> next = l -> current -> next;
         l -> current -> next -> previous = l -> current -> previous;
         count -= 1;

    }    
 }  
        void printList( const List<Object> & theList )
        {
            if( theList.isEmpty( ) )
                cout << "Empty list" << endl;
            else
            {
                ListItr<Object> itr = theList.first( );
                for( ; !itr.isPastEnd( ); itr.advance( ) )
                    cout << itr.retrieve( ) << " ";
            }

            cout << endl;
        }
Esempio n. 8
0
int
Jos1( int People, int Passes )
{
    List<int> L;
    ListItr<int> P = L;
    int i;

        // Construct the list
    for( i = 1; i <= People; i++ )
        P.Insert( i );

        // Play the game;
        // Note: P is always one player before
    while( People-- != 1 )
    {
        for( i = 0; i < Passes; i++ )
        {
            P++;                 // Advance
            if( !+P )            // If we just went past last player
                P.First( );      // then go back to first
        }

        if( !P.RemoveNext( ) )   // Remove next player
        {
                // RemoveNext fails if P is last item,
            P.Zeroth( );         // so for last item, set P
            P.RemoveNext( );     // to 0th player to remove first player
        }
    }

    P.First( );      // Get first and only player
    return P( );     // Return player's number
}
Esempio n. 9
0
        const List<Object> & List<Object>::operator=( const List<Object> & rhs )
        {
            if( this != &rhs )
            {
                makeEmpty( );

                ListItr<Object> ritr = rhs.first( );
                ListItr<Object> itr = zeroth( );
                for( ; !ritr.isPastEnd( ); ritr.advance( ), itr.advance( ) )
                    insert( ritr.retrieve( ), itr );
            }
            return *this;
        }
Esempio n. 10
0
ostream & operator<<( ostream & out, const WordEntry & rhs )
{
    out << rhs.word << ": ";

    if( rhs.lines != NULL && !rhs.lines->isEmpty( ) )
    {
        ListItr<int> itr = rhs.lines->first( );
        out << '\t' << itr.retrieve( );
        for( itr.advance( ); !itr.isPastEnd( ); itr.advance( ) )
            out << ", " << itr.retrieve( );
    }
    return out;
}
Esempio n. 11
0
void printList(List& source, bool direction) {
  // if (source.size() > 0) {
  if (direction) {
    ListItr iter = source.first();
    for (int n=0; n<source.size(); n++) {
      cout << iter.retrieve() << endl;
      iter.moveForward();
    }
  }
  
  else {
    ListItr iter = source.last();
    for (int n=0; n<source.size(); n++) {
      cout << iter.retrieve() << endl;
      iter.moveBackward();
    }
  } 
  // }
  //else {
  //cout << "The list is empty" << endl;
  //}
} 
Esempio n. 12
0
 const HashedObj & ChainingHashTable<HashedObj>::find( const HashedObj & x ) const
 {
     ListItr<HashedObj> itr;
     itr = theLists[ hash( x, theLists.size( ) ) ].find( x );
     return itr.isPastEnd( ) ? ITEM_NOT_FOUND : itr.retrieve( );
 }
Esempio n. 13
0
Graph::~Graph( )
{
    ListItr<Vertex *> itr;
    for( itr = allVertices.first( ); !itr.isPastEnd( ); itr.advance( ) )
        delete itr.retrieve( );
}
Esempio n. 14
0
void Graph::clearAll( )
{
    ListItr<Vertex *> itr;
    for( itr = allVertices.first( ); !itr.isPastEnd( ); itr.advance( ) )
        itr.retrieve( )->reset( );
}
Esempio n. 15
0
int   main ()
/*
**  This main driver program interactively exercises a
**   list package.
**  It assumes a linked list implementation, and its real
**   purpose is to exercise the underlying list manipulation
**   procedures.
**  It uses a menu to accept commands from the terminal,
**   then performs the indicated command.
*/
{
    int      command;
    string   response;
    List     *list = NULL;
    ListItr  *itr = NULL;
    // Initialize this run
    cout << "--------------------------------------------------\n";
    cout << "\tThis test harness operates with one List\n"
         << "\tobject and one ListItr object.\n\n"
         << "\tUse the menu options to manipulate these\n"
         << "\tobjects.\n";

    while (1) {
        command = menu(option, n_choice);

        switch (command) {
            case 1:                        // Quit
                cout << "\tDo you really want to quit? (y/n) > ";
                cin  >> response;

                if (response[0] == 'y' || response[0] == 'Y') {                 // Normal Exit
                    return 0;
                }

                break;

            case 2:                        // New list
                if (list != NULL) delete list;
                list = new List;

                cout << "\tYou have created an empty list\n";
                cout << "\tDo you want to initialize it with elements? (y/n) > ";
                cin  >> response;

                if (response[0] != 'y' && response[0] != 'Y')
                    break;
                // accept elements
                cout << "\t\tEnter elements one by one as integers.\n";
                cout << "\t\tAny non-numeric character, e.g. #, ";
                cout << "will terminate input\n";

                cout << "\tEnter first element: ";
                cin >> response;

                while (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    list->insertAtTail(element);

                    cout << "\tEnter next element: ";
                    cin >> response;
                }

                cout << endl << "The elements in forward order: " << endl;
                printList(*list, true);
                break;

            case 3:                      // show elements
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }
                cout << "\tPrint the list forwards or backwards? (f/b) > ";
                cin  >> response;

                if (response[0] == 'b' || response[0] == 'B') {
                    cout << endl << "The elements in reverse order:" << endl;
                    printList(*list, false);
                } else {
                    cout << endl << "The elements in forward order:" << endl;
                    printList(*list, true);
                }
                break;

            case 4:                      // test first()
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }
                cout << "\tSetting the ListItr to the first element..." << endl;
                itr = new ListItr((list->first()));
                break;

            case 5:                      // test find()
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }
                cout << "\tEnter element to find: ";
                cin >> response;

                if (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    itr = new ListItr((list->find(element)));
                    cout << "\tSetting the ListItr to find("
                         << element << ")..." << endl;
                } else {
                    cout << "\tPlease enter an integer." << endl;
                }
                break;

            case 6:                      // test last()
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                }
                cout << "\tSetting the ListItr to the last element..." << endl;
                itr = new ListItr((list->last()));
                break;

            case 7:                      // test moveForwards()
                if (itr == NULL) {
                    cout << endl << "\tCreate a ListItr first." << endl;
                    break;
                }
                cout << "\tMoving the ListItr forwards..." << endl;
                itr->moveForward();
                break;

            case 8:                      // test move_backwards()
                if (itr == NULL) {
                    cout << endl << "\tCreate a ListItr first." << endl;
                    break;
                }
                cout << "\tMoving the ListItr backwards..." << endl;
                itr->moveBackward();
                break;

            case 9:                      // test retrieve()
                if (itr == NULL) {
                    cout << endl << "\tCreate a ListItr first." << endl;
                    break;
                }

                if (itr->isPastBeginning())
                    cout << "\tThe ListItr is past the beginning." << endl;
                else if (itr->isPastEnd())
                    cout << "\tThe ListItr is past the end." << endl;
                else
                    cout << "\tElement retrieved: " << itr->retrieve() << endl;
                break;

            case 10:                        // Insert element before
                if (list == NULL || itr == NULL) {
                    cout << endl << "\tCreate a List and ListItr first." << endl;
                    break;
                }

                cout << "\tEnter element to insert: ";
                cin >> response;

                if (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    list->insertBefore(element, *itr);
                    cout << "\tInserting " << element
                         << " before the current ListItr" <<endl;
                } else {
                    cout << "\tPlease enter an integer." << endl;
                    break;
                }

                cout << endl << "The elements in forward order: " << endl;
                printList(*list, true);
                break;

            case 11:                        // Insert element after
                if (list == NULL || itr == NULL) {
                    cout << endl << "\tCreate a List and ListItr first." << endl;
                    break;
                }

                cout << "\tEnter element to insert: ";
                cin >> response;

                if (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    list->insertAfter(element, *itr);
                    cout << "\tInserting " << element
                         << " after the current ListItr" <<endl;
                } else {
                    cout << "\tPlease enter an integer." << endl;
                    break;
                }

                cout << endl << "The elements in forward order: " << endl;
                printList(*list, true);
                break;

            case 12:                        // Insert element at tail
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }

                cout << "\tEnter element to insert: ";
                cin >> response;

                if (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    list->insertAtTail(element);
                    cout << "\tInserting " << element
                         << " at the tail of the list" <<endl;
                } else {
                    cout << "\tPlease enter an integer." << endl;
                    break;
                }

                cout << endl << "The elements in forward order: " << endl;
                printList(*list, true);
                break;

            case 13:                        // Remove element
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }

                cout << "\tEnter element to remove: ";
                cin >> response;

                if (isdigit(response[0])) {
                    int element = atoi(response.c_str());
                    list->remove(element);
                    cout << "\tRemoving " << element
                         << " from list" <<endl;
                } else {
                    cout << "\tPlease enter an integer." << endl;
                    break;
                }

                cout << endl << "The elements in forward order: " << endl;
                printList(*list, true);
                break;

            case 14:                      // test size()
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }

                cout << "\tSize of list: " << list->size() << endl;
                break;

            case 15: {                    // test copy constructor
                List* old_list=list;
                list=new List(*old_list);
                old_list->makeEmpty();

                cout << "The new list is (forward ): " ;
                printList(*list, true);
                cout << "The new list is (backward): " ;
                printList(*list, false);
                cout << "The old list was made empty (forward ): ";
                printList(*old_list, true);
                cout << "The old list was made empty (backward): ";
                printList(*old_list, false);
                cout << "The old list should be destroyed now." << endl;
                delete old_list;
                break;
            }
            case 16: {                    // test equals operator
                List* old_list=list;
                list=new List();
                *list=*old_list;
                old_list->makeEmpty();

                cout << "The new list is (forward ): " ;
                printList(*list,true);
                cout << "The new list is (backward): " ;
                printList(*list,false);
                cout << "The old list was made empty (forward ): " ;
                printList(*old_list,true);
                cout << "The old list was made empty (backward): " ;
                printList(*old_list,false);
                cout << "The old list should be destroyed now." << endl;

                delete old_list;
                break;
            }

            case 17:                      // test makeEmpty()
                if (list == NULL) {
                    cout << endl << "\tCreate a List first." << endl;
                    break;
                }

                cout << "The list is (forward ): " ;
                printList(*list,true);
                cout << "The list is (backward): " ;
                printList(*list,false);
                list->makeEmpty();
                cout << "The list was made empty (forward ): " ;
                printList(*list,true);
                cout << "The list was made empty (backward): " ;
                printList(*list,false);
        }               // end of switch (command)
    }            // end of while (1)
}     // end of main()
Esempio n. 16
0
void List::insertAfter( int x, ListItr position ) {
  position.moveForward();
  insertBefore(x, position);
} 
Esempio n. 17
0
void SongSearch::query(const Request &request, Song answer[], int *answerCount)
{
	int counter = 0; 
	if(request.type == 0){
		 Song *temp; 
		 for(int i = 0; i < titles.size() ; i++){
		 	if( titles[i] != NULL && strstr(titles[i]->common, request.criteria) != NULL){
				for( ListItr <Song *> itr  = titles[i]->list->first(); !itr.isPastEnd(); itr.advance()){
				    temp = (Song *) itr.retrieve();
				    //cout << temp->title << endl; 
		  			copy(answer[counter], temp); 
		  			counter++; 
				}
		 	}
		}
		*answerCount = counter; 
	}   
	else if(request.type == 1){
  		const holdlink* link = linearprobingtitle->find(request.criteria); 
  		Song *temp;
  		for( ListItr <Song *>itr  = link->list->first(); !itr.isPastEnd(); itr.advance()){
  	    	temp = (Song *) itr.retrieve();
  	    	copy(answer[counter], temp); 
  	    	counter++; 
  		}
  	*answerCount = counter; 
    }
  	else if(request.type == 2){
  		const holdlink* link = linearprobingartist->find(request.criteria); 
  		Song *temp;
  		for( ListItr <Song *> itr  = link->list->first(); !itr.isPastEnd(); itr.advance()){
  	    	temp = (Song *) itr.retrieve();
  	    	copy(answer[counter], temp); 
  	    	counter++; 
  		}
  		*answerCount = counter; 
  	}   
  	else if(request.type == 3){ //WORKS 
		*answerCount = 0;   
			for(int i = 0; i < songCount; i++){
			   if(strcmp(songs[i]->ID, request.criteria) == 0 ){
			   		copy(answer[*answerCount], songs[i]); 
					(*answerCount)++;
			   		for(int j = i+1; j < songCount; j++){
			   			if(strcmp(songs[j]->ID, request.criteria2) == 0){
				   			while(strcmp(songs[j]->ID, request.criteria2) == 0){
						   		copy(answer[*answerCount], songs[j]); 
					   			(*answerCount)++;
				   				j++; 
				   			}
				   			return; 
			   			}
			   			else{
							copy(answer[*answerCount], songs[j]); 
				   			(*answerCount)++;
			   			}
			   		}	
				}
		    }
	}
    else if (request.type == 4){
  		const holdlink* link = linearprobingalbum->find(request.criteria); 
  		Song *temp;
  		for( ListItr <Song *> itr  = link->list->first(); !itr.isPastEnd(); itr.advance()){
  	    	temp = (Song *) itr.retrieve();
  	    	copy(answer[counter], temp); 
  	    	counter++; 
  		}
  		*answerCount = counter; 
    }
	
	return;  
}