Position- stores the place where something is.
HashTable
ADT: size(), isEmpty(), first(), last(), before(p), after(p),
set(p, e), remove(p), addBefore(p, e), addAfter(p, e),
addFirst€, addLast€
Singley Linked List, Doubley Linked List. Operations
O(1).
Stack – like an actual stack of things
ADT: push(e), pop(), top() , size(), isEmpty()
Last-in, First-out
Queues – like a real life queue
ADT: enqueue(e), dequeue(), front(), size(), isEmpty()
Deque - a stack and a queue combined
ADT: addFirst(e), addLast(e), removeFirst(),
removeLast(), getFirst(), getLast(), size(), isEmpty(),
offerFirst(e), inserts e at front unless full. Returns T/F
based on success, offerLast(e), pollFirst(), removes and
returns the first element, pollLast(), peekFirst(),
peekLast()
Tree – nodes with a parent-child relationship
ADT: int size(), boolean isEmpty(), iterator iterator(),
iterable positions(), position root(), position parent(p),
iterable children(p), integer numChildren(p), boolean
isInternal(p), boolean isExternal(p), boolean isRoot(p)
Definition: each node v of T different from the root has
a unique parents, there is a path from the root to any
other node
Can be ordered (linear ordering of children)
Preorder Traversal: visit n, for each child n,
preOrder(child)
Postorder Traversal: for each child of n:
postOrder(child), visit(n)
Binary Tree – ordered tree with nodes having at most
two children which are labelled left and right
ADT: same as tree but with position left(p), position
right (p), position sibling(p).
Proper: each node has exactly 0 or 2 children
Complete: each level is completely filled but the last
one which is filled left to right
Balanced: if the height of any right subtree differs from
the left subtree by no more than 1
inorder Traversal: inOrder(left child), visit(n),
inOrder(right child)
Can be implemented with a linked structure (like a tree)
OR an array. If array leftchild = 2i + 1, rightchild = 2i+2,
parent =(i+1)/2 floored.
Priority Queues – stores a collection of prioritised
entries (key-value pairs)
ADT: insert(k, v), removeMin(), min(), size(), isEmpty()
Comparator encapsulates the action of comparing two
objects. External to the objects being compared (unlike
Comparable).
Implemented with a sorted (insert O(n) but removeMin
O(1)) or unsorted (insert O(1) removeMin O(n)) list
Heap – implements priority queue where each child is
smaller than its parent
ADT: same as priority queue
Has height O(log(n))
To insert, add element at the bottom and restore the
heap property by swapping nodes upwards. To remove,
switch the node being removed with the last node, and
then downheap from the new position of the last node.
Use O(n) space, everything O(1) except insert and
removeMin, which are O(log(n))
Map – searchable collection of unique key-value pairs
ADT: get(k), put(k, v), remove(k), size(), isEmpty(),
iterable entrySet(), keyset(), values()
List Based: use unsorted list. Takes space O(n) and put,
get and remove take O(n).
Ordered Map ADT: everything above plus, firstEntry(k),
lastEntry(k), ceilingEntry(k), floorEntry(k), lowerEntry(k),
higherEntry(k)
Implemented using a sorted array – space O(n), insert
and delete are O(n), but search is O(log(n))
Binary Search Tree
Searches in O(log(n)) worst case could be O(n) if
everything in row
Deletion: if one child, swap with that child (repeatedly
until no children). If two children, swap with the inorder
predecessor and then do the first step
ArrayList
ADT: same as map
Use an array with index determined by hashfunction to
store key value pairs
Expected run time is O(1) but worst case is O(n)
Separate Chaining: each cell in table points to a linked
list of entries that map there. Alternative is open
addressing-building Map based on hashing
Linear Probing: going through array until space. When
remove leave defunct
Quadratic Probing: go through series (key+j^2 modN)
for j=1,2,3, .... N must be prime
Double Hashing: Use a second hashing function d(k) in
series: k+j*d(k) modN
Selection Sort – Priority Queue with an unsorted list.
O(n^2)
Graphs are a pair(collection of Vertices, collection of
Edges)
ADT: numVertices(), vertices(), numEdges(), edges(),
getEdge(u, v), endVertices(e), opposite(v,e),
outDegree(v), inDegree(v), outgoingEdges(v),
incomingEdges(v), insertVertex(x), insertEdge(u, v, x),
removeVertex(v), removeEdge(e)
Incident edges are the ones connected to the vertex
Simple graph No parallel edges or self loops
Cycle circular sequence of alternating vertices and
edges
n = number of vertices, m = number of edges
Subgraph the vertices and edges of S are a subset of the
vertices and edges of G. Spanning subgraph vertices S =
vertices G
Undirected simple graph: m <= n(n-1)/2
Can be implemented through an unordered list holding
incident edges for each vertex OR through an adjacency
map which uses a hash-based map for storing incident
edges for each vertex, OR through an edge list which
holds its origin and destination vertex objects OR
through a matrix which stores the edge in the correct
cell between vertices.
Subgraph vertices and edges of S are a subset of the
ones in G
Spanning supgraph: vertices S = vertices G
DFS: Check the children before siblings, run in O(m+n)
time, use stack.
BFS: check siblings before children, runs in O(m+n) time,
use queue.
Directed DFS we
have discovery,
back, forward and
cross edges
Strongly connected graph: each vertex has a directed
path to every other vertex
Transitive Closure: Floyd-Warshall algorithm, digraph of
G where if there is a directed path between u,v there is
a directed edge (FW: number the vertices, construct
diagram incrementally @ round k+1 only consider paths
that use only vertices numbered 1, 2, …k as
intermediate vertices). O(n^3)
Directed Acyclic Graph (DAG) has no directed cycles
Topological Ordering; numbering vertices so every edge
(u,v) u<v. (must be a DAG)
Weighted Graph Dijkstra’s algorithm does shortest
distance in O(mlog(n)). Grow cloud of vertices each
storing the shortest distance to it from v. Each step, add
the vertex with the smallest distance to the cloud
Cells in an array are associated with particular pieces of
allocated memory.
get(i)-O(1). Return data[i], deals with exceptional
classes(less than or greater than size).
set(i,e)-O(1). Return the replaced value, update the
value in memory with index i so it now points to e.
add(i,e)-O(n). Insert element e at index i, existing
elements with index >=i are shifted up.
remove(i)-O(n). Return the removed item. Iterate over
indices >=i, shifting values down.
Singley Linked list
Each Node in a Singley Linked List stores its element and
a link to the next node.
addFirst(e)-O(1). New node, 'n', set e as element of n,
set n.next to old head, update head to point to n.
removeFirst()-O(1). Update list's head to point to the
next node. Make the former first one null.
addLast(e)-O(n). New node, 'n', set e as element of n,
set n.next to null, set old tail to point to n.
removeLast()-O(n). Update list's tail to point to the
node before, make former tail null.
Doubley Linked list
Each Node in a Doubley Linked list stores its element
and a link to the previous and next nodes.
addAfter(p,e)-O(1).Return new node, 'n',
n.setElement(e), n.setPrev(p),n.setNext(p.getNext()),
p.getNext().setPrev(n), p.setNext(n).
remove(p)-O(1)-Return value removed,
p.getPrev().setNext(p.getNext()),
p.getNext().setPrev(p.getPrev()), p.setPrev(null),
p.setNext(null)
O(1) - size, isEmpty, first, last, before, after, set,
remove, addBefore, addAfter
Iterators
Abstracts the process of stepping through a collection
of elements one at a time.
hasNext()- returns boolean, checkes whether the
collection is non-empty and the cursor is not after the
last element
next()- returns the element after the cursor(cursor
advances)
For-Each- convenient syntax for using the iterator
associated with an Iterable class
Inorder
Preorder
Postorder
1. Edge List structure-Simple, but inefficient-Unordered
list V,E (Vertex and Edge object)
O(m)-incidentEdges(v), areAdjacent(v,w),
removeVertex(v), m edges
O(1)-insertVertex(o),insertEdge(v,w,o), removeEdge(e)
2. Adjacency List structure-Unordered list with
additional list structure
Incidence sequence l(v) for each vertex v- sequence of
references to edge objects of incident edges
Augmented edge objects- references to associated
positions in incidence sequence of end vertices
All methods O(1) with Edge list structure are still O(1).
O(deg(v))-incidentEdges(v), removeVertex(v),
O(min(deg(v),deg(w))-areAdjacent(v,w)
3. Adjacency Map structure-Same as adjacency list, but
uses a hash-based map for storing incident edges
Incidence map for each vertex v- Key=opposite
endpoint value=edge
getEdge(u,v) now is in expect O(1)-although still worst
case O(min(deg(u),deg(v)))
4. Adjacency Matrix Structure- Augmented vertex
objects- integer key(index) associated with vertex
2D-array adjacency array A- reference to edge object
for adjacent vertice, null for nonadjacent vertices
Dense graphs have O(n^2) edges
n vertices, m edges, no parallel edges/self-loops
Sorting
Insertion Sort – Priority Queue with a sorted list.
O(n^2). Space is O(n). We move elements into the pq,
and then move them from the pq to the output
Heap Sort – sorting with a heap. O(nlog(n))
Bubble Sort – Scan the sequence n-1 times – In each
step of a scan, compare the current element with the
next and swap them if they are out of order. O(n^2)
Merge Sort – divide and conquer. O(nlog(n)). Partition S
into half, and recursively sort (base: size == 1), and then
merge the sorted lists together
Divide
Conquer
Quick Sort – divide and conquer with pivot. Worst case
is O(n^2) when worst pivot every time, BUT as good
pivot picked 50^ of the time, expected run time is
O(nlog(n)). Pick pivot and sort into groups less than,
equal and greater than, recursively repeat on these
groups. Join them together
Summary of sorting algorithms Sort algorithm Time cost
Comments Selection-sort O(n^2) can be done in-place
Insertion-sort O(n^2) can be done in-place Heap-sort
O(n log n) can be done in-place Bubble-sort O(n^2) can
be done in-place sequential access, so works well with
data on disk Merge-sort O(n log n) can be done in-place
sequential access, so works well with data on disk
Quick-sort worst: O(n^2) Average/expected: O(n log n)
can be done in-place requires randomization
Amortised Analysis
Aggregate Analysis: O(n)/n = O(1) find the worst case
time T(n) for any sequence of n operations. Amortized
cost of an operation is T(n)/n.
Accounting Method: overcharge certain operations to
pay for future ones. Total amount charged must be
enough to pay for the entire sequence of operations
Potential Method: Start with initial data structures D0,
Potential function: Φ(Di ), Real cost: ci and ai = ci +
Φ(Di) – Φ(Di-1) for i=1, 2, …n.
Average Case Costs
Expected value – Weighted average of random variable
among the various cases – E(X) = ∑ i X(case i)*P(case i)
Binomial distribution (discrete cases)- P(X=k) = (k!(n-
k)!/n!) pk (1-p)n-k – Expected value E(X)= np
Red-Black Trees – Balanced binary tree
Properties: Root is black, the children of a red node are
black, all leaves have the same black depth
To insert/remove, do as normal BST with new node Red
and then if violation, push upwards and rotations until
solved. Runs in O(log(n)) search insert delete.
AVL tree – a BST
Each node stores height of subtree
Constraint: left and right children of x have heights that
differ at most 1
The height of an AVL tree with n nodes is O(log n)
Binomial Queue – heap but faster merging or melding
Merge: compare roots of the binomial trees
Only has at most 1 tree for each k. Of order k has 2^k
nodes and height k. O(log(n) for everything
Treap - A BST and a heap
Heap order maintained with priorities, BST with the
keys
When added/constructing, heapify and then restore the
BST properties (downwards)
Search, delete and insert average O(log(n)), worst O(n)
Splay Tree – Move elements up
When node is accessed, it is splayed to the top of the
tree (inserted or searched for). When deleting, splay up
its parent.
To insert, do normal BST and splay up
Skip List
Insertion - to insert an entry(x,o) into a skip list, we use
a randomized algorithm. Get a random number that is
less than the height, search for x in the skip list by going
right, then down if too small.
Deletion – To remove an entry with key x from a skip
list, search for the skip list, going right then down if not
found. Remove it if found.
Space usage is O(n)
Search, insertion and deletion takes O(log(n))
Sorting Lower Bound
Any comparison-based sorting algorithm must run in
Ω(nlog(n)).
Selection
Quick-Select is a randomized selection algorithm based
on the prune-and-search paradigm.
Prune: pick a random element x (called pivot) and
partition S into less than, greater than, equal to x.
Search: depending on k, either answer is in E, or we
need to recur in either L or G.
Partition takes O(n) time