Upcoming SlideShare
×

# Lecture08 stacks and-queues_v3

1,278 views

Published on

3 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
1,278
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
76
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