Sets in Computer Science

Sets are collections of objects. For example, {1,2,3 ...}, {cat, dog}, etc.
They are as fundamental to computer science as they are to mathematics.
In mathematics, we often use a variety of operations to build new sets from existing ones: union, difference, cartesian product, power set, etc.
In computer science, we might use these operations, but we also often implement sets as data structures which are dynamic. i.e., can change.
Algorithms may require several different types of operation to be performed on sets. For example, the algorithm might need that the set supports an insert, a delete, or a membership test operation.
We call a dynamic set that supports insert, delete and membership a dictionary.
As an example, min-priority queues are an example of a dictionary.

Operations on dynamic sets

Operations on dynamic sets are grouped into two categories: queries which return information about the set, and modifying operations, which change the set.
Below are some common operation that a dynamic set might support:

SEARCH(S, k)
A query that, given a set `S` and a value `k`, returns a pointer `x` to an element in `S` such that `x`.key = `k`, or NIL if no such element belongs to `S`.

INSERT(S, x)
A modifying operation that augments `S` with the element pointed to by `x`.

DELETE(S, x)
A modifying operation, that given a pointer `x` to an element in `S`, removes `x` from `S`.

MINIMUM(S)
A query on a totally ordered set `S` that returns a pointer to the element of `S` with the smallest key.

MAXIMUM(S)
query on a totally ordered set `S` that returns a pointer to the element of `S` with the largest key.

SUCCESSOR(S, x)
A query that, given an element `x` whose key is from a totally ordered set `S`, returns a pointer to the next larger element in `S`, or NIL if `x` is the maximum element.

PREDECESSOR(S, x)
A query that, given an element `x` whose key is from a totally ordered set `S`, returns a pointer to the next smaller element in `S`, or NIL if `x` is the minimum element.

Let's look at some dynamic sets now...

Stacks and Queues

Stacks and queues are dynamic sets in which the element removed from the set by DELETE is prespecified.
In a stack, we always delete the most recently inserted element. I.e., it is last-in, first out (LIFO).
In a queue, we always delete the element that has been in the queue the longest times. I.e., it is first-in, first out (FIFO)
For stacks, INSERT is often called PUSH and DELETE is often called POP.
For stacks, the last element inserted is called the top of the stack.
For queues, INSERT is often called ENQUEUE and DELETE is often called DEQUEUE.
For queues, we often keep track of the head of the queue (who will be dequeued next) and the tail (where we will add after.)

Array Implementation of a Stack

We can implement a stack of at most `n` elements with an array `S[1..n]`.
We will use S.top to index the most recently inserted element. The stack consists of elements `S[1.. S.\t\op]`, where we call S[1] is bottom of the stack. `S.\t\op` may be less than `n`.
When `S.\t\op = 0`, we say the stack is empty.
If we try to pop when the stack is empty we get an underflow error. If we push when `S.\t\op=n` we get an overflow error.

Below is some pseudo-code for the operations of a stack (each of which is `O(1)`):

STACK-EMPTY(S)
1 if S.top == 0
2    return true
3 else return false

PUSH(S,x)
1 S.top = S.top + 1
2 S[S.top] = x

POP(S)
1 if STACK-EMPTY(S)
2    error "underflow"
3 else S.top = S.top - 1
4    return S[S.top + 1]

Example Operations on a Stack

Let (a) above be our initial stack.
Then (b) shows the stack after the operations PUSH(S, 17) and PUSH(S, 3)
Next (c) shows the result of performing a POP(S).
Notice in (c), S.top changes but so 3 is not in the stack contents, but 3 is still be in the array. It would be overwritten by the next push.

Array Implementation of a Queue

We can implement a queue using an array Q[1..n].
Let Q.head and Q.tail be the head and tail of this queue.
Q.tail indexes the next location at which a newly arriving element will be inserted into the queue.
We imagine the queue will be implemented in a circular fashion.
The contents of the queue will be in locations Q.head, Q.head+1, ..., Q.tail -1, where we "wrap around" in that location 1 immediately follows location `n`.
Initially, we have `Q.head = Q.tail = 1`. If we attempt to dequeue when the head and tail are the same we get an underflow.
When `Q.head = Q.tail + 1` or both `Q.head = 1` and `Q.tail = n` (we define `Q`.length `= n`), the queue is full. Adding more elements in this case overflows the queue.

Queue Pseudo-code

Below is some pseudo-code for the operations of a queue (each of which is `O(1)`):

ENQUEUE(Q, x)
1 Q[Q.tail] = x
2 if Q.tail == Q.length
3    Q.tail = 1
4 else Q.tail = Q.tail + 1

DEQUEUE(Q)
1 x = Q[Q.head]
2 if Q.head == Q.length
3    Q.head = 1
4 else Q.head = Q.head + 1
5 return x

Queue Example

The above queue is implemented in the array Q[1..12]
At (a) above, the queue has 5 elements `Q[7..11]`
(b) is the configuration of the array after called to ENQUEUE(Q, 17), ENQUEUE(Q, 3), ENQUEUE(Q, 5)
(c) is the configuration after a call to DEQUEUE(Q).

Linked Lists

A linked list is a data structure in which the objects are arranged in a linear order.
Unlike an array, order is not determined by array indices, but instead the order in a linked list is determined by a pointer in each object.
Linked-lists can be used to support (albeit not necessarily the most efficiently) all of the dynamic set operations we described earlier.
Above we see some example of doubly linked lists.
An element of a doubly linked list `L` is an object with an attribute key and two other attributes: next and prev. The element might also have other satellite data.
Given an element `x` in the list, `x.\n\ext` points to is successor in the linked list, and `x.p\r\ev` points to its predecessor.
If `x.p\r\ev` = NIL the element has no predecessor and is therefore the first element (the head) of the list. Similarly, if `x.n\e\x\t` = NIL then `x` has no successor and `x` is the last element (the tail) of the list.
If L.head = NIL, the list is empty.

Common Forms of Lists

Several variants of lists exist.
If the list elements don't have prev pointers we call them singly linked lists,
If a list is sorted, the linear order of the list corresponds to the linear order of keys stored in elements in the list.
In a circular list, the prev pointer of the head of the list points to the tail and the next pointer of the tail points to the head to make a ring.

Pseudo-code of some list operations

Below is pseudo code for list versions of some of the dynamic set operations to give a feel for how we could implement them:

LIST-SEARCH(L,k) //Theta(n) where n=L.length worst case
1 x = L.head
2 while x != NIL and x.key != k
3    x = x.next
4 return x

LIST-INSERT(L,x) //Theta(1)
1 x.next = L.head
2 if L.head != NIL
3     L.head.prev = x
4 L.head = x
5 x.prev = NIL

LIST-DELETE(L,x) //Theta(n) worst case
1 if x.prev != NIL
2    x.prev.next = x.next
3 else L.head = x.next
4 if x.next != NIL
5    x.next.prev = x.prev

Elementary Data Structure

Outline