Download presentation

Presentation is loading. Please wait.

Published byRhoda Montgomery Modified over 4 years ago

1
CHAPTER 05 Compiled by: Dr. Mohammad Omar Alhawarat Stacks & Queues

2
Overview Stacks and Queues Data structure holding a collection of objects, ordered by when they were inserted into the structure. Stack can access newest object. Queue can access oldest object. 2

3
Stacks 3 A stack is a linear collection whose elements are added and removed from the same end Stacks are processed in a last in, first out (LIFO) manner Usually, stacks are depicted vertically, and we refer to the top of the stack as the end to which elements are added and removed

4
Stack Operations 4 push: places an element onto the top of a stack pop: removes an element from the top of the stack peek: which retrieves (copies) a value from the top of the stack without removing it isempty: an operation to determine whether or not the stack is empty empty: an operation to empty out a stack

5
The Stack Interface 5

6
Iast-in, first-out or LIFO policy Last item pushed on the stack is next item popped off the stack. Example: A stack of plates. 6

7
The Stack Interface 7

8
Push 8 Push means place a new data element at the top of the stack 17 5 11 3

9
Push (cont.) 9 Push means place a new data element at the top of the stack 17 5 11 3

10
Push (cont.) 10 Push means place a new data element at the top of the stack 17 5 11 3

11
Push (cont.) 11 Push means place a new data element at the top of the stack 17 5 11 3

12
Pop 12 Pop means take a data element off the top of the stack 17 5 11 3

13
Pop (cont.) 13 Pop means take a data element off the top of the stack 17 5 11 3

14
Pop (cont.) 14 Pop means take a data element off the top of the stack 17 5 11 3

15
Pop (cont.) 15 Pop means take a data element off the top of the stack 17 5 11 3

16
Peek 16 Peek means retrieve the top of the stack without removing it 17 5 11 3

17
Peek (cont.) 17 Peek means retrieve the top of the stack without removing it 17 5 11 3 3

18
Peek (cont.) 18 Peek means retrieve the top of the stack without removing it 17 5 11 3 3

19
Linked-List Stack 19 Stacks can be implemented with a linked list The front node is the top of the stack

20
Linked-List Stack (cont.) 20 top To pop, we remove the node at the front of the linked list, and return the element to the client…

21
Linked-List Stack (cont.) 21 top To pop, we remove the node at the front of the linked list, and return the element to the client…

22
Linked-List Stack (cont.) 22 top To push, we place the new element in a node and insert it at the front of the linked list…

23
The Program (Call) Stack When a method is called Runtime environment creates activation record Shows method's state during execution Activation record pushed onto the program stack (Java stack) Top of stack belongs to currently executing method Next method down is the one that called current method 23

24
The Program Stack The program stack at 3 points in time; (a) when main begins execution; (b) when methodA begins execution, (c) when methodB begins execution. 24

25
Evaluating Postfix Expressions 25 Before looking further at the implementation of a stack, let's first see how one might be used Arithmetic operations are traditionally written in infix notation, meaning that the operator is placed between its operands in the form When evaluating infix expressions, we rely on precedence rules to determine the order of operator evaluation In a postfix expression, the operator comes after its two operands

26
Evaluating Postfix Expressions 26 The process of evaluating a postfix expression can be stated simply: scan from left to right, apply each operation to the two previous operands immediately preceding it and replace the operator with the result Consider the infix expression: 4 + 5 * 2 In postfix notation, it would be written as: 4 5 2 * +

27
Evaluating Postfix Expressions 27 Consider the design of a program that can compute the result of a postfix expression The evaluation rule relies on being able to retrieve the previous two operands whenever we encounter an operator A large postfix expression will have many operators and operands to manage A stack is the perfect collection to use in this solution

28
Evaluating Postfix Expressions 28 Solution algorithm: scan the expression from left to right, identifying each token as an operator or operand if the scanned token is an operand, push it onto the stack if the scanned token is an operator pop the top two elements off the stack, apply the operation to them, and push the result onto the stack If we reach the end of the expression the remaining element on the stack is the result of the expression (otherwise the expression was not well formed)

29
Using a Stack to Evaluate a Postfix Expression 29 Given the expression: 7 4 -3 * 1 5 + / * 7 7 top 4 4 -3 * * 1 1 5 5 + + / / -12 6 6 -2 -14 * *

30
Infix-to-Postfix Algorithm Symbol in Infix Action OperandAppend to end of output expression Operator ^Push ^ onto stack Operator +,-, *, or / Pop operators from stack, append to output expression until stack empty or top has lower precedence than new operator. Then push new operator onto stack Open parenthesis Push ( onto stack Close parenthesis Pop operators from stack, append to output expression until we pop an open parenthesis. Discard both parentheses. 30

31
Transforming Infix to Postfix Steps to convert the infix expression a / b * ( c + ( d – e ) ) to postfix form. 31

32
Evaluating Postfix Expression Fig. 21-10 The stack during the evaluation of the postfix expression a b / when a is 2 and b is 4 32

33
Evaluating Postfix Expression Fig. 21-11 The stack during the evaluation of the postfix expression a b + c / when a is 2, b is 4 and c is 3 33

34
Evaluating Infix Expressions Two stacks during evaluation of a + b * c when a = 2, b = 3, c = 4; (a) after reaching end of expression; (b) while performing multiplication; (c) while performing the addition 34

35
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 Stacks35

36
QUEUES 36 Definition: A sequence of elements of the same type. The first stored element is first accessible. The structure is known also under the name FIFO - first in first out

37
Basic operations 37 EnQueue : store a data item at the end of the queue DeQueue : retrieve a data item from the beginning of the queue

38
The Queue Interface Queue Very similar to a stack. Items are inserted in one end (the back) and removed from the other end (the front). first-in, first-out, or FIFO 38

39
The Queue Interface 39

40
Array Implementation of a Queue 40 Similar to the linked-list queue, there are two data members called front and back, but they are indexes into an Array instead of pointers When enqueuing, the back index is incremented, and when dequeuing, the front index is incremented

41
Enqueue / Dequeue 41 0 1 2 3 4 5 6 7 frontback

42
Enqueue / Dequeue (cont.) 42 frontback DEQUEUE 0 1 2 3 4 5 6 7

43
Enqueue / Dequeue (cont.) 43 frontback DEQUEUE 0 1 2 3 4 5 6 7

44
Enqueue / Dequeue (cont.) 44 frontback DEQUEUE 0 1 2 3 4 5 6 7

45
Enqueue / Dequeue (cont.) 45 frontback DEQUEUE 0 1 2 3 4 5 6 7

46
Enqueue / Dequeue (cont.) 46 frontback ENQUEUE 0 1 2 3 4 5 6 7

47
Enqueue / Dequeue (cont.) 47 0 1 2 3 4 5 6 7 frontback ENQUEUE

48
Enqueue / Dequeue (cont.) 48 0 1 2 3 4 5 6 7 frontback ENQUEUE

49
Enqueue / Dequeue (cont.) 49 0 1 2 3 4 5 6 7 frontback ENQUEUE

50
50 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

51
51 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

52
52 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

53
53 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

54
54 0 1 2 3 4 5 6 7 frontback ENQUEUE Enqueue / Dequeue (cont.)

55
55 0 1 2 3 4 5 6 7 frontback ENQUEUE Enqueue / Dequeue (cont.)

56
56 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

57
57 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

58
58 0 1 2 3 4 5 6 7 frontback DEQUEUE Enqueue / Dequeue (cont.)

59
59 0 1 2 3 4 5 6 7 frontback ENQUEUE Enqueue / Dequeue (cont.)

60
60 0 1 2 3 4 5 6 7 frontback ENQUEUE ? Enqueue / Dequeue (cont.)

61
61 0 1 2 3 4 5 6 7 frontback ENQUEUE We could double the size of the array here. Enqueue / Dequeue (cont.)

62
62 0 1 2 3 4 5 6 7 frontback ENQUEUE But if we keep doing this, we may have a million elements in the Array, but only a few at the end are used! Enqueue / Dequeue (cont.)

63
63 0 1 2 3 4 5 6 7 frontback ENQUEUE We handle this problem by having the back wrap around to the beginning of the array. Enqueue / Dequeue (cont.)

64
64 0 1 2 3 4 5 6 7 frontback ENQUEUE Enqueue / Dequeue (cont.)

65
65 0 1 2 3 4 5 6 7 frontback The front also wraps to the beginning when it reaches the end of the array Enqueue / Dequeue (cont.)

66
How Do We Know When the Array is Full? 66 We may still need to double the capacity of the array if it gets filled An array will be full when back + 1 == front OR back + 1 == capacity AND front == 0

67
A Full Array 67 0 1 2 3 4 5 6 7 frontback

68
A Full Array 68 0 1 2 3 4 5 6 7 frontback If the next operation is ENQUEUE, the array capacity will need to be doubled

69
Implementing Queues with Links 69 Because a queue is a linear collection, we can implement a queue as a linked list of LinearNode objects, as we did with stacks One important difference, however, is that we will have to operate on both ends of the list So we'll add an additional reference variable ( rear ) that points to the last element in the list

70
Dequeue Operation 70 front back header

71
Dequeue Operation (cont.) 71 front back header

72
Enqueue Operation 72 front back header

73
Enqueue Operation (cont.) 73 front back header

74
Summary Stacks and queues are collections of objects. Stack follows a last-in, first-out policy. Objects are pushed onto and popped off the top. Queue follows a first-in, first-out policy. Objects are added to the back and removed from the front. 74

Similar presentations

© 2020 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google