01
CS A 220, Fall 2003
[an error occurred while processing this directive]
Programming Assignment
1
01
Due:
8pm, Tuesday 16 September 2003
8pm Thursday, 11 September 2003
Please make sure you adhere to the policies on
academic integrity.
Please see the general programming webpage for details about
the programming environment for this course, and specifically for
directions in how to submit your programming assignment electronically.
The files you need for this assignment can be
downloaded here.
Contents:
Web browsers commonly allow you to navigate through a "history" of
web pages which have previously been visited. Example 4.1 of the
textbook suggests that a stack ADT might be used to maintain this
history, allowing the user to step "back" to get to the previously
visited sites. If a web browser could hold infinitely many entries in
its history, then this analogy might be valid. In reality, there may
generally exist some fixed limit on the size of the history.
If the history must exist with a fixed maximum capacity, one approach
may be to use the ArrayStack implementation of a Stack, as
given in Code Fragment 4.4-4.5 of the text. In the case where an
item is pushed onto an already full stack, this implementation throws
up its hands (i.e., throws an Exception).
This is not how your Web browser behaves. If it only has room to save
50 pages in its history and yet you visit more pages, it will
make room in the history for a new page by throwing away the page
which is on the very bottom of the history (i.e., the least recently
visited page). The formal Stack interface does not help, as
it gives us no way to directly access or remove the object on the
bottom of the stack.
In this assignment, we define a new ADT which we call a BoundedStack. The interface for a BoundedStack is very similar to
the interface given for a Stack. However in the case when the
capacity is exhausted, a call to push will result in the
placement of the new page at the expense of the loss of the least
recently accessed page. The interface is provided online in a file
BoundedStack.java.
/**
* Interface for a BoundedStack: a collection of objects
* that are inserted and removed according to the
* last-in first-out principle, but with overflow handled
* by the removal of the least-recently accessed item.
*
* @author Michael Goldwasser
* @see BoundedStackEmptyException
*
* Any class which implements this interface should allow
* a constructor which takes an integer parameter specifying
* the maximum number of elements which the stack will hold
* e.g.,
* public class MyBoundedStack implements BoundedStack {
* public MyBoundedStack(int maximum) {
* // set the maximum stack size
* }
* }
*/
public interface BoundedStack {
/**
* @return number of elements in the stack.
*/
public int size();
/**
* @return true if the stack is empty, false otherwise.
*/
public boolean isEmpty();
/**
* @return top element in the stack.
* @exception BoundedStackEmptyException if the stack is empty.
*/
public Object top() throws BoundedStackEmptyException;
/**
* Insert an element at the top of the stack making room, if
* necessary, by removing the item at the bottom of the stack.
* @param element element to be inserted.
*/
public void push (Object element);
/**
* Remove the top element from the stack
* @return element removed.
* @exception BoundedStackEmptyException if the stack is empty.
*/
public Object pop() throws BoundedStackEmptyException;
}
You should submit the following files,
BoundedStackA.java, BoundedStackB.java, readme and inputfile,
as detailed below.
The files you need for this assignment can be
downloaded here.
The assignment is worth 10 points. Eight points will be
awarded based on our own evaluation of your assignment and the readme
file. One additional point will be awarded fractionally based on how
well your program performs on other students' test inputs. The final
point will be awarded fractionally based on how well your test input
fools other students' flawed programs.
When dealing with an array in a circular fashion, there are many
possible ways for adjusting indicies as they "wrap around" the ends of
the array. The text chooses to use modular arithmetic (the "%"
operator in Java).
Further discussion of this topic can be found in the general programming webpage.
CS A 220, Fall 2003
Michael Goldwasser
goldwamh nbsp; @ slu.edu
Last modified: 11 September 2002
[an error occurred while processing this directive]