CSCI 200 Lab 11 A Heap-Based Priority Queue

Transcription

1 CSCI 200 Lab 11 A Heap-Based Priority Queue Preliminaries Part of today s lab will focus on implementing a heap-based priority queue using an ArrayListlike class called ZHExtensibleArrayStructure. Recall that a heap is a binary tree (not a binary search tree) such that every element in the tree is less than (or in some implementations greater than) or equal to both its left and right child elements (if they exist). Every level of the tree is complete except possibly the bottom level, which is filled in from the left to the right with no gaps allowed. We could implement a heap using binary tree nodes, but it's actually easier to implement a heap using a linear array structure. Instead of using a raw array for the elements, we'll use the ZHExtensibleArrayStructure class, which is a sort of primitive ArrayList. It works like an array, but it supplies methods required by the ZHCollection interface along with other useful methods such as get, set, findindex, addlast, and, removelast; it also automatically expands the structure when necessary, so you don t have to check for the need to reallocate. Using this class, we can concentrate on how the heap works and not on the details of how to use the array. Use the online documentation for the zhstructures package to study the ZHExtensibleArrayStructure and ZHArrayStructure classes as well as the ZHQueue and ZHCollection interfaces. Copy the lab directory into your CS200/labs directory. Keep the three test files in your lab folder but move the file FOOHeapPriorityQueue.java into your structures directory and rename it with your initials in place of FOO. Open the four files and change all instances of <FOO> and <foo> to the appropriate initials. When you are done making these changes, close the test classes but keep your <FOO>HeapPriorityQueue.java file open. For the third part of this lab, you will be modifying your bank simulation program from Lab 6 to use a priority queue. If you have not already done so, complete the simulation program from Lab 6, the bank simulation lab. If neither you nor your current programming partner is close to finishing that lab, arrange to get a copy from another student who has it completed, but be sure that every file you copy from another person includes that person's name as author. In this problem, you will make all the necessary changes to your customer simulation in order to use your own priority queue implementation in place of the queue you used earlier.

2 Problem 1: Building and testing your own heap-based priority queue Complete the two constructors in the heap class to initialize the elements instance variable using the suitable constructors from the ZHExtensibleArrayStructure class; throw the appropriate exceptions when needed. Next, consider the peek method; the first element in the queue (if it exists) will always be at position 0. Have the peek method return the element at that position, if available (without removing it). Throw any specified exceptions. Complete the remaining methods except dequeue and enqueue. All these methods are essentially calls to the corresponding methods of the elements instance variable. Start working toward implementing the dequeue and enqueue methods by developing helper methods for them. The first three helper methods need to be able to find parent and child positions in the heap. Use your class notes to determine formulas for the position relationships between parent and child nodes in the heap. Add the following three methods and use those formulas to complete the code for these methods: protected static int parentposition(int childposition) {... } protected static int leftchildposition(int parentposition) {... } protected static int rightchildposition(int parentposition) {... } Next, add the leastposition helper method that determines the position of the smallest element among the element at currentposition, the left child element of currentposition (if it exists) and the right child element of currentposition (if it exists). Note that if the left child doesn't exist then neither does the right child, and if the right child does exist then so does the left child since the heap is always a complete binary tree. (In this and the two following helper methods, you can assume that currentposition will always be within the heap, since we wouldn t call it otherwise.) protected int leastposition(int currentposition) {... } Finally, add the following two recursive methods using the algorithms discussed in class: protected void checkupward(int currentposition) {... } protected void checkdownward(int currentposition) {... } Recall that the checkupward method works as follows: if currentposition is zero (i.e., we re at the root), it is done; otherwise, it compares the element at currentposition with its parent element. If the current element is less than the parent element, it swaps them and then calls itself recursively with the parent position passed as the new value of currentposition; otherwise, we re done. The checkdownward method is similar, but works from top to bottom: it first calls leastposition, passing it currentposition; if that call returns currentposition, it is done. Otherwise, it swaps the current element with the element at the position returned by leastpostition and calls itself recursively with that position as the new value of currentposition. Once you have these methods, you can complete the enqueue and dequeue methods. The enqueue method uses the addlast method to append the new element to the end of the heap and the checkupward method to move the element into the correct position, starting at the position the new element was added (now size 1). The dequeue method is very similar, but it

3 uses the removelast, set, and checkdownward methods instead. You should be able to figure out the logic on your own. Use the supplied HeapPriorityQueueTest.java test program to conduct your tests. Show your fully-commented class and test results to the lab instructor or TA. Problem 2: Creating and testing a max-heap-based priority queue Make a copy of your final <FOO>HeapPriorityQueue.java from Problem 1 and rename it as <FOO>MaxHeapPriorityQueue.java using your initials in place of FOO. In this problem, you are asked to make all necessary changes to the <FOO>MaxHeapPriorityQueue class so that it orders elements from highest to lowest values. This structure is known as a max-heap as opposed to the min-heap you built earlier. Use the MaxHeapPriorityQueueTest.java program to conduct your tests. Show your fully commented class and test results to the lab instructor or TA.

4 Problem 3: Modifying the simulation program to use your priority queue Have you ever wondered about that ubiquitous phrase, Your call is important to us; your call will be answered in the order it was received? They say that all customers are equal, but do they actually mean it? Do you suspect that some customers might be a little more equal than others? 1 Let's explore how data structures might help in achieving this kind of evil! Suppose a company wants to serve customers that come to them, but they want to rank customers in the order of their importance and serve the more important customers before the less important ones. To do so, the company assigns a priority rank to each customer, with lower integers indicating higher ranks. Then, if there are several customers waiting for service, the company picks the one with the lowest priority value to serve next. (If two or more customers have the same low priority, they try to choose the one that arrived first.) You are to write a simulation of this situation, based on the bank simulation from Lab 6. Copy all the necessary files from your Lab 6 folder into your folder for this lab (so you still have a working copy of the original bank simulation). Part 3.1: Modifying the Customer class Make the following changes to the Customer class: Have it implement the Comparable<Customer> interface. Add a private field priority which is an int holding the customer s priority value. Provide an accessor (getpriority) method for the field. Implement the compareto method so that it compares the priority fields and (if the priorities are equal) the arrivaltime fields of the two Customer objects; implement the equals method so that it returns true if the compareto method returns zero. The constructor should take a second int parameter to set the priority field along with the first parameter that sets the arrivaltime field. This class shouldn't need any other new methods unless you choose to override the tostring method. Part 3.2: Testing the modified Customer class Use the provided PriorityCustomerTest JUnit test class to test the methods of your Customer class. This class includes five Customer objects, an init method where the five objects are created with some objects having different priorities and some with the same priority but different arrival times, a testinitialstate method where all the accessor methods are tested and three testcomparetoreturns[ ] methods where each object is compared to all the other objects including itself. 1 Paraphrase of George Orwell, Animal Farm, All animals are equal, but some animals are more equal than others.

5 Part 3.3: Modifying the bank simulation Modify the bank simulation program so that it uses a priority queue of Customers instead of a regular queue. Use your FOOPriorityQueue class in place of the regular FOOLinkedQueue in the simulation program. Please read the remainder of this section before you start working on this part. The simulation should now take another initial input from the user representing the largest possible priority value as an integer. When the program creates a new customer object, it should randomly generate a priority value that is an integer between zero and the largest possible priority value specified as input to the simulation. Please note that low priority values indicate higher priority customers who are to receive service before customers with high priority values. This approach works well when using a min-heap priority queue class because it sorts items by their natural ordering so that customers with lower priority values receive service before customers with higher values. When you display simulation results, you need to display customers with their ids, arrival times, and priority values; you also need to display whether they received immediate service or entered the wait queue. In addition, display the priority value of customers left in the queue at the end of the simulation. Below are a couple of input/output scenarios (with all details of the simulation printed) for you to emulate. Notice how customers with lower priority values receive service before people with higher priorities values. Also, notice how customers with the same priority values receive service in order of arrival time. Try to create scenarios in which all customers get prompt service, even when they have a wide range of priorities; try to create other scenarios in which some low-priority customers wait an unacceptably long time for service or perhaps never get served. Vary the number of priority levels, the arrival rate and the number of tellers to get different scenarios. For the most part, you are on your own here in terms of how to make the required changes.

6 SCENARIO I

7

8

9 SCENARIO II

10