Homework 2: Imperative Due: 5:00 PM, Feb 16, 2018

Transcription

1 CS18 Integrated Introduction to Computer Science Fisler, Nelson Contents Homework 2: Imperative Due: 5:00 PM, Feb 16, Double the Fun with Doubly-Linked Lists 3 2 SeatMap 6 3 Memory Maps for Lists and Mutation Google Sheet Tips (if needed) Appendix 11 Objectives By the end of this homework, you will know: ˆ What imperative programming is, and what kinds of problems it can solve By the end of this homework, you will be able to: ˆ Implement doubly-linked lists from soup to nuts! ˆ Determine when to use a for loop vs. a while loop How to Hand In For this (and all) homework assignments, you should hand in answers for all questions. For this homework specifically, this entails answering the Double the Fun with Doubly-Linked Lists and Seatmap questions. The Memory Map question will ask you to submit information through Google Forms. In addition to handing in your answers for Memory Map through Google Forms, you must submit a.txt file with a link to your Google Slides containing your answers to the graded portion of Memory Map. Be sure that you leave no identifying information (like name, login, etc) in your slides. You must submit your solutions in both places, the.txt file on the department machines and the Google Form in the PDF. In order to hand in your solutions to these problems, they must be stored in appropriately-named files with the appropriate package header in an appropriately-named directory. Begin by copying the source code (/course/cs0180/src/hw02/src/*.java) from the course directory to your own personal directory. That is, copy the following files from /course/cs0180/src/ hw02/src/*.java to /course/cs0180/workspace/javaproject/src/hw02/src:

2 ˆ IList.java containing public interface IList<T> ˆ AbsList.java containing public abstract class AbsList<T> ˆ IListTest.java containing public class IListTest ˆ Item.java containing public class Item ˆ Order.java containing public class Order ˆ Shop.java containing public class Shop ˆ Main.java containing public class Main Do not alter these files! After completing this assignment, the following solution files should be in your /course/cs0180/workspace/javaproject/sol/hw02/sol directory, all as part of the hw02.sol package: ˆ Double the Fun with Doubly-Linked Lists IExtList.java, containing public interface IExtList<T>, which extends IList <T> with the methods get, remove, and reverse. DoublyLinkedList.java containing public class DoublyLinkedList<T>, which extends AbsList<T> and implements IExtList<T>. A file IExtListTest.java containing public class IExtListTest, which thoroughly tests your doubly- linked list implementation. ˆ SeatMap SeatMap.java, containing public class SeatMap, which implements the methods bookseats, findblock1, findblock2, findblock3, findblock4, and findblock. SeatMapTest.java, containing public class SeatMapTest, which thoroughly tests your SeatMap implementation ˆ Memory Map for Lists and Mutations A.txt file containing the link to your Google Slides answer for the graded portion of the assignment. To hand in your files, navigate to the /course/cs0180/workspace/javaproject/ directory, and run the command cs018 handin hw02. This will automatically hand in all of the above files. Once you have handed in your homework, you should receive an , more or less immediately, confirming that fact. If you don t receive this , try handing in again, or ask the TAs what went wrong. 2

3 Regarding Exceptions In Java, the Exception class is used to indicate that something has gone wrong or an abnormal condition has occured. These are widely used, and you will see more detail about them in future lectures. For this assignment, there are a few places where we want you to throw exceptions. throw is the keyword we use when talking about exceptions, and we will demonstrate an example below. Consider a problem we might run into in the DoublyLinkedList class. We start with an empty list, and say a user wishes to remove the first item from this empty list. What can we do? The type signature says that we have to return some item, but we don t have any item to return. We also don t want to return some random item, because we didn t remove it. Additionally, it would be bad practice to return null. The solution here is to throw an Exception! This tells the user that they ve done something wrong, like removing an item from an empty list. Let s see what this would look like in an example. Here, we are going to throw a Java built in exception called the NoSuchElementException We can start in IExtList.java, since that is where we are declaring the removefirst() method. First, we put import java.util.nosuchelementexception; at the top of your IExtList file. This way, your code will compile. The declaration for the method should look like the following: /** * Removes the first item from the list. If the list is empty, throws an * exception. * the item that was removed * NoSuchElementException if the list is empty */ public T removefirst() throws NoSuchElementException; First, we have in our comments - this is part of proper commenting. Next, note that our method declaration also includes the line throws NoSuchElementException. This is required, and lets Java know that this class might throw that exception. We can now move into our DoublyLinkedList file. As before, we import java.util.nosuchelementexception. Then, when we override the removefirst() method, we don t need to add throws NoSuchElementException - that is already captured by the IExtList. Then, when we reach a point in our code where we think it is appropriate to throw this exception we do that by writing throw new NoSuchElementException ("message"). The message should be informative as to why the error was thrown. You should throw exceptions whenever a method is called in error. For example, calling any method that gets or removes an element on an empty list should throw a NoSuchElementException with an informative error message telling the user that the list is empty. When you are conducting testing for your DoublyLinkedList class, you can use the checkexception () method to test your exceptions. Feel free to look at IListTest in the source code for an example of this. 3

4 Problems 1 Double the Fun with Doubly-Linked Lists As a computer scientist, you will often be presented with a problem where it is easy to determine what functionality you require from a piece of code you are writing, but you do not yet know the best implementation. As you ve learned in CS 17/18, this situation calls for an interface. That way, you can decide on one implementation now, and later you can switch it out for a newer and better one without impacting your code base. In class you saw how to implement a list interface using linked lists. In the linked list implementation, each node refers to the next node in the list, and the list itself maintains references to the start and end of the list. A doubly-linked list is one in which each node refers to both the next node and the previous node, as shown in Figure 1. Can you imagine ways in which this implementation might have advantages over a singly-linked list (which we have seen in lecture)? A doubly-linked list maintains the following invariants: 1. When the linked list is empty, ˆ start is null ˆ end is null 2. When the linked list is nonempty, ˆ start refers to the first node of the list ˆ end refers to the last node of the list ˆ if the list contains exactly one node, then both start s and end s next and prev fields are null ˆ if the list contains more than one node, then only end.next and start.prev are null; no other node s next or prev fields are null Figure 1: The doubly-linked list (12, 99, 37). The goal of this problem is to extend the IList interface and the DoublyLinkedList class to include get, remove, reverse, removefirst, and removelast methods: ˆ The get method takes as input an index, say i, and returns the ith item in the list. You should assume 0-indexing, like in arrays, where the first item in the list has index 0. If there is an index that is too large, or if the list is empty, you should throw an exception. ˆ The remove method takes as input an item, the first instance of which it proceeds to remove from the list. It returns a boolean indicating whether or not the remove operation was successful: i.e., was the item successfully found in the list and removed or not? 4

5 ˆ The reverse method reverses the order of the items in the list that it is called on. It should take O(n) time and O(1) space (it should not create any new lists), where n is the number of items in the list. ˆ The removefirst method removes the first item in the list and returns it. If there are no items in the list, it throws an exception. ˆ The removelast method removes the last item in the list and returns it. If there are no items in the list, it throws an exception. What are the signatures of these five methods? That is, what should their arguments and return types be? Task: Extend the given IList interface to a new interface called IExtList that requires these five methods. Think about how this interface IExtList might be useful. Right now, we only are having you implement DoublyLinkedLists, but how might having this interface be important if you were to design a SinglyLinkedList class (or, more generally, a hierarchy of lists) as well? Task: Write a doubly-linked list class, DoublyLinkedList, with a static nested Node class. Your doubly-linked list class should implement your IExtList interface, meaning it should implement all the methods we implemented in class for (singly-)linked lists, as well as the ones presented above. Furthermore, your DoublyLinkedList should extend the AbsList abstract class provided in the support code. This class, given an iterator, implements tostring and equals. Consequently, if your DoublyLinkedList extends this class, then once you write an iterator (which you must, because IList, and hence IExtList, extends Iterable), you will inherit implementations of tostring and equals for free. Wow! Object-oriented programming is powerful! Task: Write an iterator for your DoublyLinkedList. Hint: You should model your solution after our implementation of singly-linked lists, found in Lecture 7. If you need to report an error, throw a NoSuchElementException, or an IndexOutOf- BoundsException, as relevant. As usual, you must exhaustively test your DoublyLinkedList methods! However, because we are working with mutable data, you should create a setup method in your test class. A setup method takes in nothing and returns an object that you will perform tests on; in this case, a DoublyLinkedList. You know the contents of this list, because the method makes a list, exactly as you want, and returns it. This allows you to safely perform tests. We use setup methods because we want our tests to pass regardless of what order the test methods are run in. If we were running tests on a DoublyLinkedList that was a global variable in our test class, switching the order of our testadd and testremove methods would be disastrous. But if we create a new DoublyLinkedList in each test method, we won t run into any issues! Here s an example of what a setup method could look like: /** * A setup method for a basic list a basic linked list */ public IExtList<Integer> setupbasiclist() { IExtList<Integer> dll = new DoublyLinkedList<Integer>(); 5

6 } dll.addfirst(1); dll.addfirst(5); dll.addfirst(10); return dll // A doubly linked list with elements 10,5,1, in that order // A method to test get public void testget(tester t) { IExtList<Integer> testlist = setupbasiclist(); t.checkexpect(testlist.get(0), 10);... } The contents of this list are up to you, but you should make several setup methods so that you can test methods such as remove and reverse. Remember to check edge cases! Task: Write a class to exhaustively test your DoublyLinkedList methods, including those methods found in the iterator (except the methods given to you in source code). Be sure to use at least one setup method to create DoublyLinkedLists for testing. Just for Fun: Can you figure out how to implement reverse in constant time? Consider trading off space for time. 2 SeatMap Word has gotten out about your CS skills, and as such, you have been contracted to help design a system for booking seats. Specifically, you are to design a SeatMap class. The constructor for this class should take in one parameter, an integer specifying the number of seats in the row as a whole. The class itself should contain the following: ˆ A single array of booleans, which represents the seat availability, where false represents a taken seat, and true represents an empty seat. Upon constructing a SeatMap object, every index in this array should be true (i.e. the row of seats should be entirely empty). ˆ The bookseats method, which takes the number of consecutive seats to reserve and the starting seat number and sets all the seats to reserve to false in the array. This method should assume that the seats it is supposed to book are open. ˆ The findblock method, which takes the number of (consecutive) seats that someone wants to find and a seat number from which to start searching. The method returns either (a) a seat number from which there are the requested number of consecutive seats available, or (b) throws an exception if there are no blocks of open seats at the requested size (more on this later). Task: Create the SeatMap.java class with the appropriate constructor, and implement the bookseats method. As you begin to think about the problem, you come to realize that there are many ways in which you can implement the findblock method, some better than others. You decide to start small, and go with the first method you can think of. 6

7 Task: In your SeatMap class, create the findblock1 method, which uses 2 for loops to find the the requested blocks of seats one to iterate across each seat, and another to iterate starting from a given seat, and checking each consecutive seat to see if it s open. For this part, don t use break, and don t worry about efficiency. Here, and for all future findblock methods, you don t have to worry about bad inputs (like a negative start seat). You successfully complete findblock1, but you have some reservations. In particular, you feel that this is inefficient. Despite the fact that the inner loop might find an occupied seat, you continue to iterate, which is wasteful. You decide to step it up, and make an even faster version. Task: Create a helper method checkseats, which takes the seat to start checking from and the number of seats to look for. It then returns a boolean indicating whether the requested number of seats is available from the given start seat. This method should return as soon as an occupied seat is found (i.e, as soon as you know that you can t find a block of the appropriate size starting from a given seat). Write this function without using loop operators, that is, in the CS 17 style of recursion. Task: Create a method findblock2, which takes the implementation of findblock1, but replaces the inner loop with your newly created checkseats method. You are making good progress, but feel weird that you re doing recursion in a homework about imperative programming. You decide a change needs to be made. Task: Create a helper method checkseats2, which performs the same task as checkseats (and uses the same type signature), but instead uses a while loop, rather than recursion. Task: Create a method findblock3, which takes the implementation of findblock2,but replaces checkseats with checkseats2. You are satisfied now that you are back in the land of imperative programming (though you do note that you haven t changed your efficiency much, as recursion is not necessarily more expensive given modern compilation techniques). You determine that there is another speedup you can make to your program, this time with the outer loop. This outer loop still checks seats that can t work, as it checks every seat. However, since you know the locations of filled seats, you can use this information to skip checking some seats. For example, if you just checked a seat and it didn t work, you can be sure that the seat next to it also won t work, as it is either occupied, or it is unoccupied, but is also eventually going to be broken up by the later occupied seat which caused the previous seat to fail (Figure 2). Task: Create a method findblock4, which does the following: ˆ Takes the logic from checkseats2 (that is, a while loop with stopping at the first occupied seat), and puts it in an inner loop ˆ Creates an outer loop with a while, that uses the info from the inner loop to cleverly skip over seats that don t need to be checked You are now happy that you have become efficient in both your outer and inner loop, and as such, have become an even better student of imperative programming. Task: Create the findblock method, which simply makes a call to your findblock4 method. Task: When all the seats in a row are filled or there are no consecutive seats available, you want to throw an exception explaining that there are no more seats available. When you reach a point in your solution when there are no seats available or not enough consecutive seats, throw a 7

8 Figure 2: Suppose you are looking for 3 consecutive seats. Seat 0 is occupied so you move onto seat 1. You check seats 1, 2, and 3, and find that seat 3 is occupied. Seat 1 will not work. After checking seat 1, you can skip over 2 and 3 (directly to seat 4), since you know seats 2 and 3 will not work either X X NoSuchElementException (throw new NoSuchElementException("No Seats Available")). When you are conducting testing for your SeatMap class, you can use the t.checkexception() method to test your exceptions. Task: Test all of your methods, and test them exhaustively. Additionally, since we are working with mutable data, be sure to create a setup method to use between your tests, the same way you did for DoublyLinkedList testing. 3 Memory Maps for Lists and Mutation For this final task, we want you to work with memory maps for linked lists in the presence of mutation. We also want to ask some questions about your general understanding of this concept (to help us assess the effectiveness of the way in which we are covering this material). Some tasks on this part of the assignment ask you to answer questions in Google forms. The forms questions are for our course diagnostics, and do not have incorrect answers for which you would lose points. Your grade for the form questions will be based on having answered the questions. Despite these not being graded for content, please to answer honestly as this is part of our assessment of whether CS18 activities are being effective. Task: Before you look at the rest of the problem, visit the following URL and answer the multiplechoice question in the form. Thor has decided to retire from his role as King of Asgard and open up a small online shop, which he s called the sthore. His shop maintains a catalog, which is a LinkedList of items, each with a description and price, and a LinkedList of open orders, each with the name of a customer and a LinkedList of items that they have ordered. You can find the source code for this under catalogs in your hw02 src directory. The shop already has a few items and open orders for you to manage! The shop has written two different functions to update the price of an item in the catalog; they are called updateprice1 and updateprice2. 8

9 Task: Inside Main.java, you ll find a sequence of calls to these update methods. Without running the program or tracing it in detail, predict what you believe the openorders will contain after the sequence of price updates. Record your answer in the form at the following url (this is again a diagnostic question for us): Task: (Graded for Correctness) Now, we want you to show us the contents of the heap (the objects area of the memory map) at each Memory Point that is marked with a comment in Main.java. To make this easier, we ve set up an initial objects heap with most of the objects and known names already filled in. You will copy and edit our initial diagram (within a Google Slides presentation) to produce your answers. Here are the detailed instructions for doing so: 1. Navigate to the following Google Slides page and make a copy of it (File Make a copy) Set the sharing on your copy so that anyone with the link at Brown can view (you will share the link with the staff at handin, but obviously don t distribute or publicize your link beyond the handin process, as that would violate the collaboration policy). 3. There are three slides: the first has some template objects (for LinkedLists and Items), and the second and third are identical copies of the initial object heap. The template slide has two templates for LinkedLists, one with the item field first and one with the next field first. Use whichever one is more convenient for connecting arrows to items in your diagram. 4. Edit slide 3 to create the object heap diagram for the first memory point (slide 2 is there as a backup in case you need a fresh copy on which to start over). Duplicate that diagram to create the next one, and so on. You should end up with 6 slides: the template, the backup, and one for each of the four memory points in Main.java (we will grade only the last four). As you can see in the starter slide (which you should have duplicated), we have already filled out some objects for Memory Point 1 in Main.java. Edit the duplicate so that the slide shows the object heap at Memory Point 1. Make it so that everything in the heap is represented in this slide and that this slide only contains things in the heap. This might include filling in some objects, removing objects, adding objects, moving arrows, adding arrows, removing arrows, etc.. We have started filling in Tony Stark s order as well as the openorders linked-list as examples of the kinds of connections we are expecting. We have started filling in the Shop object for you as well. Complete this object as well. Since this object s fields might span a lot of space, please change the dash of the arrows to make them easier to differentiate from more local arrows. When you have finished with the first memory point, duplicate this slide and start working on the next memory point. Please highlight the differences between two consecutive slides (memory points) by bolding the names of any fields that change in any object and by significantly thickening any arrows that change. If you change a field that has a value rather than an arrow, change the value and put it in bold (you can change the value by clicking on the current value, which brings up a box with the text). 9

10 To handin, fill out the following (final) Google form. The contents of your slides diagram will be graded, but the questions are diagostic for us. Additionally, be sure to make a.txt file with a link to your Google Slides, and turn that in with the rest of your code on the department machines. Make sure there is no identifying information (like name, login, etc) in your slides. 3.1 Google Sheet Tips (if needed) To create links/arrows between fields and objects in the map, you will use the line tool. You can click the drop-down arrow next to the line icon for line-drawing options the Curved Connector, Elbow Connector, and Arrow tools work well when items are close together. For objects that are farther apart or for areas that are particularly dense with arrows, the Curve tool might be better. Furthermore, if an arrow intersects many other others or covers a lot of space, feel free to change its color and its dash to differentiate it from others. To add more objects, either copy and paste from the template slide or duplicate already existing objects with Ctrl+D or Command+D. To delete objects, select them by dragging your mouse over their area. If you accidentally select too many things, click the things you do not want to select while holding Ctrl (or Command). You are welcome to practice with the line tool on the template slide, if you wish. Notice how you can change the color (select the pencil icon, not the bucket icon), the endings, the dash, and the thickness of the line. Knowing how to do these will be necessary to complete the assignment. 10

11 4 Appendix Here is a class diagram that depicts the structure that the source files and your solution files should have after you finish implementing doubly-linked lists: public interface IList extends Iterable<T> public boolean isempty(); public T getfirst(); public T getlast(); public void addfirst(t item); public void addlast(t item); implements extends public abstract class AbsList public String tostring(); public boolean equals(object o); public interface IExtList public T removefirst(); public T removelast(); public boolean remove(t item); public void reverse(); public T get(int index); extends implements public class DoublyLinkedList protected static class Node<S>; public DoublyLinkedList(); public boolean isempty(); public T getfirst(); public T getlast(); public void addfirst(t item); public void addlast(t item); public T removefirst(); public T removelast(); public boolean remove(t item); public void reverse(); public T get(int index); public Iterator<T> iterator(); Please let us know if you find any mistakes, inconsistencies, or confusing language in this or 11

12 any other CS18 document by filling out the anonymous feedback form: courses/cs018/feedback. 12