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