CS 10, Fall 2015, Professor Prasad Jayanti

Transcription

1 Problem Solving and Data Structures CS 10, Fall 2015, Professor Prasad Jayanti Midterm Practice Problems We will have a review session on Monday, when I will solve as many of these problems as possible. To prepare for the test, you should attempt to solve these problems on your own before Monday. 1. What is the distinction between an ADT and its implementation? What features does Java provide to realize the distinction between an ADT and its implementation? What is abstraction? What features does Java provide to realize abstraction? 2. Consider an ADT whose state is a collection of integers. The ADT supports two operations, specified as follows: /* adds e to the collection of integers. */ public void insert(int e); /* if e is present in the collection, one instance of e is removed from the collection. */ public void delete(int e); Give an efficient implementation of this ADT. Make sure that your implementation is as efficient as possible both in terms of running time and in terms of space. Hint: Exploit the fact that the above two operations are the only operations that the ADT supports. Consider an ADT whose state is a collection of integers. The ADT supports two operations, specified as follows: /* adds e to the collection of integers. */ public void insert(int e); /* if the collection is nonempty, returns the smallest integer in the collection; else returns -1 */ public int minimum(); Define a class that efficiently implements this ADT. State the running times of your methods in asymptotic notation. (It is not enough for the implementation to be correct: very little credit is awarded unless the implementation is as efficient as possible both in terms of running time and in terms of space.) 3. Consider the following interface for a stack ADT. public interface StackADT<E> { /* pushes e on to the top of the stack. */ public void push(e e) 1

2 /* if the stack is empty, returns null; otherwise, removes and returns the top item of the stack.*/ public E pop() Let us say that our goal is to implement the StackADT using the ListADT, where you should assume that the ListADT E supports only the following methods: addfirst(ee), which adds the item e to the front of the list addlast(ee), which adds the item e to the rear of the list isempty(), which returns true if the list is empty, and false otherwise removefirst(), which is legal to invoke if and only if the list is nonempty and, when legal, removes and returns the first element of the list removelast(), which is legal to invoke if and only if the list is nonempty and, when legal, removes and returns the last element of the list Assume that the class ListImpl<E> implements ListADT E with the following performance: addfirst(ee) runs in O(1) time addlast(ee) runs in O(1) time isempty() runs in O(1) time removefirst() runs in O(1) time removelast() runs in Θ(n) time, where n is the length of the list Write a class StackImpl E that implements StackADT E using the class ListImpl E such that all operations of run in O(1) time. 4. In the class I explained how to implement a queue using a circular array and allocating a bigger array whenever we run out of space in the current array. Using these ideas, write a class that implements a queue, where the items in the queue are known to be integers. 5. Suppose that we have a class S to maintain a sequence of integers, where we represent the sequence using a singly linked list with sentinel. Each node of the linked list belongs to an inner class E (of S) that has two public instance variables data (of type int) and next (of type E). Assume that the class S has a single instance variable sentinel that references the sentinel node. For the class S, write the method public void removefirstoccurrence(int x) that removes the first occurrence of x from the sequence (maintained by S). In asymptotic notation, what is the run time of your method? 6. Redo the previous problem assuming that the designer of the class S changed her mind and represented the sequence using a singly linked list without a sentinel. 7. A complete binary tree is a binary tree where all leaves have the same depth. In the class that implements the BinaryTree methods, write the method public boolean iscompletebinarytree() that returns true if and only if this (i.e., the tree on which the method is invoked) is a complete binary tree. 2

3 8. Given a binary tree T and a node x in the tree, consider the path from T s root to the node x. This path is a sequence of edges, some of which are left edges and the others right edges (note that this sequence is empty if x is T s root). Each time a left edge is immediately followed by a right edge or a right edge is immediately followed by a left edge, we say the path takes a turn. Thus, the path can take zero or more turns. For example, the path LLLL takes 0 turns, the path R takes 0 turns, the empty sequence takes 0 turns, and the path LLLRRRLLRL takes four turns. If T is a tree and l is a leaf of T, et n(l, T ) denote the number of turns that a path from T s root to l takes; and let n(t ) denote the sum, over all leaves l of T, of n(l, T ). In the class that implements the BinaryTree methods, write the method public int sumofturnsofleaves() that returns n(t ), where T is this (the tree on which the method is invoked). 9. Why is the distinction between an ADT and its implementation important? Be sure you know about inheritance, polymorphism, and dynamic binding. 10. Consider the following two class definitions: // *****************Definition of the class CourseGrade************************ public class CourseGrade { private String coursename; private int points; // name of the course // regular points earned in the course // Constructor, takes the name and points public CourseGrade (String name, int pts) { coursename = name; points = pts; // increases the points by n public void increasepoints (int n) { points = points + n; // returns points public int getpoints () { return points; // returns if the grade should be A or not public boolean gota() { return (getpoints() >= 93); // prints points public void printpoints() { System.out.println("Points = " + points); // end of the class CourseGrade Turn to the next page for the definition of the second class. 3

4 // ****************Definition of the class CS25Grade*********************** public class CS25Grade extends CourseGrade { private int extracredit; // extra credit points earned in CS 25 // Constructor, takes course name, regular points earned, and // extra credit points earned public class CS25Grade (String name, int regpoints, int ecpoints) { // increases regular points by m and extra credit points by n public void increasepoints (int m, int n) { // overrides the inherited method and returns total points earned in // the course, i.e., the sum of regular points and extra credit points public int getpoints () { // prints total points earned, overrides the inherited method public void printpoints() { System.out.println("Points = " + getpoints()); // end of the class CS25Grade NOTE: When answering the following questions, you are not allowed to introduce any new instance variables or methods in either of the above two classes. (a) Of the two classes defined above, which is the superclass and which is the subclass? (b) Based on the code and the accompanying comments given above, fill in the code for the constructor of the CS25Grade class (in the space provided under the header of the constructor). (c) Fill in the code for the getpoints() method in the CS25Grade class. (d) Fill in the code for the increasepoints(int m, int n) method in the CS25Grade class. (e) What does the following code print? Briefly explain your answer. (Notice that g is declared to be a reference to CourseGrade but is assigned a reference to CS25Grade.) 4

5 CourseGrade g = new CS25Grade("CS 25", 90, 5); if (g.gota()) System.out.prinln("I got A"); else System.out.println("I did not get A"); 11. This problem requires you to write an applet that can respond to mouse events and timer events. Most importantly, it requires you to think carefully about what instance variables to use in the applet and how to properly update them as events occur. Here is the description of how your applet must behave. When the applet first comes into being, it should display nothing. When the user clicks on the applet, it starts a clock and displays the value of this clock in seconds. This display is simply a number, which is updated every second. For example, 10 seconds after the clock is created (in response to the user s first click on the applet), the number displayed will be 10. When the user clicks on the applet the second time, your program should create a second clock and start displaying the values of both clocks. The value of the second clock is simply the number of seconds since its creation. For example, in a scenario where the second click comes 20 seconds after the first click, immediately after the second click the applet s window should display As before, the display should be updated each second, showing the current values of the two clocks. For instance, in the previous example, 50 seconds after the second clock is born, the display will show If there are already two clocks when the user clicks on the applet window, the click should have no effect (i.e., a third clock is not created). When the mouse exits the applet window, the display should go blank, i.e., it should show nothing. (From a conceptual point of view, any clocks that were there until then simply die ). Later, if the user clicks on the applet once more, a clock will be born again, starting once more with a value of 0. As before, a second click will give birth to a second clock, but the subsequent clicks will have no effect. Thus, at any point in time, the applet window displays the values of two clocks, or one clock, or none at all. Based on the description above, write your applet. Here is some useful information that you already know, but I am repeating to help you recall. The constructor for the Timer class takes two parameters an integer and a reference to an ActionListener object. For instance, if r is a variable that holds a reference to an ActionListener object, the call new Timer(100, r) creates a timer object with two guarantees: (i) once the timer is turned on, it goes off every 100 milliseconds, and (ii) every time the timer goes off, r.actionperformed() gets called. The Timer class supports start(), stop(), isrunning() methods. You might need only some of these methods. You can display a string s on the applet window starting at point (x, y) using the call page.drawstring(s, x, y) You must call repaint() after you make changes to the representation of what appears in the Applet window. 5