03/29/2004. A dispenser has three essential features: adding, removing, accessing. Dispensers

Size: px

Start display at page:

Download "03/29/2004. A dispenser has three essential features: adding, removing, accessing. Dispensers"

Cori Owen
5 years ago
Views:

1 Dispensers stacks queues priority queues Dictionaries A dispenser is a container that restricts access to its elements. Only one element in the container can be accessed or removed. This element is called the current element. A dispenser has three essential features: adding, removing, accessing. stack: a dispenser in which the current element is the container element most recently added to the container. Also known as last-in first-out, or LIFO lists. 1

2 The features get, add, and remove traditionally are named top, push, and pop. * This type model a stack, which is a * dispenser adhering to a last-in/first-out discipline. public interface Stack<Element> { * This Stack contains no elements. public boolean isempty (); *The element of this Stack that was most recently added. *require: *!this.isempty() public Element top (); *Add the specified element to this Stack. *require: element!= null *ensure:!this.isempty() public void push (Element element); *Remove the element of this Stack that was most recently added. *require: *!this.isempty() public void pop (); *Remove all the elements from this Stack. *ensure: *this.isempty() public void clear (); <<interface>> Stack<Element> AbstractStack<Element> LinkedStack<Element> LinkedList<Element> 2

3 <<interface>> Stack<Element> LinkedList<Element> In an array-based implementation: LinkedStack<Element> void push(element e) this.add(o,e); This permits pushing and popping to be done in constant time. In a linked implementation: queue:a dispenser in which current element is container element least recently added. Again, pushing and popping can be done in constant time. Also known as first-in first-out, or FIFO lists. Dispenser features are front, append, and remove; append and remove traditionally are named enqueue and serve. 3

4 /* * * Dispenser adhering to a first-in/first-out discipline. public interface Queue<Element>{ * This Queue contains no elements. public boolean isempty(); * The element of this Queue that was least recently added. public Element front(); * Add the specified element to this Queue. * element!= null public void append(element element); * Remove the element of this Queue that was least recently added. public void remove(); * Remove all the elements from this Queue. * this.isempty() public void clear(); If a LinkedList maintains references to both ends of the list, elements can be added to either end in constant time. If we attempt to use the class BoundedList to implement queues, we encounter a problem: Adding and removing elements requires shuffling the list, and takes linear time. Constant time deletes can be done only from the front of the list. Therefore, we make the front of LinkedList the front of the queue. An adapter class can be defined easily in much the same way as was done for Stacks. 4

5 Viewing an array as a circular structure permits all queue methods to operate in constant time. The queue occupies a set of contiguous array elements, and circulates through the array as items are added and removed. The relationship between the two indexes is the same for both the full queue and the empty queue. (rear+1)%n == front * Circular array implementation of the interface Queue class CircularQueue<Element> { private Object[] elements; private int front; // index of the front Queue item private int rear; // index of the rear Queue item private int size; // size of the Queue * Create a CircularQueue with specified maximum size. maxsize >= 0 this.isempty() public CircularQueue (int maxsize) { elements = new Object[maxSize]; size = 0; front = 0; rear = maxsize-1; * The maximum size of this Queue. this.maxsize() >= 0 public int maxsize () { return elements.length; 5

6 * The number of elements in this Queue. this.size() >= 0 && this.size() <= this.maxsize() public int size () { return this.size; * This Queue contains no elements. public boolean isempty () { return this.size == 0; * This Queue contains a maximum number of elements. public boolean isfull () { return this.size == elements.length; * The element of this Queue least recently added. public Element front () { return (Element)elements[front]; * Add a new element to this Queue. element!= null &&!this.isfull() public void append (Element element) { rear = next(rear); elements[rear] = element; size = size+1; * Remove the element of this Queue that was least * recently added. public void remove () { front = next(front); size = size-1; * Remove all the elements from this Queue. this.isempty() public void clear () { size = 0; front = 0; rear = elements.length; * A String representation of this Queue. public String tostring () { String s = "["; if (size > 0) { s = s + elements[front].tostring(); int i; for (i = front; i!= rear; i = next(i)) s = s + ", " + elements[next(i)].tostring(); s = s + "]"; return s; * The next index, mod length of the array. private int next (int index) { return (index+1) % elements.length; priority queue: a dispenser in which the current element is a largest container element with respect to some given ordering. A largest item with respect to the ordering is referred to as the highest priority item. The dispenser features highest, add, and remove; add and remove are traditionally named enqueue and serve. 6

7 /* * * Dispenser adhering to a first-in/first-out discipline. public interface PriorityQueue<Element>{ * This Queue contains no elements. public boolean isempty(); * An element of this PriorityQueue with highest priority. * for each element e in this PriorityQueue *!this.priority().inorder(e,this.highest()) public Element highest(); * The priority used to order this PriorityQueue. public Order<Element> priority (); * Add the specified element to this Queue. * element!= null public void add(element element); * Remove the element with the highest priority of this Queue public void remove(); * Remove all the elements from this Queue. * this.isempty() public void clear(); A way to implement a priority queue is with the class OrderedList. If we base a PriorityQueue implementation on either an array-based or linked implementation of OrderedList, add will be linear highest and remove can be made constant time operations With an array-based implementation, we can find an element s position in log n time.! "# $ "% & ' ( ") * + dictionary: a container in which the elements are accessed by key. + Dictionary entries have a key and an associated value. i.e. a key-value pair. Example: English dictionary: an English word is the key, and the definition is the value. + We can also consider the key to be an attribute of the entry, rather than a separate component. Example: telephone directory has name (key), address and number. 7

8 ! "# $ "% & ' ( ") * # % & $ A key must be provided to access or delete an item. We assume keys are unique. * Container in which elements are uniquely accessed by key. public interface Dictionary<Key, Element>{ * This Dictionary contains no entries. public boolean isempty(); * element of this Dictionary associated with the specified key. * null if there is no entry with the specified key. public Element get (Key key); * Add an entry with specified key and value to this Dictionary. * If this already contains an entry with the specified key, * value associated with this entry is replaced by specified value. public void add( Key key, Element value); * Remove the entry this.get(key) from this Dictionary. If this Dictionary * does not contain an entry with the specified key, this method does nothing. public void remove(key key); * Remove all the entries from this Dictionary. * this.isempty() public void clear(); We can build straightforward implementations of dictionaries with a List whose elements are key-value pairs. The method get and remove can simply search the List to locate the item with the given key. java.util defines an interface Map that serves as a superclass for dictionary variants. 8

ITI Introduction to Computing II

ITI Introduction to Computing II ITI 1121. Introduction to Computing II Queues ArrayQueue Marcel Turcotte School of Electrical Engineering and Computer Science Version of March 10, 2014 Abstract These lecture notes are meant to be looked