1. CSC401 – Analysis of Algorithms Lecture Notes 3 Basic Data Structures Objectives: Introduce basic data structures, including –Stacks –Queues –Vectors –Lists –Sequences Analyze the performance of operations on basic data structures

2. 2 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 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

3. 3 The Stack ADT The Stack ADT stores arbitrary objects Insertions and deletions follow the last-in first-out scheme Think of a spring-loaded plate dispenser Main 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 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 EmptyStackException

4. 4 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 Indirect applications –Auxiliary data structure for algorithms –Component of other data structures The Java Virtual Machine (JVM) keeps track of the chain of active methods with a stack When 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 main() { int i = 5; foo(i); } foo(int j) { int k; k = j+1; bar(k); } bar(int m) { … } bar PC = 1 m = 6 foo PC = 3 j = 5 k = 6 main PC = 2 i = 5

5. 5 Array-based Stack A simple way of implementing the Stack ADT uses an array We add elements from left to right A variable keeps track of the index of the top element 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 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 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 fixed maximum size –Trying to push a new element into a full stack causes an implementation- specific exception

6. 6 Other Implementations of Stack –Extendable array-based stack –Linked list-based stack Stack Interface & ArrayStack in Java public interface Stack { public int size(); public boolean isEmpty(); public Object top() throws EmptyStackException; public void push(Object o); public Object pop() throws EmptyStackException; } public class ArrayStack implements Stack { private Object S[ ]; private int top = -1; public ArrayStack(int capacity) { S = new Object[capacity]); } public Object pop() throws EmptyStackException { if isEmpty() throw new EmptyStackException (“Empty stack: cannot pop”); Object temp = S[top]; S[top] = null; top = top – 1; return temp; } }

7. 7 The Queue ADT The Queue ADT stores arbitrary objects Insertions and deletions follow the first-in first-out scheme Insertions are at the rear and removals at the front Main queue operations: –enqueue(object): inserts an element at the end of the queue –object dequeue(): removes and returns the element at the front 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 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

8. 8 Array-based 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 Q 012rf normal configuration Q 012fr wrapped-around configuration

9. 9 Array-based Queue Operations 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 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

10. 10 Other Implementations of Queue –Extendable array-based queue: The enqueue operation has amortized running time O(n) with the incremental strategy O(1) with the doubling strategy –Linked list-based queue Queue Interface in Java public interface Queue { public int size(); public boolean isEmpty(); public Object front() throws EmptyQueueException; public void enqueue(Object o); public Object dequeue() throws EmptyQueueException; } Java interface corresponding to our Queue ADT Requires the definition of class EmptyQueueException No corresponding built-in Java class

11. 11 The Vector ADT The Vector ADT extends the notion of array by storing a sequence of arbitrary objects An 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() Direct applications –Sorted collection of objects (elementary database) Indirect applications –Auxiliary data structure for algorithms –Component of other data structures

12. 12 Array-based Vector Use an array V of size N A 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] returning V[r] V 012n r V 012n r V 012n o r V 012n r In 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 ), case ( r  0 ), this takes this takes O(n) time O(n) time

13. 13 Array-based Vector In 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 ), case ( r  0 ), this takes this takes O(n) time O(n) time V 012n r V 012n o r V 012n r Performance –In the array based implementation of a Vector The space used by the data structure is O(n) size, isEmpty, elemAtRank and replaceAtRank run in O(1) time insertAtRank and removeAtRank run in O(n) time –If we use the array in a circular fashion, insertAtRank(0) and removeAtRank(0) run in O(1) time –In an insertAtRank operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one (extendable array)

14. 14 Singly Linked List A singly linked list is a concrete data structure consisting of a sequence of nodes Each node stores –element –link to the next node next elem node ABCD  Stack with singly linked list –The top element is stored at the first node of the list –The space used is O(n) and each operation of the Stack ADT takes O(1) time Queue with 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

15. 15 Position ADT & List ADT The Position ADT –models the notion of place within a data structure where a single object is stored –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 The List ADT –models a sequence of positions storing arbitrary objects –establishes a before/after relation between positions –Generic 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)

16. 16 Doubly Linked List A doubly linked list provides a natural implementation of the List ADT Nodes implement Position and store: –element –link to the previous node –link to the next node Special trailer and header nodes trailer header nodes/positions elements prevnext elem node

17. 17 Doubly Linked List Operations We visualize insertAfter(p, X), which returns position q p ABC ABC p X q ABX C pq We visualize remove(p), where p = last() ABCD p ABC D p ABC Performance –The space used by a doubly linked 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

18. 18 Sequence ADT The Sequence ADT is the union of the Vector and List ADTs Elements 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) The Sequence ADT is a basic, general-purpose, data structure for storing an ordered collection of elements Direct applications: –Generic replacement for stack, queue, vector, or list –small database Indirect applications: –Building block of more complex data structures

19. 19 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 0123 positions elements S lf

20. 20 Sequence Implementations nn insertAtRank, removeAtRank 11 insertFirst, insertLast 1n insertAfter, insertBefore n1replaceAtRank 11 replaceElement, swapElements n1 atRank, rankOf, elemAtRank 11 size, isEmpty 1nremove 11 first, last, before, after ListArrayOperation

21. 21 Design Patterns AdaptorPositionCompositionIteratorComparatorLocator

22. 22 Design Pattern: Iterators An iterator abstracts the process of scanning through a collection of elements Methods of the ObjectIterator ADT: –object object() –boolean hasNext() –object nextObject() –reset() Extends the concept of Position by adding a traversal capability Implementation with an array or singly linked list An iterator is typically associated with an another data structure We 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

23. 23 The Tree Structure In computer science, a tree is an abstract model of a hierarchical structure A tree consists of nodes with a parent-child relation Applications: –Organization charts –File systems –Programming environments Computers”R”Us SalesR&DManufacturing LaptopsDesktops US International EuropeAsiaCanada

24. 24 subtree Tree Terminology Root: node without parent (A) Internal node: node with at least one child (A, B, C, F) External node (a.k.a. leaf ): node without children (E, I, J, K, G, H, D) Ancestors of a node: parent, grandparent, grand-grandparent, etc. Depth of a node: number of ancestors Height of a tree: maximum depth of any node (3) Descendant of a node: child, grandchild, grand-grandchild, etc. A B DC GH E F IJ K Subtree: tree consisting of a node and its descendants

25. 25 Tree ADT We use positions to abstract nodes Generic methods: –integer size() –boolean isEmpty() –objectIterator elements() –positionIterator positions() Accessor methods: –position root() –position parent(p) –positionIterator children(p) Query methods: –boolean isInternal(p) –boolean isExternal(p) –boolean isRoot(p) Update methods: –swapElements(p, q) –object replaceElement(p, o) Additional update methods may be defined by data structures implementing the Tree ADT