The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A...
Transcript of The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A...
![Page 1: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/1.jpg)
The Stack and Queue Types Lecture 10 Hartmut Kaiser [email protected] http://www.cct.lsu.edu/˜hkaiser/fall_2012/csc1254.html
![Page 2: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/2.jpg)
Programming Principle of the Day
• Do the simplest thing that could possibly work
▫ A good question to ask one’s self when programming is “What is the simplest thing that could possibly work?”
▫ This helps keep us on the path towards simplicity in the design.
http://c2.com/xp/DoTheSimplestThingThatCouldPossiblyWork.html
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
2
![Page 3: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/3.jpg)
Abstract
• This lecture will focus on two other sequential data types, the stack and the queue. We will use stacks to implement conversion between ‘normal expressions’ and the equivalent reverse polish notation.
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
3
![Page 4: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/4.jpg)
Introduction to Stacks
• A stack is a last-in-first-out (LIFO) data structure
• Limited access vector (or list)
• Main operations:
▫ Adding an item
Referred to as pushing it onto the stack
▫ Removing an item
Referred to as popping it from the stack
CSC 1254, Fall 2012, Stacks and Queues
4
10/2/2012, Lecture 10
![Page 5: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/5.jpg)
CSC 1254, Fall 2012, Stacks and Queues
5
Introduction to Stacks
• Definition: ▫ An ordered collection of data items ▫ Can be accessed at only one end (the top)
• Operations: ▫ Construct a stack (usually empty) ▫ Check if it is empty ▫ push: add an element to the top ▫ top: retrieve the top element ▫ pop: remove the top element ▫ size: returns number of elements in stack
10/2/2012, Lecture 10
![Page 6: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/6.jpg)
Introduction to Stacks
• Useful for
▫ Reversing a sequence
▫ Managing a series of undo-actions
▫ Tracking history when browsing the web
▫ Function call hierarchy is implemented with a stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
6
![Page 7: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/7.jpg)
7
Push
17
5
11
3
• Push means place a new data element at the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 8: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/8.jpg)
8
Push (cont.)
17
5
11
3
• Push means place a new data element at the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 9: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/9.jpg)
9
Push (cont.)
17
5
11
3
• Push means place a new data element at the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 10: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/10.jpg)
10
Push (cont.)
17
5
11
3
• Push means place a new data element at the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 11: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/11.jpg)
11
Pop
17
5
11
3
• Pop means take a data element off the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 12: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/12.jpg)
12
Pop (cont.)
17
5
11
3
• Pop means take a data element off the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 13: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/13.jpg)
13
Pop (cont.)
17
5
11
3
• Pop means take a data element off the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 14: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/14.jpg)
14
Pop (cont.)
17
5
11
3
• Pop means take a data element off the top of the stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 15: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/15.jpg)
15
Top
17
5
11
3
• Top means retrieve the top of the stack without removing it
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 16: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/16.jpg)
16
Top (cont.)
17
5
11
3
3
• Top means retrieve the top of the stack without removing it
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 17: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/17.jpg)
17
Top (cont.)
17
5
11
3
3
• Top means retrieve the top of the stack without removing it
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 18: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/18.jpg)
18
Linked-List Stack
• Stacks can also be implemented with a linked list • The front node is the top of the stack • In fact, there is std::stack<> which is an adaptor
usable with different types of underlying containers (std::list is one possibility)
• std::stack<T>: implements a stack of ‘T’s T top(); void push(T const&); void pop(); std::stack<T>::size_type size() const; bool empty();
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 19: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/19.jpg)
Linked-List Stack (cont.)
• To pop, we remove the node at the front of the linked list, and return the element to the client…
19
top
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 20: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/20.jpg)
Linked-List Stack (cont.)
• To pop, we remove the node at the front of the linked list, and return the element to the client…
20
top
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 21: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/21.jpg)
Linked-List Stack (cont.)
• To push, we place the new element in a node and insert it at the front of the linked list…
21
top
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 22: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/22.jpg)
Linked-List Stack (cont.)
• To push, we place a new element in a node and insert it at the front of the linked list…
22
top
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
![Page 23: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/23.jpg)
Example: Implementing a Stack
• Implementing a stack on top of a list is trivial
▫ Live coding
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
23
![Page 24: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/24.jpg)
Application of Stacks
Consider the arithmetic statement in the assignment: x = a * b + c Compiler must generate machine instructions:
LOAD a MULT b ADD c STORE x
CSC 1254, Fall 2012, Stacks and Queues
24
Note: this is "infix" notation
The operators are between the operands
10/2/2012, Lecture 10
![Page 25: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/25.jpg)
Reverse Polish Notation
• Postfix Notation
▫ Most compilers convert an expression in infix notation to postfix
The operators are written after the operands
▫ So a * b + c becomes a b * c +
▫ Advantage:
Expressions can be written without parentheses
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
25
![Page 26: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/26.jpg)
Postfix and Prefix Examples
Infix RPN (Postfix) Prefix
A + B A B + + A B
A * B + C A B * C + + * A B C
A * (B + C) A B C + * * A + B C
A – (B – (C – D)) A B C D – – – – A – B – C – D
A – B – C – D A B – C – D – – – – A B C D
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
26
Prefix: Operators come before the operands
![Page 27: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/27.jpg)
Evaluating RPN Expressions
"By hand" (Underlining technique):
1. Scan the expression from left to right to find an operator.
2. Locate ("underline") the last two preceding operands and combine them using this operator.
3. Repeat until the end of the expression is reached.
Example:
2 3 4 + 5 6 - - *
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
27
![Page 28: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/28.jpg)
Evaluating RPN Expressions
2 3 4 + 5 6 - - *
2 3 4 + 5 6 - - *
2 7 5 6 - - *
2 7 5 6 - - *
2 7 -1 - *
2 7 -1 - *
2 8 *
2 8 *
16
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
28
2 * ((3 + 4) – (5 – 6))
![Page 29: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/29.jpg)
Evaluating RPN Expressions
• By using a stack algorithm ▫ Initialize an empty stack
• Repeat the following until the end of the expression is encountered ▫ Get the next token (const, var, operator) in the expression ▫ Operand – push onto stack
Operator – do the following Pop 2 values from stack Apply operator to the two values Push resulting value back onto stack
• When end of expression encountered, value of expression is the (only) number left in stack
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
29
Note: if only 1 value on stack, this is an invalid RPN expression
![Page 30: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/30.jpg)
CSC 1254, Fall 2012, Stacks and Queues
30
Evaluating
of Postfix
• Note the changing status of the stack
10/2/2012, Lecture 10
![Page 31: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/31.jpg)
Converting between Notations
• By hand: Represent infix expression as an expression tree:
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
31
A * B + C
+
C *
A B
A * (B + C)
*
A +
B C
((A + B) * C) / (D - E)
C
A B
D E
*
+
/
-
![Page 32: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/32.jpg)
Converting RPN (Postfix)
• Traverse the tree in Left-Right-Parent order (post-order) to get RPN:
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
32
C
A B
D E
*
+
/
-
A B + C * D E - /
![Page 33: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/33.jpg)
Converting to Prefix
• Traverse tree in Parent-Left-Right order (pre-order) to get prefix:
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
33
/ * + A B C - D E
C
A B
D E
*
+
/
-
![Page 34: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/34.jpg)
Converting to Infix
• Traverse tree in Left-Parent-Right order (in-order) to get infix (must insert parenthesis)
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
34
((A + B)* C)/(D – E)) C
A B
D E
*
+
/
-
![Page 35: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/35.jpg)
Another RPN Conversion Method
By hand: "Fully parenthesize-move-erase" method:
1. Fully parenthesize the expression.
2. Replace each right parenthesis by the corresponding operator.
3. Erase all left parentheses.
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
35
A * B + C
((A B * C +
A B * C +
A * (B + C)
(A (B C + *
A B C + *
((A * B) + C) (A * (B + C ) )
![Page 36: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/36.jpg)
Introduction to Queue
• A queue is a first-in-first-out (FIFO) data structure
• Limited access vector (or list)
• Main operations:
▫ Adding an item
Referred to as pushing it onto the queue (enqueue an item, adding to the end)
▫ Removing an item
Referred to as popping it from the queue (dequeue an item, remove from the front)
CSC 1254, Fall 2012, Stacks and Queues
38
10/2/2012, Lecture 10
![Page 37: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/37.jpg)
CSC 1254, Fall 2012, Stacks and Queues
39
Introduction to Queues
• Definition: ▫ An ordered collection of data items ▫ Can be read at only one end (the front) and
written to only at the other end (the back) • Operations:
▫ Construct a queue (usually empty) ▫ Check if it is empty ▫ push: add an element to the back ▫ front: retrieve the front element ▫ pop: remove the front element ▫ size: returns number of elements in queue
10/2/2012, Lecture 10
![Page 38: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/38.jpg)
Introduction to Queues
• Useful for
▫ All kind of simulations (traffic, supermarket, etc.)
▫ Computers use queues for scheduling
Handling keyboard events
Handling mouse events
Scrolling the screen
Printer spooler
▫ C++ I/O streams are queues
Even if we only access one end, the other end is managed by the operating system
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
40
![Page 39: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/39.jpg)
Example: Queue of Strings void manage_queue() { queue<string> waiting_strings; // queue of 'waiting' strings while (true) { cout << "?> "; // ask for next line of text string response; getline(cin, response); if (response.empty()) break; if (response == "next") { // try to dequeue if (waiting_strings.empty()) cout << "No one waiting!" << endl; else { cout << waiting_strings.front() << endl; waiting_strings.pop(); } } else { // enqueue the line read waiting_strings.push(response); } } }
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
41
![Page 40: The Stack and Queue Types - cct.lsu.eduhkaiser/fall_2012/csc1254/lectures/Lecture 10... · •A stack is a last-in-first-out (LIFO) data structure •Limited access vector (or list)](https://reader030.fdocuments.in/reader030/viewer/2022041209/5d67691988c9931a568b4a1b/html5/thumbnails/40.jpg)
Example: Implementing a Queue
• Implementing a queue on top of a list is equally trivial
▫ Live coding
10/2/2012, Lecture 10
CSC 1254, Fall 2012, Stacks and Queues
42