1. 1 Chapter 7 Stacks and Queues

2. 2 Stack ADT Recall that ADT is abstract data type, a set of data and a set of operations that act upon the data. In a stack, the set of data is the stack of elements. Stack is known as a LIFO (last-in-first-out) data structure because the last data to enter the stack is the first to exit the stack.

3. 3 Stack ADT Operations 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. an operation to determine whether or not the stack is empty. an operation to empty out a stack.

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

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

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

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

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

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

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

11. 11 3 template 4 class Stack { 5 public: 6Stack() { … } 7~Stack( ) { … } 8void push( T& elementToPush ) { … } 9bool pop( T& poppedElement ) { … } 10bool peek( T& topElement ) { … } 11bool isEmpty( ) { … } 12void makeEmpty( ) { … } 13 private: 14T* elements; // dynamic array 15 int size; 16int top; 17 }; Array Stack Class Template used as an index to the top of the stack

12. 12 3Stack () : top(-1), size(0) 4{ 5 elements = NULL; 6} 7 8 ~Stack( ) 9 { 10 makeEmpty( ); 11 } Array Stack Constructor and Destructor

13. 13 Array Stack isEmpty and makeEmpty 65 bool isEmpty( ) 66 { 67 return top == -1; 68 } 69 70 void makeEmpty( ) 71 { 72 size = 0; 73top = -1; 74delete [] elements; 75 }

14. 14 Array Stack Pop 125 25 200 70 elements 0 1 2 3 top An element can’t really be removed from an array, as one would think pop would achieve.

15. 15 Array Stack Pop (cont.) 125 25 200 70 elements 0 1 2 3 top The element 70 is at the top of the stack, and what really happens during a pop, is that 70 is returned to the client… client

16. 16 Array Stack Pop (cont.) 125 25 200 70 elements 0 1 2 3 top and top is decremented… client

17. 17 Array Stack Pop (cont.) 125 25 200 70 elements 0 1 2 3 top The element 70 is still in the array, but it is no longer accessible. The next push will overwrite it. Say, we would like to push 63… client

18. 18 Array Stack Push 125 25 200 70 elements 0 1 2 3 top First, top is incremented…

19. 19 Array Stack Push (cont.) 125 25 200 63 elements 0 1 2 3 top Then, 63 is pushed into that position…

20. 20 Is the Array Stack Full/Empty? An array stack is full when –top == size - 1 An array stack is empty when –top == -1

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

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

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

24. 24 Linked-List Stack Class Template 13 template 14 class Stack { 15 public: 16Stack( ) { … } 17~Stack( ) { … } 18void push( T & element ) { … } 19bool pop( T & element ) { … } 20bool peek( T & element ) { … } 21bool isEmpty( ) { … } 22void makeEmpty( ) { … } 23 private: 24Node *top; 25 };

25. 25 8 Stack( ) : top(NULL) { } 7 8 ~Stack( ) 9 { 10 makeEmpty( ); 11 } Linked-List Stack Constructor and Destructor

26. 26 Linked-List Push 32 void push( T& element ) { 33Node *newNode = new Node ; 34newNode->info = element; 35 newNode->next = top; 36 top = newNode; 37 } newNode

27. 27 Linked-List Push into Empty Stack 32 void push( T& element ) { 33Node *newNode = new Node ; 34newNode->info = element; 35 newNode->next = top; 36 top = newNode; 37 } top newNode NULL

28. 28 Linked-List Push into Empty Stack (cont.) 32 void push( T& element ) { 33Node *newNode = new Node ; 34newNode->info = element; 35 newNode->next = top; 36 top = newNode; 37 } top newNode

29. 29 Linked-List Push into Non-Empty Stack 32 void push( T& element ) { 33Node *newNode = new Node ; 34newNode->info = element; 35 newNode->next = top; 36 top = newNode; 37 } newNode top

30. 30 Linked-List Push into Non-Empty Stack (cont.) 32 void push( T& element ) { 33Node *newNode = new Node ; 34newNode->info = element; 35 newNode->next = top; 36 top = newNode; 37 } newNode top

31. 31 Linked-List Peek 56 bool peek( T& element ) 57 { 58if ( top == NULL ) 59 return false; 60element = top->info; 61return true; 62 }

32. 32 Linked-List Pop 56 bool pop( T& element ) 57 { 58if ( top == NULL ) 59 return false; 60element = top->info; 61Node *ptr = top; 62top = top->next; 63delete ptr; 64return true; 65 }

33. 33 Linked-List Stack isEmpty and makeEmpty 65 bool isEmpty( ) 66 { 67 return top == NULL; 68 } 69 70 void makeEmpty( ) 71 { 72 T temp; 73while ( pop( temp ) ); 74 }

34. 34 The Queue ADT The queue is a data structure that is like a line of people –When people join the line, they go at the end –When people are served, they come off the front of the line Queue is known as a FIFO (first-in, first- out) data structure because the last data to enter the queue is the last to exit from the queue.

35. 35 Queue ADT Operations enqueue: add an element to the end of the line dequeue: take an element from the front of the line peek: retrieve (copy) the element at the front of the line without removing it an operation to determine whether or not the queue is empty an operation that will empty out the queue

36. 36 Queue (cont.) In addition to a pointer at the beginning of the linked list (called front), a pointer to the end of the linked list (called back) is also maintained in the private section The back pointer makes it fast to add new elements to the end of the queue – you don’t have to use a loop to go all the way through the queue to find the last node

37. 37 Linked-List Dequeue front back Bob Ali

38. 38 Linked-List Dequeue (cont.) front back Ali

39. 39 Linked-List Enqueue front back

40. 40 Linked-List Enqueue (cont.) front back

41. 41 Linked-List Queue Class Template 13 template 14 class Queue { 15 public: 16Queue( ); 17~Queue( ); 18void enqueue( T & element ); 19bool dequeue( T & deqElement ); 20bool peek( T & frontElement ); 21bool isEmpty( ) ; 22void makeEmpty( ); 23 private: 24Node *front; 25Node *back; 26 };

42. 42 4 Queue( ) 5 { 6 front = back = NULL; 7 } 8 9 ~Queue( ) 10 { 11 makeEmpty( ); 12 } Linked-List Queue Constructor and Destructor

43. 43 Linked-List Queue Enqueue 22 void enqueue( T & element ) 23 { 24Node *newNode = new Node ; 25newNode->info = element; 26newNode->next = NULL; 27if (front == NULL) { // list is empty. 28 front = newNode; 29 back = front; 30} 31else { // list is not empty. 32 back->next = newNode; 33 back = newNode; 34} 35 } newNode

44. 44 Linked-List Queue Enqueue (cont.) 22 void enqueue( T & element ) 23 { 24Node *newNode = new Node ; 25newNode->info = element; 26newNode->next = NULL; 27if (front == NULL) { // list is empty. 28 front = newNode; 29 back = front; 30} 31else { // list is not empty. 32 back->next = newNode; 33 back = newNode; 34} 35 } newNode Case 1: The queue is initially empty. front back

45. 45 Linked-List Queue Enqueue (cont.) 22 void enqueue( T & element ) 23 { 24Node *newNode = new Node ; 25newNode->info = element; 26newNode->next = NULL; 27if (front == NULL) { // list is empty. 28 front = newNode; 29 back = front; 30} 31else { // list is not empty. 32 back->next = newNode; 33 back = newNode; 34} 35 } newNode Case 2: The queue has nodes. front back

46. 46 Linked-List Queue Enqueue (cont.) 22 void enqueue( T & element ) 23 { 24Node *newNode = new Node ; 25newNode->info = element; 26newNode->next = NULL; 27if (front == NULL) { // list is empty. 28 front = newNode; 29 back = front; 30} 31else { // list is not empty. 32 back->next = newNode; 33 back = newNode; 34} 35 } newNode Case 2: The queue has nodes. front back

47. 47 Linked-List Queue Dequeue 41 bool dequeue( T & deqElement ) 42 { 43if ( front == NULL) 44return false; Dequeue continued… Returns false if client tries to dequeue an empty queue.

48. 48 Linked-List Queue Dequeue (cont.) 45deqElement = front->info; 46Node *ptr = front; 47front = front->next; 48delete ptr; 49return true; 50 } frontbackptr deqElement: passed in by reference

49. 49 Linked-List Queue Dequeue (cont.) 45deqElement = front->info; 46Node *ptr = front; 47front = front->next; 48delete ptr; 49return true; 50 } frontbackptr deqElement:

50. 50 Linked-List Queue Dequeue (cont.) 45deqElement = front->info; 46Node *ptr = front; 47front = front->next; 48delete ptr; 49return true; 50 } frontbackptr deqElement:

51. 51 Linked-List Queue Peek 56 bool peek( T & frontElement ) 57 { 58if ( front == NULL) 59return false; 60frontElement = front->info; 61return true; 62 }

52. 52 Linked-List Queue isEmpty and makeEmpty 65 bool isEmpty( ) 66 { 67 return front == NULL; 68 } 69 70 void makeEmpty( ) 71 { 72 T temp; 73while ( dequeue( temp ) ); 74 }

53. 53 Array Queue Similar to the linked-list queue, there are 2 attributes 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.

54. 54 Array Queue Class Template 3 template 4 class Queue { 5 public: 6 Queue( ) { … } 7 ~Queue( ) { … } 8void enqueue( T element ) { … 9bool dequeue( T & deqElement ) { … } 10bool peek( T & frontElement ) { … } 11bool isEmpty( ) { … } 12void makeEmpty( ) { … } 13 private: 14T *elements; 15int size 16int front; 17int back; 18 };

55. 55 Array Queue Enqueue / Dequeue 0 1 2 3 4 5 6 7 frontback DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

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

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

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

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

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

61. 61 0 1 2 3 4 5 6 7 frontback Array Queue Enqueue / Dequeue (cont.) DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

62. 62 0 1 2 3 4 5 6 7 frontback Array Queue Enqueue / Dequeue (cont.) DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

63. 63 0 1 2 3 4 5 6 7 frontback Array Queue Enqueue / Dequeue (cont.) DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

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

65. 65 0 1 2 3 4 5 6 7 frontback We have reached the end of array. How to enqueue? ? Array Queue Enqueue / Dequeue (cont.) DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

66. 66 0 1 2 3 4 5 6 7 frontback Array Queue Enqueue / Dequeue (cont.) We could double the size of the array here. But if we keep doing this, we may have a million elements in the array, but only a few at the end are used! DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

67. 67 0 1 2 3 4 5 6 7 frontback We handle this problem by having the back wrap around to the beginning of the array. The front also wraps to the beginning when it reaches the end of the array Array Queue Enqueue / Dequeue (cont.) DEQUEUE ENQUEUE DEQUEUE ENQUEUE DEQUEUE ENQUEUE

68. 68 Is Array Queue Full/Empty? An array queue is empty when –front = -1 An array queue has one element when –front = back An array queue is full when –back + 1 = front

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

70. Reference Childs, J. S. (2008). Stack and Queue. C++ Classes and Data Structures. Prentice Hall. 70