Foundations of Data Structures

Size: px

Start display at page:

Download "Foundations of Data Structures"

Clyde Campbell
6 years ago
Views:

1 Foundations of Data Structures Lecture 4 Elementary Abstract Data Types (ADT): Stack Queue 1

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 2

3 Linear Structures A structure is linearif it has these 2 properties: (P1) Each element is `followed by' at most one other element (P2) No two elements are `followed by' the same element An array is a linear structure. A->B->C->D Counter example 1 (violates P1): B<-A->C Counter example 2 (violates P2): A->C<-B 3

4 Stacks Linear structure. One end is called top. Other end is called bottom. Additions to and removals from the topend only. 4

5 Stack Of Cups top E top F E D D C C B B bottom A bottom A Add a cup to the stack. Remove a cup from new stack. A stack is a LIFO list. 5

6 Stack Specification A stack is either emptyor it consists of two parts: a top element a stack (the remaining elements). The elements in a stack may be of any type, but all the elements in a given stack must be the same type. 6

7 The Stack ADT: Data Stored The Stack ADT stores arbitrary objects Insertions and deletions follow the last-in firstout scheme Think of a spring-loaded plate dispenser 7

8 The Stack ADT: Operations 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 makeemptystack(): initialize an empty stack integer size(): returns the number of elements stored booleanisemptystack(): indicates whether no elements are stored 8

9 The Stack ADT: Exceptions 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 9

10 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 10

11 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 Algorithm size() return t + 1 Algorithm pop() if isempty() then throw EmptyStackException else t t 1 return S[t + 1] 11

12 Array-based Stack (cont.) 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 push(o) ift =S.length 1 then throw FullStackException else t t + 1 S[t] o 12

13 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 13

14 Computing Spans We show how to use a stack as an auxiliary data structure in an algorithm Given an an array X, the span S[i] ofx[i] is the maximum number of consecutive elements X[j] immediatelypreceding X[i] and such that X[j] X[i] Spans have applications to financial analysis 14

15 Quadratic Algorithm Algorithm spans1(x, n) Input arrayx ofn integers Output arrays of spans of X # S new array of n integers n fori 0ton 1do n s 1 n while s i X[i s] X[i] do (n 1) s s (n 1) S[i] s n return S 1 Algorithm spans1runs in O(n 2 ) time 15

16 Computing Spans with a Stack We keep in a stack the indices of the elements visible when looking back We scan the array from left to right Let i be the current index We pop indices from the stack until we find index jsuch that X[i]< X[j] We set S[i] i j We push ionto the stack

17 Linear Algorithm Each index of the array Is pushed into the stack exactly one Is popped from the stack at most once The statements in the while-loop are executed at most n times Algorithm spans2 runs in O(n) time Algorithm spans2(x, n) # S new array of n integers n A new empty stack 1 for i 0to n 1do n while ( A.isEmpty() X[top()] X[i] ) do n A.pop() n if A.isEmpty() then n S[i] i+1 n else S[i] i top() n A.push(i) n return S 1 Stacks 17

18 Parentheses Matching Each (, {, or [ must be paired with a matching ), }, or [ correct: ( )(( )){([( )])} correct: ((( )(( )){([( )])})) incorrect: )(( )){([( )])} incorrect: ({[ ])} incorrect: ( 18

19 Parentheses Matching Algorithm Algorithm ParenMatch(X,n) Input: An array X of n tokens, each of which is either a grouping symbol, a variable, an arithmetic operator, or a number Output: true if and only if all the grouping symbols in X match A new empty stack for i 0to n - 1 do if X[i] is an opening grouping symbol then S.push(X[i]) else if X[i] is a closing grouping symbol then if S.isEmpty() then return false {nothing to match with} if S.pop() does not match the type of X[i] then return false {wrong type} if S.isEmpty() then return true {every symbol matched} else return false {some symbols were never matched} 19

20 Example (((a+b)*c+d-e)/(f+g)-(h+j)*(k-l))/(m-n) 20

21 Infix to Postfix Conversion Rules: Operands immediately go directly to output Operators are pushed into the stack (including parenthesis) - Check to see if stack top operator is less than current operator - If the top operator is less than, push the current operator onto stack - If the top operator is greater than the current, pop top operator and print, push current operator onto stack - Priority 2: * / - Priority 1: Priority 0: ( If we encounter a right parenthesis, pop from stack until we get matching left parenthesis. Do not output parenthesis.

22 Infix to Postfix Example A + B * C - D / E Infix Stack(bot->top) Postfix a) A + B * C - D / E b) + B * C - D / E A c) B * C - D / E + A d) * C - D / E + A B e) C - D / E + * A B f) - D / E + * A B C g) D / E + - A B C * h) / E + - A B C * D i) E + - / A B C * D j) + - / A B C * D E k) A B C * D E / - +

23 Infix to Postfix Example #2 A * B - ( C + D ) + E Infix Stack(bot->top) Postfix a) A * B - ( C + D ) + E empty empty b) * B - ( C + D ) + E empty A c) B - ( C + D ) + E * A d) - ( C + D ) + E * A B e) - ( C + D ) + E empty A B * f) ( C + D ) + E - A B * g) C + D ) + E - ( A B * h) + D ) + E - ( A B * C i) D ) + E - ( + A B * C j) ) + E - ( + A B * C D k) + E - A B * C D + l) + E empty A B * C D + - m) E + A B * C D + - n) + A B * C D + - E o) empty A B * C D + - E +

24 Postfix Evaluation Operand: push Operator: pop 2 operands, do the math, pop result back onto stack * Postfix Stack( bot -> top ) a) * b) * 1 c) 3 + * 1 2 d) + * e) * 1 5 // 5 from f) 5 // 5 from 1 * 5

25 Rat In A Maze 25

26 Rat In A Maze Move order is: right,down,left, up Block positions to avoid revisit. 26

27 Rat In A Maze Move order is: right, down, left, up Block positions to avoid revisit. 27

28 Rat In A Maze Move backward until we reach a square from which a forward move is possible. 28

29 Rat In A Maze Move down. 29

30 Rat In A Maze Move left. 30

31 Rat In A Maze Move down. 31

32 Rat In A Maze Move backward until we reach a square from which a forward move is possible. 32

33 Rat In A Maze Move backward until we reach a square from which a forward move is possible. 33 Move downward.

34 Rat In A Maze Move right. Backtrack. 34

35 Rat In A Maze Move downward. 35

36 Rat In A Maze Move right. 36

37 Rat In A Maze Move one down and then right. 37

38 Rat In A Maze Move one up and then right. 38

39 Rat In A Maze Move down to exit and eat cheese. Path from maze entry to current position operates as a stack. 39

40 Rat In A Maze 40

41 Queue Linear list. One end is called front. Other end is called rear. Additions are done at the rearonly. Removals are made from the front only. 41

42 The Queue ADT: Data Stored The Queue ADT stores arbitrary objects Insertions and deletions follow the first-in first-out scheme (FIFO) Insertions are at the rear of the queue and removals are at the front of the queue 42

43 The Queue ADT: Operations Main 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 booleanisemptyqueue(): indicates whether no elements are stored createemptyqueue(): initialize an empty queue 43

44 The Queue ADT: Exceptions Attempting the execution of dequeue or front on an empty queue throws an EmptyQueueException 44

45 Queue Example Operation Output Q enqueue(5) (5) enqueue(3) (5, 3) dequeue() 5 (3) enqueue(7) (3, 7) dequeue() 3 (7) front() 7 (7) dequeue() 7 () dequeue() error () isempty() true () enqueue(9) (9) enqueue(7) (9, 7) size() 2 (9, 7) enqueue(3) (9, 7, 3) enqueue(5) (9, 7, 3, 5) dequeue() 9 (7, 3, 5) Queues 45

46 Array-based Queue Use an array of size Nin 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 normal configuration Q f r wrapped-around configuration Q r f Queues 46

47 Queue Operations We use the modulo operator (remainder of division) Algorithm size() return (N f+ r) mod N Q Q f r r f Queues 47

48 Queue Operations (cont.) Operation enqueue throws an exception if the array is full This exception is implementationdependent Algorithm enqueue(o) if size() = N 1then throw FullQueueException else Q[r] o r (r + 1) mod N Q Q f r r f Queues 48

49 Queue Operations (cont.) Operation dequeue throws an exception if the queue is empty This exception is specified in the queue ADT Algorithm dequeue() if isempty() then throw EmptyQueueException else o Q[f] f (f + 1) mod N return o Q Q f r r f Queues 49

50 Performance and Limitations Performance Let n be the number of elements in the queue The space used is O(n) Each operation runs in time O(1) Limitations Trying to enqueuea new element into a full queue or dequeuefrom an empty queue causes an implementation-specific exception 50

51 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 Queues 51

52 Lee s Wire Router start pin end pin Label all reachable squares 1 unit from start.

53 Lee s Wire Router start pin end pin 1 1 Label all reachable unlabeled squares 2 units from start.

54 Lee s Wire Router start pin end pin Label all reachable unlabeled squares 3 units from start.

55 Lee s Wire Router start pin end pin Label all reachable unlabeled squares 4 units from start.

56 Lee s Wire Router start pin end pin Label all reachable unlabeled squares 5 units from start.

57 Lee s Wire Router start pin end pin Label all reachable unlabeled squares 6 units from start.

58 Lee s Wire Router start pin end pin End pin reached. Traceback.

59 Lee s Wire Router start pin end pin End pin reached. Traceback.

Data Structures Lecture 5

Fall 2017 Fang Yu Software Security Lab. Dept. Management Information Systems, National Chengchi University Data Structures Lecture 5 Announcement Project Proposal due on Nov. 9 Remember to bring a hardcopy