Elementary Data Structures Stacks, Queues, & Lists Amortized analysis Trees.

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


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)


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


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


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


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


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]


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


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


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


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


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)


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


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)


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


Outline and Reading

The Queue ADT (§2.1.2)Implementation with a circular array (§2.1.2)Growable array-based queueQueue interface in Java


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


Applications of Queues

Direct applications Waiting lists, bureaucracy Access to shared resources (e.g.,

printer) Multiprogramming



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


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


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


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


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


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


Outline and Reading

The Vector ADT (§2.2.1)Array-based implementation (§2.2.1)


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()


Applications of Vectors

Direct applications Sorted collection of objects

(elementary database)



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


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


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


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)


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


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


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


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


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)


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


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


DeletionWe visualize remove(p), where p = last()

A B C D

p

A B C

D

p

A B C


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


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)


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


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


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


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

Date post:	19-Dec-2015
Category:	Documents
View:	244 times
Download:	2 times

Elementary Data Structures Stacks, Queues, & Lists Amortized analysis Trees.

Documents