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 );
            }
        }
    }
}
        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( );
 }
Exemple #4
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;
        }
Exemple #6
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;
        }
Exemple #7
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;
}
Exemple #8
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( );
 }
Graph::~Graph( )
{
    ListItr<Vertex *> itr;
    for( itr = allVertices.first( ); !itr.isPastEnd( ); itr.advance( ) )
        delete itr.retrieve( );
}
Exemple #10
0
void Graph::clearAll( )
{
    ListItr<Vertex *> itr;
    for( itr = allVertices.first( ); !itr.isPastEnd( ); itr.advance( ) )
        itr.retrieve( )->reset( );
}
Exemple #11
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()
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;  
}