CSCI-UA 102

Data Structures

Stacks and Queues

Instructor: Joanna Klukowska

Copyright 2020 Joanna Klukowska. Unless noted otherwise all content is released under a
Creative Commons Attribution-ShareAlike 4.0 International License.
Background image by Stewart Weiss

1/95

Stack ADT2/95

Stacks and Stack ADT

Stacks are structures in which elements are always added and removed from the same end (depending on how you visualize the stack, you may wish to think of that end as the top of the stack). Stacks are last in first out (or LIFO) structures.

3/95

Stacks and Stack ADT

public interface Stack<E> {
  /** Add an element to the top of the stack
   * @param item character to be added to the stack
   */
  public void push ( E item ) ;
  /** Remove and return the element from the top of the stack
   * @return the element from the top of the stack or null if the stack is empty
   *   from the stack. If stack is empty, null is returned.
   */
  public E pop () ;
  /** Return the element from the top of the stack.
   * @return  the element from the top of the stack or null if the stack is empty
   */
  public E peek () ;
  /** Produces string representation of the stack.
   * @return Returns a String object that contains all elements stored on the stack.
   *   The elements are separatedb y spaces. The top of the stack is the rightmost
   *   element in the returned string.
   */
  public String toString () ;
}

4/95

Stacks and Stack ADT

public interface Stack<E> {
  /** Add an element to the top of the stack
   * @param item character to be added to the stack
   */
  public void push ( E item ) ;
  /** Remove and return the element from the top of the stack
   * @return the element from the top of the stack or null if the stack is empty
   *   from the stack. If stack is empty, null is returned.
   */
  public E pop () ;
  /** Return the element from the top of the stack.
   * @return  the element from the top of the stack or null if the stack is empty
   */
  public E peek () ;
  /** Produces string representation of the stack.
   * @return Returns a String object that contains all elements stored on the stack.
   *   The elements are separatedb y spaces. The top of the stack is the rightmost
   *   element in the returned string.
   */
  public String toString () ;
}

The Java's built in class implementing a stack is Stack<E>.

5/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

6/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

7/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 0

8/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 1

9/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

10/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

11/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

The top element is at index 2, so that is the element removed when pop is called.

12/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 5

13/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

14/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0

15/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements

16/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added?

17/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size

18/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size
how do we know the index from which the element should be popped/removed?

19/95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size
how do we know the index from which the element should be popped/removed? the index of the top is size - 1

20/95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

21/95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

22/95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

23/95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

Algorithm for top (return, but do not remove the top element)

if size == 0
  nothing to return
else
  return array[size-1]

24/95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

Algorithm for top (return, but do not remove the top element)

if size == 0
  nothing to return
else
  return array[size-1]

What is the performance of each of these algorithms?

25/95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

26/95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the top and bottom of the stack be.

27/95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the top and bottom of the stack be.

stack using an array

Which of the options A or B is better? Or is there no difference?

28/95

Stack Implementation Using a Linked Structure

top of the stack at the end

29/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

30/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

31/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

32/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

33/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

34/95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

35/95

Stack Implementation Using a Linked Structure

top of the stack at the front

36/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

37/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

38/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

39/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

40/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

41/95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

42/95

Queue ADT43/95

Queues and Queue ADT

Queues are structures in which elements are added to one end (rear/back of a queue) and removed from the other end (front of a queue). Queues are first in first out structures (FIFO).

44/95

Queues and Queue ADT

public interface Queue<E> {
  /** Add an element to the queue.
    * @param item  an element to be added to the queue
    */
  public void enqueue ( E item ) ;
  /** Remove and return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E dequeue () ;
  /** Return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E peek () ;
  /** Compute a string representation of the queue.
    * @return String object representing the queue. The string should contain the
    * current queue elements one per line.
    */
  public String toString () ;
}

45/95

Queues and Queue ADT

public interface Queue<E> {
  /** Add an element to the queue.
    * @param item  an element to be added to the queue
    */
  public void enqueue ( E item ) ;
  /** Remove and return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E dequeue () ;
  /** Return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E peek () ;
  /** Compute a string representation of the queue.
    * @return String object representing the queue. The string should contain the
    * current queue elements one per line.
    */
  public String toString () ;
}

Java has a built-in interface for a queue: Queue<E>, and there are several classes that implement this interface.

Note that the names for the methods are different in the above interface.

46/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

47/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

48/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 0

front = 0

back = 0

49/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 1

front = 0

back = 1

50/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

front = 0

back = 2

51/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 5

front = 0

back = 5

52/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 4

front = 1

back = 5

53/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

front = 2

back = 5

54/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

front = 2

back = 5

front - index of the first element (size > 0)

back - index at which the next element should be added

size = back - front

55/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 6

front = 2

back = ???

56/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 6 + 1

front = 2

back = ???

57/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

58/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

We can use the array as a circular array: where there are empty locations available in the front of the array, we wrap the values back to the start of the array instead of allocating a new one.

59/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

We can use the array as a circular array: where there are empty locations available in the front of the array, we wrap the values back to the start of the array instead of allocating a new one.

~~size = back - front~~

size =
(back - front) mod capacity

(when size < capacity)

60/95

Aside: modulo arithmetic examples

10 mod 8 = 2

61/95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2

62/95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5

63/95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2

64/95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2
-9 mod 8 = -1 mod 8 = 7 mod 8 = 7

65/95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2
-9 mod 8 = -1 mod 8 = 7 mod 8 = 7

Note that Java's % operator does not compute the true modulus, it computes the remainder. The two are the same when both operands are positive.

In java: -6 % 8 evaluates to -6, to obtain true modulus, we need to add the divisor to the result: (-6 % 8) + 8.

66/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

67/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

68/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

69/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

70/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

71/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

72/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

Will this work?

73/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

Will this work?

74/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

75/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

queue using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

76/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

queue using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

Will this work?

77/95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

Will this work? YES

78/95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

79/95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the front and back of the queue be.

80/95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the front and back of the queue be.

queue using an array

Which of the options A or B is better? Or is there no difference?

81/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

82/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

83/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

84/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

85/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

86/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

87/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

88/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

89/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

90/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

91/95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

92/95

Examples and Things to Think About93/95

Algorithms for array-based queue

On slide #25 we have algorithms for the stack operations when it is implemented using an array. Create similar algorithms for the array-based queue implementation.

94/95

Stacks and Queues in Java

Study the Stack<E> class.
- can you tell if it is array-based on reference-based?
- if it is one of the above implementations, is there an alternative in Java (i.e. are there classes in Java that provide array-based implementation and reference-based implementation - not in the same class, of course)
The above Stack<E> class mentions Deque<E> interface.
- how is it different from a sack?
- what functionality does it provide?
- what does deque stand for?
The Queue<E> interface is implemented by many classes. Pick the ones that you are familiar with and divide them into array-based implementations and reference-based implementations.

95/95

CSCI-UA 102

Data Structures

Stacks and Queues

Instructor: Joanna Klukowska

Copyright 2020 Joanna Klukowska. Unless noted otherwise all content is released under a
Creative Commons Attribution-ShareAlike 4.0 International License.
Background image by Stewart Weiss

1 / 95

Stack ADT2 / 95

Stacks and Stack ADT

3 / 95

Stacks and Stack ADT

public interface Stack<E> {
  /** Add an element to the top of the stack
   * @param item character to be added to the stack
   */
  public void push ( E item ) ;
  /** Remove and return the element from the top of the stack
   * @return the element from the top of the stack or null if the stack is empty
   *   from the stack. If stack is empty, null is returned.
   */
  public E pop () ;
  /** Return the element from the top of the stack.
   * @return  the element from the top of the stack or null if the stack is empty
   */
  public E peek () ;
  /** Produces string representation of the stack.
   * @return Returns a String object that contains all elements stored on the stack.
   *   The elements are separatedb y spaces. The top of the stack is the rightmost
   *   element in the returned string.
   */
  public String toString () ;
}

4 / 95

Stacks and Stack ADT

public interface Stack<E> {
  /** Add an element to the top of the stack
   * @param item character to be added to the stack
   */
  public void push ( E item ) ;
  /** Remove and return the element from the top of the stack
   * @return the element from the top of the stack or null if the stack is empty
   *   from the stack. If stack is empty, null is returned.
   */
  public E pop () ;
  /** Return the element from the top of the stack.
   * @return  the element from the top of the stack or null if the stack is empty
   */
  public E peek () ;
  /** Produces string representation of the stack.
   * @return Returns a String object that contains all elements stored on the stack.
   *   The elements are separatedb y spaces. The top of the stack is the rightmost
   *   element in the returned string.
   */
  public String toString () ;
}

The Java's built in class implementing a stack is Stack<E>.

5 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

6 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

7 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 0

8 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 1

9 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

10 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

11 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

The top element is at index 2, so that is the element removed when pop is called.

12 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 5

13 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

14 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0

15 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements

16 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added?

17 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size

18 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size
how do we know the index from which the element should be popped/removed?

19 / 95

Stack Implementation Using an Array

One way to implement a stack is to use the array as the underlying storage.

The decision that needs to be made is where should the top and bottom of the stack be.

As with the array-based list implementation, we also need to make sure that the array grows when the number of elements put on the stack reaches the capacity of the array.

stack using an array

bottom of the stack is always at index 0
top of the stack moves as we push and pop elements
how do we know the index at which the next element should be pushed/added? the index of the first empty space is size
how do we know the index from which the element should be popped/removed? the index of the top is size - 1

20 / 95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

21 / 95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

22 / 95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

23 / 95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

Algorithm for top (return, but do not remove the top element)

if size == 0
  nothing to return
else
  return array[size-1]

24 / 95

Stack Implementation Using an Array

Algorithm for push

if size >= capacity
  grow the array and copy all the elements to the new array
array[size] = new element
size++

Algorithm for pop

if size == 0
  nothing to pop
else
  size--
  return array[size]

Alternative algorithm for pop

if size == 0
  nothing to pop
else
  tmp = array[size-1]
  array[size-1] = null
  size--
  return tmp

Algorithm for top (return, but do not remove the top element)

if size == 0
  nothing to return
else
  return array[size-1]

What is the performance of each of these algorithms?

25 / 95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

26 / 95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the top and bottom of the stack be.

27 / 95

Stack Implementation Using a Linked Structure

An alternative way of implementing a stack is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the top and bottom of the stack be.

stack using an array

Which of the options A or B is better? Or is there no difference?

28 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

29 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

30 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

31 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

32 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

33 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

34 / 95

Stack Implementation Using a Linked Structure

top of the stack at the end

stack using an array

35 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

36 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

37 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

38 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

39 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

40 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

41 / 95

Stack Implementation Using a Linked Structure

top of the stack at the front

stack using an array

42 / 95

Queue ADT43 / 95

Queues and Queue ADT

Queues are structures in which elements are added to one end (rear/back of a queue) and removed from the other end (front of a queue). Queues are first in first out structures (FIFO).

44 / 95

Queues and Queue ADT

public interface Queue<E> {
  /** Add an element to the queue.
    * @param item  an element to be added to the queue
    */
  public void enqueue ( E item ) ;
  /** Remove and return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E dequeue () ;
  /** Return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E peek () ;
  /** Compute a string representation of the queue.
    * @return String object representing the queue. The string should contain the
    * current queue elements one per line.
    */
  public String toString () ;
}

45 / 95

Queues and Queue ADT

public interface Queue<E> {
  /** Add an element to the queue.
    * @param item  an element to be added to the queue
    */
  public void enqueue ( E item ) ;
  /** Remove and return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E dequeue () ;
  /** Return the element from the front of the queue
    * @return the element from the front of the queue or null if queue is empty
    */
  public E peek () ;
  /** Compute a string representation of the queue.
    * @return String object representing the queue. The string should contain the
    * current queue elements one per line.
    */
  public String toString () ;
}

Java has a built-in interface for a queue: Queue<E>, and there are several classes that implement this interface.

Note that the names for the methods are different in the above interface.

46 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

47 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

48 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 0

front = 0

back = 0

49 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 1

front = 0

back = 1

50 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 2

front = 0

back = 2

51 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 5

front = 0

back = 5

52 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 4

front = 1

back = 5

53 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

front = 2

back = 5

54 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 3

front = 2

back = 5

front - index of the first element (size > 0)

back - index at which the next element should be added

size = back - front

55 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 6

front = 2

back = ???

56 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 6 + 1

front = 2

back = ???

57 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

58 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

We can use the array as a circular array: where there are empty locations available in the front of the array, we wrap the values back to the start of the array instead of allocating a new one.

59 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

We can use the array as a circular array: where there are empty locations available in the front of the array, we wrap the values back to the start of the array instead of allocating a new one.

~~size = back - front~~

size =
(back - front) mod capacity

(when size < capacity)

60 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2

61 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2

62 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5

63 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2

64 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2
-9 mod 8 = -1 mod 8 = 7 mod 8 = 7

65 / 95

Aside: modulo arithmetic examples

10 mod 8 = 2
2 mod 8 = 2
29 mod 8 = 5
-6 mod 8 = (-6 + 8 ) mod 8 = 2 mod 8 = 2
-9 mod 8 = -1 mod 8 = 7 mod 8 = 7

Note that Java's % operator does not compute the true modulus, it computes the remainder. The two are the same when both operands are positive.

In java: -6 % 8 evaluates to -6, to obtain true modulus, we need to add the divisor to the result: (-6 % 8) + 8.

66 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 7

front = 2

back = 1

67 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

68 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

69 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

70 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

71 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

72 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

Will this work?

73 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
place the new value at the end

Will this work?

74 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8

size = 8

front = 2

back = 2

size == capacity

so we need a larger array

75 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

queue using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

76 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

queue using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

Will this work?

77 / 95

Queue Implementation Using an Array

One way to implement a queue is to use the array as the underlying storage.

The decision that needs to be made is where should the front and the end of the queue be.

And as before, we also need to make sure that the array grows when the number of elements in the queue reaches the capacity of the array.

stack using an array

capacity = 8
size = 8
front = 2
back = 2

size == capacity

so we need a larger array

create a new larger array
copy of the values from the old array to the new one
for each index i in the old array, copy it to index
(i - front) mod capacity
in the new array
place the new value at the end

Will this work? YES

78 / 95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

79 / 95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the front and back of the queue be.

80 / 95

Queue Implementation Using a Linked Structure

An alternative way of implementing a queue is to use a reference based structure just like we did for a list.

Again, the decision that needs to be made is where should the front and back of the queue be.

queue using an array

Which of the options A or B is better? Or is there no difference?

81 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

82 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

83 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

84 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

85 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

86 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

87 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

88 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

89 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

90 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

91 / 95

Queue Implementation Using a Linked Structure

front of the queue at the end or beginning

queue using an array

92 / 95

Examples and Things to Think About93 / 95

Algorithms for array-based queue

On slide #25 we have algorithms for the stack operations when it is implemented using an array. Create similar algorithms for the array-based queue implementation.

94 / 95

Stacks and Queues in Java

Study the Stack<E> class.
- can you tell if it is array-based on reference-based?
- if it is one of the above implementations, is there an alternative in Java (i.e. are there classes in Java that provide array-based implementation and reference-based implementation - not in the same class, of course)
The above Stack<E> class mentions Deque<E> interface.
- how is it different from a sack?
- what functionality does it provide?
- what does deque stand for?
The Queue<E> interface is implemented by many classes. Pick the ones that you are familiar with and divide them into array-based implementations and reference-based implementations.

95 / 95

↑, ←, Pg Up, k	Go to previous slide
↓, →, Pg Dn, Space, j	Go to next slide
Home	Go to first slide
End	Go to last slide
Number + Return	Go to specific slide
b / m / f	Toggle blackout / mirrored / fullscreen mode
c	Clone slideshow
p	Toggle presenter mode
t	Restart the presentation timer
?, h	Toggle this help

↑, ←, Pg Up, k	Go to previous slide
↓, →, Pg Dn, Space, j	Go to next slide
Home	Go to first slide
End	Go to last slide
Number + Return	Go to specific slide
b / m / f	Toggle blackout / mirrored / fullscreen mode
c	Clone slideshow
p	Toggle presenter mode
t	Restart the presentation timer
?, h	Toggle this help