Chapter 4

Chapter 4: Stacks and Queues

4.2 Stack

4.2.1 The Stack ADT Abstract Data Types (ADTs)

An abstract data type (ADT) is an abstraction of a data structure
An ADT specifies:
- Data stored
- Operations on the data
- Error conditions associated with operations
The Stack ADT stores arbitrary objects
Insertions and deletions follow the last-in first-out (LIFO) scheme
Main stack operations:
- push(object o): inserts element o at the top of the stack
- pop(): removes and returns the last inserted element
Auxiliary stack operations:
- top(): returns a reference to the last inserted element without removing it
- size(): returns the number of elements stored
- isEmpty(): returns a Boolean value indicating whether no elements are stored

Еxample: push(3), push(4), pop()...

Exceptions

Attempting the execution of an operation of ADT may sometimes cause an error condition, called an exception
Exceptions are said to be “thrown” by an operation that cannot be executed
In the Stack ADT, operations pop and top cannot be performed if the stack is empty
Attempting the execution of pop or top on an empty stack throws an StackEmptyException.
html-4.9 (Stack)

html-4.10 (StackEmptyException)
Access to elements (avoid making a copy) :
html-4.11 (Stack2)

4.2.2 A Simple Array-Based Implementation

A simple way of implementing the Stack ADT uses an array S
We add elements from left to right
A variable t keeps track of the index of the top element

Algorithm size()
return t + 1

Algorithm pop()
    if isEmpty() then
        throw EmptyStackException
    else
        t ← t − 1
        return S[t +1]

Algorithm push(o)
    if t = S.length − 1 then
        throw FullStackException
    else
        t ← t + 1
        S[t] ← o

The array storing the stack elements may become full

A push operation will then throw a FullStackException

Limitation of the array-based implementation, not intrinsic to the Stack ADT
Each function runs in constant time (not depend on stack size)

html-4.13 (ArrayStack1) ; html-4.14 (ArrayStack2)
ArrayStack.cpp; StackExcept.cpp

4.3 Queues

4.3.1 The Queue ADT

The Queue ADT stores arbitrary objects
Insertions and deletions follow the first-in first-out (FIFO) scheme
Insertions are at the rear of the queue and removals are at the front of the queue
Main queue operations:

enqueue(Object o): inserts an element o at the end of the queue
dequeue(): removes and returns the element at the front of the queue

Auxiliary queue operations:

front(): returns the element at the front without removing it
size(): returns the number of elements stored
isEmpty(): returns a Boolean indicating whether no elements are stored

Exceptions

Attempting the execution of dequeue or front on an empty queue throws an EmptyQueueException

Example: enqueue(5), enqueue(3), dequeue(), ...

Applications of Queues

Direct applications

Waiting lists, bureaucracy
Access to shared resources (e.g., printer)
Multiprogramming

Indirect applications

Auxiliary data structure for algorithms
Component of other data structures

4.3.2 A Simple Array-Based Implementation

html-4.16 (Queue)

Use an array of size N in a circular fashion
Two variables keep track of the front and rear:

f index of the front element
r index immediately past the rear element; array location r is kept empty

Queue Operations:

Algorithm size()
return (N − f + r) mod N

Algorithm isEmpty()
return (f = r)

Algorithm enqueue(o)
    if size() = N − 1 then
        throw FullQueueException
    else
        Q[r] ← o
        r ← (r + 1) mod N

Algorithm dequeue()
    if isEmpty() then
        throw EmptyQueueException
    else
        o ← Q[f]
        f ← (f + 1) mod N
        return o

We use the modulo operator (remainder of division).
Operation enqueue throws an exception if the array is full. This exception is implementation-dependent.
Operation dequeue throws an exception if the queue is empty. This exception is specified in the queue ADT.
Each function in this implementation runs O(1) (constant) time.

4.4 Linked Lists

4.4.1 Singly Linked Lists

A singly linked list is a concrete data structure consisting of a sequence of nodes
Each node stores:

element
link to the next node

4.4.2 Implementing a Stack with a Singly Linked List

html-4.18 (Node)
html-4.19 (LinkedStack1)
html-4.20 (LinkedStack2)
html-4.21 (LinkedStack3)
LinkedStack.cpp

4.4.3 Implementing a Queue with a Singly Linked List

html-4.22 (LinkedQueue)

4.5 Double-Ended Queue (Deque)

Supports insertion and deletion at both the front and the rear of the queue.

4.5.1 The Deque ADT

The fundamental functions of the Deque ADT are as follows:

insertFirst(o), insertLast(o)
removeFirst(), removeLast()

The deque includes the following support functions:

first(), last()
size(), isEmpty()

Example: insertFirst(3), insertFirst(5), first(), removeFirst(), insertLast(7),...

4.5.2 Implementing a Deque with a Doubly Linked List

A doubly linked list is a concrete data structure consisting of a sequence of nodes.
Nodes store:
- element (a datum)
- link (pointer) to the previous node
- link (pointer) to the next node
Special trailer and header nodes (sentinel nodes). They simplify the code for insertion and removal operations.

Inserting and removing elements at either end of a doubly linked list is straightforward to do in O(1) time.
html-4.23 (Node)
html-4.24 (LinkedDeque1)
LinkedDeque.h; LinkedDeque.cpp

4.5.3 The Adapter Design Pattern

The adapter design pattern adjusts functions from one class so they can be used to implement functions of another class.
html-4.25 (DequeStack)
We adapt class LinkedDeque, which implements the more powerful Deque interface, so that it can be used to implement the simpler Stack interface.