Stacks and Queues

Complete the Reading Quiz by 3:00pm before lecture.

Table of contents

1. Representation Invariants
2. Stack ADT
3. Queue ADT
4. Java Generics

In lecture, we learned that abstract data types (ADTs) hide implementation details from clients, the users of ADTs. This holds so long as both the client and the implementer agree on the ADT’s possible values and operations.

Here, we examine design decisions from the client’s perspective: Given that we want to represent the data using the List ADT, which of either ArrayList or LinkedList should we use to solve the problem? Recall that ArrayList is backed by a data array of items that we resize when data.length is not large enough for the size of the list. Let’s take a closer look at the get and removeFront methods for our ArrayList.

Item get(int i)

Returns the item at the specified zero-based index i in the list.

removeFront(int k)

Removes the first k values from the list.

Implementing get by indexing directly into the underlying data array relies on the assumption that the i-th item of the list is always located at data[i]. While this assumption might seem simple, it dictates the implementation for removeFront.

Representation Invariants

Assumptions like this one are called representation invariants and underlie all concrete data structures. A representation invariant is a condition that is guaranteed to be true before and after the data structure is modified. Invariants make it easier to reason about the correctness of our code as it gives us a convenient checklist every time we modify our data structure.

Invariants can also serve as guide posts for our problem-solving process and mental model of the data structure. We could implement removeFront by making a plan that integrated information about the ArrayList invariants. For every program we want to analyze, create, or evaluate, we should ask ourselves about its invariants.

Stack ADT

The Stack is a linear ADT that supports adding and removing items from one end that we call the top of the stack, or “last-in, first-out” (LIFO).

push(Item item)

Puts the item on the top of the stack.

Item pop()

Removes and returns the top item of the stack.

This is like only using the addLast and removeLast methods of a List ADT, where the back of the list represents the top of the stack. Unlike lists, stacks do not maintain item indexes: what matters is the position of each item relative to the top of the stack.

Queue ADT

The Queue is a linear ADT that supports adding items to one end and removing items from the other end of the queue, or “first-in, first-out” (FIFO).

add(Item item)

Adds the item to the back of the queue.

Item remove()

Removes and returns the item at the front of the queue.

This is like only using the addLast and removeFront methods of a List ADT. Unlike lists, queues do not maintain item indexes: what matters is the position of each item relative to the front of the queue.

Java Generics

Java generics allow you to implement a class independent of a specific type. It is only when the generic is used (ie, instantiated) that clients must supply the type. Consider the following Box class.

public class Box {
    private Object object;

    public void set(Object object) {
        this.object = object;
    }

    public Object get() {
        return object;
    }
}

Since every Java type derives from Object, this implementation can contain any time. However, we can also use generics to implement a similar Box.

public class Box<T> {
    // T stands for Type
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

Reading Quiz