1. ADT Stacks and Queues

2. Stack: Logical Level “An ordered group of homogeneous items or elements in which items are added and removed from only one end.” A stack is also called a Last In First Out (LIFO) data structure.

3. Stack: Logical Level Stack Operations: Boolean IsEmpty () Boolean IsFull () Push (ItemType newitem) void Pop () ItemType Top ()

4. Stack: Application Level A runtime stack of activation records (ar) is maintained as a program executes to track function calls and scopes. Each activation record contains – space for local variables and parameters – ptr to dynamic parent – ptr to static parent – return address

5. Consider this code outline: // ------------------------------ void B ( ) { } // ------------------------------ void A ( ) { B (); } // ------------------------------ int main ( ) { A (); return 0; }

6. Consider the following: main begins executing main calls function A function A calls function B function B returns function A returns main returns Push (main’s ar) Push (A’s ar) Push (B’s ar) Use info in Top ar to return control to A Pop Use info in Top ar to return control to main Pop Use info in Top ar to return control to OS Pop main A B Runtime Stack

7. Stack: Application Level Stacks can be used to analyze nested expressions with grouping symbols to determine if they are well-formed (all grouping symbols occur in matching pairs and are nested properly.) ( ( {xxx} ) x [ ] xx) is well-formed ( ( {xxx} x [ ] ) is ill-formed

8. General Algorithm get next symbol set balanced flag to true while (there are more input symbols and expression still balanced) if (next symbol is opening symbol) Push symbol onto stack else if (next symbol is closing symbol) if (stack is empty) set balanced to false else use Top to get copy of opening symbol on top of stack Pop the stack if (opening symbol does not match closing symbol) set balanced to false else ignore symbol get next symbol if (balanced and stack is empty) well-formed else ill-formed ( ( { x x x } ) x [ ] x x ) ( ( { [ Stack

9. Stack: Implementation Level Using an array:...... items [0] [MAX_ITEMS - 1] top

10. Stack: Implementation Level Using an array: 70...... items [0] [MAX_ITEMS - 1] 0 top Push ( 70 )

11. Stack: Implementation Level Using an array: 70 28...... items [0] [MAX_ITEMS - 1] 1 top Push ( 70 ) Push ( 28)

12. Stack: Implementation Level Using an array: 70 28 88...... items [0] [MAX_ITEMS - 1] 2 top Push ( 70 ) Push ( 28) Push ( 88)

13. Stack: Implementation Level Using an array: 70 28 88...... items [0] [MAX_ITEMS - 1] 1 top Push ( 70 ) Push ( 28) Push ( 88) Pop

14. Stack: Implementation Level Using an array: 70 28 95...... items [0] [MAX_ITEMS - 1] 2 top Push ( 70 ) Push ( 28) Push ( 88) Pop Push ( 95)

15. Stack: Implementation Level Using an array: 70 28 95...... items [0] [MAX_ITEMS - 1] 1 top Push ( 70 ) Push ( 28) Push ( 88) Pop Push ( 95) Pop

16. Stack: Implementation Level Using an array: 70 28 95...... items [0] [MAX_ITEMS - 1] 0 top Push ( 70 ) Push ( 28) Push ( 88) Pop Push ( 95) Pop

17. Stack: Implementation Level Using an array: 70 28 95...... items [0] [MAX_ITEMS - 1] top Push ( 70 ) Push ( 28) Push ( 88) Pop Push ( 95) Pop

18. Stack: Implementation Level Using a linked list: top NULL

19. Stack: Implementation Level Using a linked list: top NULL Push ( 70 ) 70

20. Stack: Implementation Level Using a linked list: top NULL Push ( 70 ) Push ( 28 ) 2870

21. Stack: Implementation Level Using a linked list: top NULL Push ( 70 ) Push ( 28 ) Push ( 88 ) 882870

22. Stack: Implementation Level Using a linked list: top NULL 2870 Push ( 70 ) Push ( 28 ) Push ( 88 ) Pop

23. Stack: Implementation Level Using a linked list: top NULL Push ( 70 ) Push ( 28 ) Push ( 88 ) Pop Push ( 95 ) 952870

24. Stack: Implementation Level Using a linked list: top NULL 2870 Push ( 70 ) Push ( 28 ) Push ( 88 ) Pop Push ( 95 ) Pop

25. Stack: Implementation Level Using a linked list: top NULL 70 Push ( 70 ) Push ( 28 ) Push ( 88 ) Pop Push ( 95 ) Pop

26. Stack: Implementation Level Using a linked list: top NULL Push ( 70 ) Push ( 28 ) Push ( 88 ) Pop Push ( 95 ) Pop

27. Queue: Logical Level “An ordered group of homogeneous items or elements in which items are added at one end (the rear) and removed from the other end (the front.)” A queue is also called a First In First Out (FIFO) data structure.

28. Queue: Logical Level Queue Operations: Boolean IsEmpty () Boolean IsFull () void Enqueue (ItemType newitem) void Dequeue (ItemType& newitem)

29. Queue: Application Level Perfect for modeling a waiting line in a simulation program Key simulation parameters – # of servers – # of queues (waiting lines) – statistics for customer arrival patterns Want to minimize customer waiting time Want to minimize server idle time

30. Queue: Application Level Queues found all over operating system! – I/O buffers – Job queues waiting for various resources – Spool (print) queue

31. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1]... rear front - fixed at [0] (similar to bottom of stack)

32. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1] 0 A... rear front - fixed at [0] (similar to bottom of stack) Enqueue (A)

33. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1] 1 AB... rear front - fixed at [0] (similar to bottom of stack) Enqueue (A) Enqueue (B)

34. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1] 2 ABC... rear front - fixed at [0] (similar to bottom of stack) Enqueue (A) Enqueue (B) Enqueue (C)

35. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1] 2 ABC... rear front - fixed at [0] (similar to bottom of stack) Enqueue (A) Enqueue (B) Enqueue (C) Dequeue(ch) But now front is at position[1], not [0] Need to shift remaining items down!

36. Queue: Implementation Level Using an array: Option 1 items [0] [MAXQUEUE - 1] 1 BC... rear front - fixed at [0] (similar to bottom of stack) Enqueue (A) Enqueue (B) Enqueue (C) Dequeue(ch) After the shifting Is this a very efficient implementation?

37. Queue: Implementation Level Using an array: Option 2 items [0][4] rear front 0 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear

38. Queue: Implementation Level Using an array: Option 2 items [0][4] 0 A rear front 0 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A)

39. Queue: Implementation Level Using an array: Option 2 items [0][4] 1 AB rear front 0 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B)

40. Queue: Implementation Level Using an array: Option 2 items [0][4] 2 ABC rear front 0 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C)

41. Queue: Implementation Level Using an array: Option 2 items [0][4] 3 ABCD rear front 0 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D)

42. Queue: Implementation Level Using an array: Option 2 items [0][4] 3 ABCD rear front 1 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch)

43. Queue: Implementation Level Using an array: Option 2 items [0][4] 3 ABCD rear front 2 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch)

44. Queue: Implementation Level Using an array: Option 2 items [0][4] 4 ABCDE rear front 2 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch) Enqueue (E) Hmm... Queue now appears full, but there are two unused positions in array! Why not let Queue elements “wrap around” in array?

45. Queue: Implementation Level Using an array: Option 2 items [0][4] 0 FBCDE rear front 2 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front – 1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch) Enqueue (E) Enqueue (F) Note: to advance the rear indicator : rear = (rear + 1) % MAXQUEUE

46. Queue: Implementation Level Using an array: Option 2 items [0][4] 1 FGCDE rear front 2 Note: Let MAXQUEUE = 5 for the example Keep track of both front and rear Note: queue is empty when (front -1) == rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch) Enqueue (E) Enqueue (F) Enqueue (G) Note: to advance the rear indicator : rear = (rear + 1) % MAXQUEUE Now queue REALLY IS full! But look at values of front and rear... (front-1) == rear Yikes! This is supposed to mean queue is empty !!!

47. Queue: Implementation Level Using an array: Option 3 items [0][4] 4 rear front 4 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear queue is empty when front == rear front indicates position just before actual front queue is full when (rear + 1) % MAXQUEUE == front (when next Enqueue would put item in unused position.) This position must remain unused, effectively reducing size of queue by 1

48. Queue: Implementation Level Using an array: Option 3 items [0][4] 0 A rear front 4 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A)

49. Queue: Implementation Level Using an array: Option 3 items [0][4] 1 AB rear front 4 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B)

50. Queue: Implementation Level Using an array: Option 3 items [0][4] 2 ABC rear front 4 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C)

51. Queue: Implementation Level Using an array: Option 3 items [0][4] 3 ABCD rear front 4 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) (Note: queue full)

52. Queue: Implementation Level Using an array: Option 3 items [0][4] 3 ABCD rear front 0 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch)

53. Queue: Implementation Level Using an array: Option 3 items [0][4] 3 ABCD rear front 1 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch)

54. Queue: Implementation Level Using an array: Option 3 items [0][4] 3 ABCD rear front 2 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch)

55. Queue: Implementation Level Using an array: Option 3 items [0][4] 3 ABCD rear front 3 Note: Let MAXQUEUE = 5 for the example Still keep track of both front and rear Enqueue (A) Enqueue (B) Enqueue (C) Enqueue (D) Dequeue (ch) Dequeue (ch) (Note: queue empty)

56. Queue: Implementation Level Using a linked list: front NULL rear NULL

57. Queue: Implementation Level Using a linked list: front NULL rear A Enqueue (A)

58. Queue: Implementation Level Using a linked list: front NULL rear A Enqueue (A) Enqueue (B) B

59. Queue: Implementation Level Using a linked list: front NULL rear A Enqueue (A) Enqueue (B) Enqueue (C) BC

60. Queue: Implementation Level Using a linked list: front NULL rear B Enqueue (A) Enqueue (B) Enqueue (C) Dequeue (ch) C

61. Queue: Implementation Level Using a linked list: front NULL rear C Enqueue (A) Enqueue (B) Enqueue (C) Dequeue (ch)

62. Queue: Implementation Level Using a linked list: front NULL rear NULL Enqueue (A) Enqueue (B) Enqueue (C) Dequeue (ch)