1

Stacks (Continued) and Queues

• Array Stack Implementation• Linked Stack Implementation• The java.util.Stack class• Queue Abstract Data Type (ADT)• Queue ADT Interface• Queue Design Considerations• The java.util.Queue interfaceReading L&C 3rd : 4.4, 4.6, 5.1 2nd: 7.1-7.8

2

Array Stack Implementation

• We can use an array of elements as a stack

• The top is the index of the next available element in the array

top Object of type T

Object of type T Object of type T nullT [ ] stack

3

Array Stack Implementation

• push – O(n) public void push (T element)

{

if (size() == stack.length)

expandCapacity();

stack [top++] = element;

}

• worst case: O(n)

• How about the average case: almost constant time.

4

Array Stack Implementation

• pop() – O(1)public T pop() throws EmptyStackException{if (isEmpty())

throw new EmptyStackException();T result = stack[--top];stack[top] = null; // removes “stale” referencereturn result;

}

• The “stale” reference stored in stack[top] would prevent garbage collection on the object when the caller sets the returned reference value to null – ties up resources

5

Linked Stack Implementation

• We can use the same LinearNode class that we used for LinkedSet implementation

• We change the attribute name to “top” to have a meaning consistent with a stack

Object of type T

top LinearNode next;T element;

Object of type T

LinearNode next;T element;

null

count Object of type T

6

Linked Stack Implementation

• push – O(1)public void push (T element)

{

LinearNode<T> temp = new LinearNode<T>(element);

temp.setNext(top);

top = temp;

count++;

}

• Note the difference between the stack push method and the LinkedSet add method– There is no check for already present or not

7

Linked Stack Implementation

• pop – O(1)public T pop () throws EmptyStackException{if (isEmpty()) throw new EmptyStackException();T result = top.getElement();top = top.getNext();count--;return result;

}

• Note the difference between the stack pop method and the LinkedSet remove method– There is no specified target as a parameter

8

The java.util.Stack Class

• The java.util.Stack class is part of the Java collections API.

• It is a subclass of the java.util.Vector class which is a subclass of java.util.AbstractList

• java.util.Stack inherits some methods from its superclasses that are inappropriate for a stack collection – a bad design decision!

• A good programmer will avoid using those methods on a Stack object

9

The java.util.Stack Class

• java.util.Stack has a search method that returns the distance from the top of the stack to the first occurrence of that object on the stack, e.g. search returns 1 for the top element of the stack

• If the object is not found, search returns -1• The search method is O(n)• Does this method violate the principles of

a stack as a data structure?

10

Queue Abstract Data Type• A queue is a linear collection where the

elements are added to one end and removed from the other end

• The processing is first in, first out (FIFO)

• The first element put on the queue is the first element removed from the queue

• Think of a line of people waiting to be served at RMV.

11

A Conceptual View of a Queue

Rear of Queue(or Tail)

Adding an Element Removing an Element

Front of Queue(or Head)

12

Queue Terminology

• We enqueue an element on a queue to add one• We dequeue an element off a queue to remove one• We can also examine the first element without

removing it• We can determine if a queue is empty or not and

how many elements it contains (its size)• The L&C QueueADT interface supports the above

operations and some typical class operations such as toString()

13

Queue ADT Interface

<<interface>>QueueADT<T>

+ enqueue(element : T) : void+ dequeue () : T+ first() : T+ isEmpty () : bool+ size() : int+ toString() : String

14

Queue Design Considerations

• Although a queue can be empty, there is no concept for it being full. An implementation must be designed to manage storage space

• For first and dequeue operation on an empty queue, this implementation will throw an exception

• Other implementations could return a value null that is equivalent to “nothing to return”

15

Queue Design Considerations

• No iterator method is provided

• That would be inconsistent with restricting access to the first element of the queue

• If we need an iterator or other mechanism to access the elements in the middle or at the end of the collection, then a queue is not the appropriate data structure to use

16

The java.util.Queue Interface

• The java.util.Queue interface is in the Java Collections API (extends Collection)

• However, it is only an interface and you must use an implementing class

• LinkedList is the most commonly used implementing class

• For a queue of type objects:Queue<type> myQueue = new LinkedList<type>();

17

The java.util.Queue Interface

• The names of the methods are different

• Enqueue is done using:boolean offer(T element) // returns false if full

• Dequeue is done using either:T poll() // returns null value if empty

T remove() // throws an exception if empty

• Peek is done using either:T peek() // returns null value if empty

T element() // throws an exception if empty