C++ PQueue::isEmpty方法代码示例

/*
 * Function: MoreQueueTest
 * Usage: MoreQueueTest();
 * -----------------------
 * Tests a few more enqueue, dequeueMax, some boundary cases explored.
 * Reports results of test to cout.
 */
void MorePQueueTest()
{
    PQueue pq;
    
    cout << boolalpha;
    cout << endl << "-----------   More pqueue testing functions -----------" << endl;
    
    cout << endl << "Enqueuing integers from 15 downto 1 (decreasing order)" << endl;
    for (int i = 15; i > 0; i--)
        pq.enqueue(i);
    
    cout << "Enqueuing duplicates for even numbers 2 to 14" << endl;
    for (int j = 2; j <= 14; j += 2)
        pq.enqueue(j);
    
    cout << "Dequeuing the top 10 elements: ";
    for (int k = 0; k < 10; k++)
        cout << pq.dequeueMax() << " ";
    
    cout << endl << "Dequeuing all the rest: ";
    while (!pq.isEmpty())
        cout << pq.dequeueMax() << " ";
    cout << endl << "Pqueue should be empty.  Is it empty? " << pq.isEmpty() << endl;
    
}

/*
 * Function: BasicPQueueTest
 * Usage: BasicQueueTest();
 * ------------------------
 * Runs a test of the PQueue focusing on simple enqueue, dequeueMax.
 * Reports results of test to cout.
 */
void BasicPQueueTest()
{
    PQueue pq;
    
    cout << boolalpha;	// configure stream to print booleans as true/false instead of 1/0
    cout << endl << "-----------   Testing Basic PQueue functions -----------" << endl;
    cout << "The pqueue was just created.  Is it empty? " << pq.isEmpty() << endl;
    
    cout << endl << "Now enqueuing integers from 1 to 10 (increasing order)" << endl;
    for (int i = 1; i <= 10; i++)
        pq.enqueue(i);
    
    cout << "Pqueue should not be empty.  Is it empty? " << pq.isEmpty() << endl;
    cout << "Pqueue should have size = 10.  What is size? " << pq.size() << endl;
    
    cout << "Dequeuing the top 5 elements: ";
    for (int j = 0; j < 5; j++)
        cout << pq.dequeueMax() << " ";
    cout << endl << "Pqueue should have size = 5.  What is size? " << pq.size() << endl;
    
    cout << endl << "Dequeuing all the rest: ";
    while (!pq.isEmpty())
        cout << pq.dequeueMax() << " ";
    cout << endl << "Pqueue should be empty.  Is it empty? " << pq.isEmpty() << endl;
    
}

/*
 * Function: MoreQueueTest
 * Usage: MoreQueueTest();
 * -----------------------
 * Tests a few more enqueue, dequeueMax, some boundary cases explored.
 * Reports results of test to cout.
 */
void MorePQueueTest()
{
	PQueue pq;
	
	cout << boolalpha;
	cout << endl << "-----------   More pqueue testing functions -----------" << endl;

	cout << endl << "Enqueuing integers from 15 downto 1 (decreasing order)" << endl;
	for (int i = 15; i > 0; i--)
		pq.enqueue(i);
	
	cout << "Enqueuing duplicates for even numbers 2 to 14" << endl;
	for (int j = 2; j <= 14; j += 2)
		pq.enqueue(j);

	cout << "Dequeuing the top 10 elements: ";
	for (int k = 0; k < 10; k++)
		cout << pq.dequeueMax() << " ";
		
	cout << endl << "Dequeuing all the rest: ";
	while (!pq.isEmpty())
		cout << pq.dequeueMax() << " ";
	cout << endl << "Pqueue should be empty.  Is it empty? " << pq.isEmpty() << endl;

	// The line below calling DequeueMax should cause your program to halt with an error.
	// Once you've verified that your PQueue correctly raises this error
	// you should comment out the call, so that you can continue on with the other tests.
	cout << endl << "This next test raises an error if your pqueue is working correctly." << endl;
	cout << "Once you verify the test, comment it out to move on to the other tests." << endl;
	cout << "(Comment out line " << __LINE__ + 1 << " in the file " << __FILE__ << ")." << endl;
	cout << "Dequeue from empty pqueue returns " << pq.dequeueMax() << endl;

	cout << endl << "Hit return to continue: ";
	GetLine();
}

void basicStructuralTests() {
    beginTest("Basic Structural Tests");

    /* This try ... catch system is designed to catch any errors that the
     * program explicitly generates.  It does not guard against runtime
     * crashes from errors like following a bad pointer, so if your
     * program crashes and pulls up the debugger, you should be looking
     * for memory errors.
     */
    try {

        /* The use of curly braces here introduces a new block scope.  We
         * use this so that we can construct multiple different priority
         * queues.
         */

        /* Basic test: Add 5 elements to the queue and ensure that
         * the size is correct at each step.
         */
        {
            logInfo("These tests will check size() isEmpty() without calling dequeueMin().");

            PQueue queue;
            checkCondition(queue.isEmpty(), "New priority queue should be empty.");
            checkCondition(queue.size() == 0, "New priority queue should have size 0.");

            for (int i = 0; i < 5; i++) {
                queue.enqueue("Test String");

                checkCondition(queue.size() == i + 1, "Queue should have proper size after inserting a value.");
                checkCondition(!queue.isEmpty(), "Queue containing elements should not be empty.");
                cout<<i<<endl;
            }
        }

        /* Slightly more complex test: Enqueue and dequeue elements, ensuring the
         * size matches at each step.
         */
        {
            logInfo("We're about to start calling dequeueMin().");
            PQueue queue;

            for (int i = 0; i < 5; i++) {
                queue.enqueue("Test String");
            }

            for (int i = 5; i > 0; i--) {
                checkCondition(queue.size() == i, "Queue should have proper size after dequeues.");
                checkCondition(!queue.isEmpty(), "Queue should not be empty before all elements are removed.");
                queue.dequeueMin();
            }

            checkCondition(queue.size() == 0, "After removing all elements, the queue should have size 0.");
            checkCondition(queue.isEmpty(), "After removing all elements, the queue should be empty.");
        }

        /* Getting harder: The value dequeued should always match the value of peek(). */
        {
            logInfo("This next test will check whether peek() matches dequeueMin().");
            PQueue queue;

            for (int i = 0; i < 5; i++) {
                queue.enqueue(randomString());
            }

            while (!queue.isEmpty()) {
                string expected = queue.peek();
                checkCondition(queue.dequeueMin() == expected, "Value returned by peek() matches value returned by dequeueMin()");
            }
        }

        /* A different one - let's make sure that peeking at an empty queue causes an
         * error.
         */
        {
            PQueue queue;
            bool didThrow = false;
            try {
                logInfo("About to peek into an empty queue.  This may cause a crash");
                logInfo("if your implementation is incorrect.");
                queue.peek();
            } catch (ErrorException&) {
                didThrow = true;
            }

            checkCondition(didThrow, "Priority queue uses 'error' when peek() called on empty queue.");
        }

        /* In the same vein - what happens if we dequeue from an empty queue? */
        {
            PQueue queue;
            bool didThrow = false;
            try {
                logInfo("About to dequeue from an empty queue.  This may cause a crash");
                logInfo("if your implementation is incorrect.");
                queue.dequeueMin();
            } catch (ErrorException&) {
                didThrow = true;
            }

//.........这里部分代码省略.........

int main(void)
{
	Queue bankQueue; //represents the line of customers in the bank/bank line
	PQueue eventListPQueue; //priority queue eventListPQueue for the event list

	bool tellerAvailable = true;
	loadIntoPriorityQueue(eventListPQueue); //load data into Priority Queue from file/Create and add arrival events to event list

	//waitTime = SUM(time of departure) - SUM(processing time) - SUM(time of arrival)/COUNT(EVENTS)
	unsigned int sumDepartureTime = 0;
	unsigned int sumProcessingTime = 0;
	unsigned int sumArrivalTime = 0;
	unsigned int eventCount = 0; //track how many customers came in
	float waitTime; //Calculated at the end

	cout << "Simulation Begins" << endl;

	while(!eventListPQueue.isEmpty()) //run while eventListPQueue is not empty
	{
		Event newEvent = eventListPQueue.peek();
		// Get current time
		unsigned int currentTime = newEvent.getTime(); // get time of newEvent
		if (newEvent.getType() == 'A') //check if newEvent is an arrival event
		{
			// Processes an arrival event.
			//processArrival(newEvent, eventListPQueue, bankQueue, tellerAvailable, currentTime);

			eventListPQueue.dequeue(); //Remove this event from the event list
			Event customer = newEvent; //customer referenced in arrivalEvent
			if (bankQueue.isEmpty() && tellerAvailable)
			{
				unsigned int departureTime = currentTime + customer.getLength();//currentTime + transaction time in arrivalEvent
				Event newDepartureEvent('D', departureTime, 0); //a new departure event with departureTime
				eventListPQueue.enqueue(newDepartureEvent);
				tellerAvailable = false;
			}
			else
			{
				bankQueue.enqueue(customer);
			}

			cout << "Processing an arrival event at time:\t" << customer.getTime() << endl;
			eventCount++; //count how many customers arrived
			sumArrivalTime += customer.getTime();
			sumProcessingTime += customer.getLength();
		}
		else
		{
			// Processes a departure event.
//			processDeparture(newEvent, eventListPQueue, bankQueue, tellerAvailable, currentTime);
			eventListPQueue.dequeue(); // Remove this event from the event list

			if(!bankQueue.isEmpty())
			{
				// Customer at front of line begins transaction
				Event customer = bankQueue.peek();
				bankQueue.dequeue();
				unsigned int departureTime = currentTime + customer.getLength(); //currentTime + transaction time in customer
				Event newDepartureEvent('D', departureTime, 0); //a new departure event with departureTime
				eventListPQueue.enqueue(newDepartureEvent);
			}
			else
			{
				tellerAvailable = true;
			}

			cout << "Processing a departure event at time:\t" << currentTime << endl; //temp
			sumDepartureTime += currentTime;
		}

	}

	waitTime = (float)(sumDepartureTime - sumProcessingTime - sumArrivalTime)/eventCount; //do the average wait time calculation

	cout << "Simulation Ends\n\n";
	cout << "Final Statistics:" << endl;
	cout << "\tTotal number of people processed: " << eventCount << endl;
	cout << "\tAverage amount of time spent waiting: " << waitTime << endl;

//	cout << "Bank Queue Contents:" << endl;
//	bankQueue.print();
//	cout << "Priority Queue Contents:" << endl;
//	eventListPQueue.print();
//	resultPrinterQueue(bankQueue); //print out the results
	return 0;
}