View
257
Download
2
Embed Size (px)
Citation preview
Elementary Data Structures
Stacks, Queues, & ListsAmortized analysisTrees
Elementary Data Structures 2
Abstract Data Types (ADTs)
An abstract data type (ADT) is an abstraction of a data structureAn ADT specifies: Data stored Operations on
the data Error conditions
associated with operations
Example: ADT modeling a simple stock trading system The data stored are buy/sell
orders The operations supported are
order buy(stock, shares, price) order sell(stock, shares, price) void cancel(order)
Error conditions: Buy/sell a nonexistent stock Cancel a nonexistent order
Stacks
Elementary Data Structures 4
Outline and Reading
The Stack ADT (§2.1.1)Applications of Stacks (§2.1.1)Array-based implementation (§2.1.1)Growable array-based stack (§1.5)
Elementary Data Structures 5
The Stack ADT
The Stack ADT stores arbitrary objectsInsertions and deletions follow the last-in first-out schemeThink of a spring-loaded plate dispenserMain stack operations:
push(object): inserts an element
object pop(): removes and returns the last inserted element
Auxiliary stack operations:
object top(): returns the last inserted element without removing it
integer size(): returns the number of elements stored
boolean isEmpty(): indicates whether no elements are stored
Elementary Data Structures 6
Exceptions
Attempting the execution of an operation of ADT may sometimes cause an error condition, called an exceptionExceptions 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 emptyAttempting the execution of pop or top on an empty stack throws an EmptyStackException
Elementary Data Structures 7
Applications of Stacks
Direct applications Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java
Virtual Machine or C++ runtime environment
Indirect applications Auxiliary data structure for algorithms Component of other data structures
Elementary Data Structures 8
Method Stack in the JVM
The Java Virtual Machine (JVM) keeps track of the chain of active methods with a stackWhen a method is called, the JVM pushes on the stack a frame containing
Local variables and return value Program counter, keeping track
of the statement being executed
When a method ends, its frame is popped from the stack and control is passed to the method on top of the stack
1 main() { int i = 5;
3 foo(i); }
foo(int j) { int k; k = j+1;
7 bar(k);
…. }
9 bar(int m) { … }
bar PC = 9 m = 6
foo PC = 7 j = 5 k = 6
main PC = 3 i = 5
Elementary Data Structures 9
Array-based Stack
A simple way of implementing the Stack ADT uses an arrayWe add elements from left to rightA variable keeps track of the index of the top element (size is t+1)
S0 1 2 t
…
Algorithm size()return t + 1
Algorithm pop()if isEmpty() then
throw EmptyStackException else
t t 1return S[t + 1]
Elementary Data Structures 10
Array-based Stack (cont.)
The array storing the stack elements may become fullA push operation will then throw a FullStackException
Limitation of the array-based implementation
Not intrinsic to the Stack ADT
S0 1 2 t
…
Algorithm push(o)if t = S.length 1 then
throw FullStackException else
t t + 1S[t] o
Elementary Data Structures 11
Performance and Limitations
Performance Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1)
Limitations The maximum size of the stack must be
defined a priori and cannot be changed Trying to push a new element into a full stack
causes an implementation-specific exception
Elementary Data Structures 12
Growable Array-based Stack
In a push operation, when the array is full, instead of throwing an exception, we can replace the array with a larger oneHow large should the new array be? incremental strategy:
increase the size by a constant c
doubling strategy: double the size
Algorithm push(o)if t = S.length 1 then
A new array ofsize …
for i 0 to t do A[i] S[i] S A
t t + 1S[t] o
Elementary Data Structures 13
Comparison of the Strategies
We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operationsWe assume that we start with an empty stack represented by an array of size 1We call amortized time of a push operation the average time taken by a push over the series of operations, i.e., T(n)/n
Elementary Data Structures 14
Incremental Strategy Analysis
We replace the array k = n/c timesThe total time T(n) of a series of n push operations is proportional to
n + c + 2c + 3c + 4c + … + kc =n + c(1 + 2 + 3 + … + k) =
n + ck(k + 1)/2Since c is a constant, T(n) is O(n + k2), i.e., O(n2)The amortized time of a push operation is O(n)
Elementary Data Structures 15
Doubling Strategy Analysis
We replace the array k = log2 n timesThe total time T(n) of a series of n push operations is proportional to
n + 1 + 2 + 4 + 8 + …+ 2k =n 2k + 1 1 = 2n 1
T(n) is O(n)The amortized time of a push operation is O(1)
geometric series
1
2
14
8
Elementary Data Structures 16
The accounting method determines the amortized running time with a system of credits and debitsWe view a computer as a coin-operated device requiring 1 cyber-dollar for a constant amount of computing.
Accounting Method Analysis of the Doubling Strategy
We set up a scheme for charging operations. This is known as an amortization scheme.
The scheme must give us always enough money to pay for the actual cost of the operation.
The total cost of the series of operations is no more than the total amount charged.
(amortized time) (total $ charged) / (# operations)
Elementary Data Structures 17
Amortization Scheme for the Doubling Strategy
Consider again the k phases, where each phase consisting of twice as many pushes as the one before.At the end of a phase we must have saved enough to pay for the array-growing push of the next phase.At the end of phase i we want to have saved i cyber-dollars, to pay for the array growth for the beginning of the next phase.
0 2 4 5 6 731
$ $ $ $
$ $ $ $
0 2 4 5 6 7 8 9 113 10 12 13 14 151
$
$
• We charge $3 for a push. The $2 saved for a regular push are “stored” in the second half of the array. Thus, we will have 2(i/2)=i cyber-dollars saved at then end of phase i.• Therefore, each push runs in O(1) amortized time; n pushes run in O(n) time.
Queues
Elementary Data Structures 19
Outline and Reading
The Queue ADT (§2.1.2)Implementation with a circular array (§2.1.2)Growable array-based queueQueue interface in Java
Elementary Data Structures 20
The Queue ADTThe Queue ADT stores arbitrary objectsInsertions and deletions follow the first-in first-out schemeInsertions are at the rear of the queue and removals are at the front of the queueMain queue operations:
enqueue(object): inserts an element at the end of the queue
object dequeue(): removes and returns the element at the front of the queue
Auxiliary queue operations:
object front(): returns the element at the front without removing it
integer size(): returns the number of elements stored
boolean isEmpty(): indicates whether no elements are stored
Exceptions Attempting the execution
of dequeue or front on an empty queue throws an EmptyQueueException
Elementary Data Structures 21
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
Elementary Data Structures 22
Array-based Queue
Use an array of size N in a circular fashionTwo variables keep track of the front and rearf index of the front elementr index immediately past the rear element
Array location r is kept empty
Q0 1 2 rf
normal configuration
Q0 1 2 fr
wrapped-around configuration
Elementary Data Structures 23
Queue Operations
We use the modulo operator (remainder of division)
Algorithm size()return (N f + r) mod N
Algorithm isEmpty()return (f r)
Q0 1 2 rf
Q0 1 2 fr
Elementary Data Structures 24
Queue Operations (cont.)
Algorithm enqueue(o)if size() = N 1 then
throw FullQueueException else
Q[r] or (r + 1) mod N
Operation enqueue throws an exception if the array is fullThis exception is implementation-dependent
Q0 1 2 rf
Q0 1 2 fr
Elementary Data Structures 25
Queue Operations (cont.)
Operation dequeue throws an exception if the queue is emptyThis exception is specified in the queue ADT
Algorithm dequeue()if isEmpty() then
throw EmptyQueueException else
o Q[f]f (f + 1) mod Nreturn o
Q0 1 2 rf
Q0 1 2 fr
Elementary Data Structures 26
Growable Array-based Queue
In an enqueue operation, when the array is full, instead of throwing an exception, we can replace the array with a larger oneSimilar to what we did for an array-based stackThe enqueue operation has amortized running time O(n) with the incremental strategy O(1) with the doubling strategy
Elementary Data Structures 27
Queue Interface in Java
Java interface corresponding to our Queue ADTRequires the definition of class EmptyQueueExceptionNo corresponding built-in Java class
public interface Queue {
public int size();
public boolean isEmpty();
public Object front()throws EmptyQueueException;
public void enqueue(Object o);
public Object dequeue() throws EmptyQueueException;
}
Vectors
Elementary Data Structures 29
Outline and Reading
The Vector ADT (§2.2.1)Array-based implementation (§2.2.1)
Elementary Data Structures 30
The Vector ADTThe Vector ADT extends the notion of array by storing a sequence of arbitrary objectsAn element can be accessed, inserted or removed by specifying its rank (number of elements preceding it)An exception is thrown if an incorrect rank is specified (e.g., a negative rank)
Main vector operations: object elemAtRank(integer r):
returns the element at rank r without removing it
object replaceAtRank(integer r, object o): replace the element at rank with o and return the old element
insertAtRank(integer r, object o): insert a new element o to have rank r
object removeAtRank(integer r): removes and returns the element at rank r
Additional operations size() and isEmpty()
Elementary Data Structures 31
Applications of Vectors
Direct applications Sorted collection of objects
(elementary database)
Indirect applications Auxiliary data structure for algorithms Component of other data structures
Elementary Data Structures 32
Array-based VectorUse an array V of size NA variable n keeps track of the size of the vector (number of elements stored)Operation elemAtRank(r) is implemented in O(1) time by returning V[r]
V0 1 2 nr
Elementary Data Structures 33
InsertionIn operation insertAtRank(r, o), we need to make room for the new element by shifting forward the n r elements V[r], …, V[n 1]In the worst case (r 0), this takes O(n) time
V0 1 2 nr
V0 1 2 nr
V0 1 2 n
or
Elementary Data Structures 34
DeletionIn operation removeAtRank(r), we need to fill the hole left by the removed element by shifting backward the n r 1 elements V[r 1], …, V[n 1]In the worst case (r 0), this takes O(n) time
V0 1 2 nr
V0 1 2 n
or
V0 1 2 nr
Lists and Sequences
Elementary Data Structures 36
Outline and Reading
Singly linked listPosition ADT and List ADT (§2.2.2)Doubly linked list (§ 2.2.2)Sequence ADT (§ 2.2.3)Implementations of the sequence ADT (§ 2.2.3)Iterators (2.2.3)
Elementary Data Structures 37
Singly Linked ListA singly linked list is a concrete data structure consisting of a sequence of nodesEach node stores
element link to the next node
next
elem node
A B C D
Elementary Data Structures 38
Stack with a Singly Linked List
We can implement a stack with a singly linked listThe top element is stored at the first node of the listThe space used is O(n) and each operation of the Stack ADT takes O(1) time
t
nodes
elements
Elementary Data Structures 39
Queue with a Singly Linked List
We can implement a queue with a singly linked list The front element is stored at the first node The rear element is stored at the last node
The space used is O(n) and each operation of the Queue ADT takes O(1) time
f
r
nodes
elements
Elementary Data Structures 40
Position ADTThe Position ADT models the notion of place within a data structure where a single object is storedIt gives a unified view of diverse ways of storing data, such as a cell of an array a node of a linked list
Just one method: object element(): returns the element
stored at the position
Elementary Data Structures 41
List ADT
The List ADT models a sequence of positions storing arbitrary objectsIt establishes a before/after relation between positionsGeneric methods:
size(), isEmpty()
Query methods: isFirst(p), isLast(p)
Accessor methods: first(), last() before(p), after(p)
Update methods: replaceElement(p,
o), swapElements(p, q)
insertBefore(p, o), insertAfter(p, o),
insertFirst(o), insertLast(o)
remove(p)
Elementary Data Structures 42
Doubly Linked ListA doubly linked list provides a natural implementation of the List ADTNodes implement Position and store:
element link to the previous node link to the next node
Special trailer and header nodes
prev next
elem
trailerheader nodes/positions
elements
node
Elementary Data Structures 43
InsertionWe visualize operation insertAfter(p, X), which returns position q
A B X C
A B C
p
A B C
p
X
q
p q
Elementary Data Structures 44
DeletionWe visualize remove(p), where p = last()
A B C D
p
A B C
D
p
A B C
Elementary Data Structures 45
PerformanceIn the implementation of the List ADT by means of a doubly linked list The space used by a list with n
elements is O(n) The space used by each position of the
list is O(1) All the operations of the List ADT run in
O(1) time Operation element() of the
Position ADT runs in O(1) time
Elementary Data Structures 46
Sequence ADTThe Sequence ADT is the union of the Vector and List ADTsElements accessed by
Rank, or Position
Generic methods: size(), isEmpty()
Vector-based methods: elemAtRank(r),
replaceAtRank(r, o), insertAtRank(r, o), removeAtRank(r)
List-based methods: first(), last(),
before(p), after(p), replaceElement(p, o), swapElements(p, q), insertBefore(p, o), insertAfter(p, o), insertFirst(o), insertLast(o), remove(p)
Bridge methods: atRank(r), rankOf(p)
Elementary Data Structures 47
Applications of SequencesThe Sequence ADT is a basic, general-purpose, data structure for storing an ordered collection of elementsDirect applications: Generic replacement for stack, queue, vector,
or list small database (e.g., address book)
Indirect applications: Building block of more complex data structures
Elementary Data Structures 48
Array-based Implementation
We use a circular array storing positions A position object stores:
Element Rank
Indices f and l keep track of first and last positions
0 1 2 3
positions
elements
S
lf
Elementary Data Structures 49
Sequence ImplementationsOperation Array List
size, isEmpty 1 1
atRank, rankOf, elemAtRank 1 n
first, last, before, after 1 1
replaceElement, swapElements 1 1
replaceAtRank 1 n
insertAtRank, removeAtRank n n
insertFirst, insertLast 1 1
insertAfter, insertBefore n 1
remove n 1
Elementary Data Structures 50
IteratorsAn iterator abstracts the process of scanning through a collection of elementsMethods of the ObjectIterator ADT:
object object() boolean hasNext() object nextObject() reset()
Extends the concept of Position by adding a traversal capabilityImplementation with an array or singly linked list
An iterator is typically associated with an another data structureWe can augment the Stack, Queue, Vector, List and Sequence ADTs with method:
ObjectIterator elements()
Two notions of iterator: snapshot: freezes the
contents of the data structure at a given time
dynamic: follows changes to the data structure