Lecture08 stacks and-queues_v3

1,278 views

Published on

0 Comments
3 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,278
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
76
Comments
0
Likes
3
Embeds 0
No embeds

No notes for slide

Lecture08 stacks and-queues_v3

  1. 1. Chapter 7Stacks and Queues 1
  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. 2
  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. 3
  4. 4. Push• Push means place a new data element at the top of the stack 11 5 3 17 stack 4
  5. 5. Push (cont.)• Push means place a new data element at the top of the stack 11 3 5 17 stack 5
  6. 6. Push (cont.)• Push means place a new data element at the top of the stack 3 11 5 17 stack 6
  7. 7. Pop• Pop means take a data element off the top of the stack 3 11 5 17 stack 7
  8. 8. Pop (cont.)• Pop means take a data element off the top of the stack 3 11 5 17 stack 8
  9. 9. Pop (cont.)• Pop means take a data element off the top of the stack 11 5 3 17 stack 9
  10. 10. Peek• Peek means retrieve the top of the stack without removing it 3 11 5 3 17 stack 10
  11. 11. Array Stack Class Template3 template <typename T>4 class Stack {5 public:6 Stack() { … }7 ~Stack( ) { … }8 void push( T& elementToPush ) { … }9 bool pop( T& poppedElement ) { … }10 bool peek( T& topElement ) { … }11 bool isEmpty( ) const { … }12 void makeEmpty( ) { … }13 private:14 T* elements; // dynamic array used as an15 int size; index to the top16 int top; of the stack17 }; 11
  12. 12. Array Stack Constructor and Destructor3 Stack () : top(-1), size(0)4 {5 elements = NULL;6 }78 ~Stack( )9 {10 makeEmpty( );11 } 12
  13. 13. Array Stack isEmpty and makeEmpty65 bool isEmpty( ) const66 {67 return top == -1;68 }6970 void makeEmpty( )71 {72 size = 0;73 top = -1;74 delete [] elements;75 } 13
  14. 14. Array Stack Pop elements 125 25 200 70 0 1 2 3 topAn element can’t really be removed from anarray, as one would think pop would achieve. 14
  15. 15. Array Stack Pop (cont.) elements client 125 25 200 70 0 1 2 3 topThe element 70 is at the top of the stack, andwhat really happens during a pop, is that 70 isreturned to the client… 15
  16. 16. Array Stack Pop (cont.) elements client 125 25 200 70 0 1 2 3 topand top is decremented… 16
  17. 17. Array Stack Pop (cont.) elements client 125 25 200 70 0 1 2 3 topThe element 70 is still in the array, but it is nolonger accessible. The next push willoverwrite it. Say, we would like to push 63… 17
  18. 18. Array Stack Push elements 125 25 200 70 0 1 2 3 topFirst, top is incremented… 18
  19. 19. Array Stack Push (cont.) elements 125 25 200 63 0 1 2 3 topThen, 63 is pushed into that position… 19
  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 20
  21. 21. Linked-List Stack• Stacks can also be implemented with a linked list.• The front node is the top of the stack. 21
  22. 22. Linked-List Stack (cont.) Bob Alitop To pop, we remove the node at the front of the linked list, and return the element to the client… Alitop 22
  23. 23. Linked-List Stack (cont.) Alitop To push Cat, we place the new element in a node and insert it at the front of the linked list… Cat Alitop 23
  24. 24. Linked-List Stack Class Template13 template <typename T>14 class Stack {15 public:16 Stack( ) { … }17 ~Stack( ) { … }18 void push( const T & element ) { … }19 bool pop( T & element ) { … }20 bool peek( T & element ) { … }21 bool isEmpty( ) const { … }22 void makeEmpty( ) { … }23 private:24 Node<T> *top;25 }; 24
  25. 25. Linked-List Stack Constructor and Destructor8 Stack( ) : top(NULL) { }78 ~Stack( )9 {10 makeEmpty( );11 } 25
  26. 26. Linked-List Push32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) {36 newNode->next = NULL;37 top = newNode;38 }39 else {40 newNode->next = top;41 top = newNode;42 } newNode43 } 26
  27. 27. Linked-List Push into Empty Stack32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } top NULL39 else {40 newNode->next = top;41 top = newNode;42 }43 } newNode 27
  28. 28. Linked-List Push into Empty Stack (cont.)32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } top39 else {40 newNode->next = top;41 top = newNode;42 } newNode43 } 28
  29. 29. Linked-List Push into Non-Empty Stack32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } top39 else { // stack is not empty.40 newNode->next = top;41 top = newNode;42 }43 } newNode 29
  30. 30. Linked-List Push into Non-Empty Stack (cont.)32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } top39 else { // stack is not empty.40 newNode->next = top;41 top = newNode;42 } newNode43 } 30
  31. 31. Linked-List Peek56 bool peek( T& element )57 {58 if ( top == NULL )59 return false;60 element = top->info;61 return true;62 } 31
  32. 32. Linked-List Pop56 bool pop( T& element )57 {58 if ( top == NULL )59 return false;60 element = top->info;61 Node<T> *ptr = top;62 top = top->next;63 delete ptr;64 return true;65 } 32
  33. 33. Linked-List Stack isEmpty and makeEmpty65 bool isEmpty( ) const66 {67 return top == NULL;68 }6970 void makeEmpty( )71 {72 T temp;73 while ( pop( temp ) );74 } 33
  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 (last-in, last- out) data structure because the last data to enter the queue is the last to exit from the queue. 34
  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 35
  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 36
  37. 37. Linked-List Dequeuefront back Bob Ali 37
  38. 38. Linked-List Dequeue (cont.) front back Ali 38
  39. 39. Linked-List Enqueuefront back 39
  40. 40. Linked-List Enqueue (cont.)front back 40
  41. 41. Linked-List Queue Class Template13 template <typename T>14 class Queue {15 public:16 Queue( );17 ~Queue( );18 void enqueue( const T & element );19 bool dequeue( T & deqElement );20 bool peek( T & frontElement );21 bool isEmpty( ) const;22 void makeEmpty( );23 private:24 Node<T> *front;25 Node<T> *back;26 }; 41
  42. 42. Linked-List Queue Constructor and Destructor4 Queue( )5 {6 front = back = NULL;7 }89 ~Queue( )10 {11 makeEmpty( );12 } 42
  43. 43. Linked-List Queue Enqueue21 void enqueue( const T & element )22 {23 Node<T> *newNode = new Node<T>;24 newNode->info = element;25 newNode->next = NULL;28 if (front == NULL) { // list is empty.29 front = back = newNode;30 }31 else { // list is not empty.32 back->next = newNode;33 back = newNode; newNode34 }35 } 43
  44. 44. Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>;25 newNode->info = element;26 newNode->next = NULL; back27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front; front30 }31 else { // list is not empty. newNode32 back->next = newNode;33 back = newNode;34 }35 } Case 1: The queue is initially empty. 44
  45. 45. Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>; front25 newNode->info = element;26 newNode->next = NULL;27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front;30 } back31 else { // list is not empty.32 back->next = newNode; newNode33 back = newNode;34 }35 } Case 2: The queue has nodes. 45
  46. 46. Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>; front25 newNode->info = element;26 newNode->next = NULL;27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front;30 }31 else { // list is not empty. back32 back->next = newNode; newNode33 back = newNode;34 }35 } Case 2: The queue has nodes. 46
  47. 47. Linked-List Queue Dequeue41 bool dequeue( T & deqElement )42 {43 if ( front == NULL) Returns false if client tries44 return false; to dequeue an empty queue. Dequeue continued… 47
  48. 48. Linked-List Queue Dequeue (cont.)45 deqElement = front->info;46 Node<T> *ptr = front;47 front = front->next; deqElement:48 delete ptr; passed in by49 return true; reference50 } front ptr back 48
  49. 49. Linked-List Queue Dequeue (cont.)45 deqElement = front->info;46 Node<T> *ptr = front;47 front = front->next; deqElement:48 delete ptr;49 return true;50 } ptr front back 49
  50. 50. Linked-List Queue Dequeue (cont.)45 deqElement = front->info;46 Node<T> *ptr = front;47 front = front->next; deqElement:48 delete ptr;49 return true;50 } ptr front back 50
  51. 51. Linked-List Queue Peek56 bool peek( T & frontElement )57 {58 if ( front == NULL)59 return false;60 frontElement = front->info;61 return true;62 } 51
  52. 52. Linked-List Queue isEmpty and makeEmpty65 bool isEmpty( ) const66 {67 return front == NULL;68 }6970 void makeEmpty( )71 {72 T temp;73 while ( dequeue( temp ) );74 } 52
  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. 53
  54. 54. Array Queue Class Template3 template <typename T>4 class Queue {5 public:6 Queue( ) { … }7 ~Queue( ) { … }8 void enqueue( T element ) { …9 bool dequeue( T & deqElement ) { … }10 bool peek( T & frontElement ) { … }11 bool isEmpty( ) const { … }12 void makeEmpty( ) { … }13 private:14 T *elements;15 int size16 int front;17 int back; 5418 };
  55. 55. Array Queue Enqueue / Dequeue DEQUEUE DEQUEUE ENQUEUE 0 1 2 3 4 5 6 7 ENQUEUEfront back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 55
  56. 56. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE0 1 2 3 4 5 6 7 ENQUEUE ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 56
  57. 57. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE0 1 2 3 4 5 6 7 ENQUEUE ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 57
  58. 58. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE0 1 2 3 4 5 6 7 ENQUEUE ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 58
  59. 59. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 59
  60. 60. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 60
  61. 61. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 61
  62. 62. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 62
  63. 63. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 63
  64. 64. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE DEQUEUE DEQUEUE ENQUEUE 64
  65. 65. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUE ENQUEUE We have reached the DEQUEUE end of array. How to enqueue? ? DEQUEUE ENQUEUE 65
  66. 66. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE 0 1 2 3 4 5 6 7 ENQUEUE front back DEQUEUE DEQUEUEWe could double the size of the array ENQUEUEhere. DEQUEUEBut if we keep doing this, we may DEQUEUEhave a million elements in the ENQUEUEarray, but only a few at the end are 66used!
  67. 67. Array Queue Enqueue / Dequeue (cont.) DEQUEUE DEQUEUE ENQUEUE 0 1 2 3 4 5 6 7 ENQUEUEback front DEQUEUE DEQUEUEWe handle this problem by having the ENQUEUEback wrap around to the beginning of DEQUEUEthe array. DEQUEUEThe front also wraps to the beginning ENQUEUEwhen it reaches the end of the array 67
  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 68
  69. 69. A Full Array Queue0 1 2 3 4 5 6 7 back front If the next operation is ENQUEUE, the array capacity will need to be doubled 69
  70. 70. Reference• Childs, J. S. (2008). Stack and Queue. C++ Classes and Data Structures. Prentice Hall. 70

×