9.7 KiB
9.7 KiB
Lecture 14 --- Stack and Queue
Today’s Lecture
- STL Queue and STL Stack
14.1 Additional STL Container Classes: Stacks
- A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle.
- Stacks allow access, insertion and deletion from only one end called the top.
- There is no access to values in the middle of a stack.
- Stacks may be implemented efficiently in terms of vectors and lists, although vectors are preferable.
- All stack operations are O(1).
14.1.1 Member functions of std::stack
- push(const T& value): Adds an element value to the top of the stack.
- pop(): Removes the top element from the stack.
- top(): Returns a reference to the top element of the stack without removing it.
- empty(): Checks if the stack is empty. Returns true if the stack is empty, false otherwise.
- size(): Returns the number of elements in the stack.
14.1.2 Stack Example Program
- Following is an example program, remember to include the stack library.
#include <iostream>
#include <stack>
int main() {
std::stack<int> myStack;
myStack.push(10);
myStack.push(20);
myStack.push(30);
myStack.push(40);
myStack.push(50);
std::cout << "Size of stack: " << myStack.size() << std::endl;
std::cout << "Top element: " << myStack.top() << std::endl;
if (!myStack.empty()) {
std::cout << "Stack is not empty" << std::endl;
} else {
std::cout << "Stack is empty" << std::endl;
}
myStack.pop();
// What is the output of this next line?
std::cout << "Top element after pop: " << myStack.top() << std::endl;
return 0;
}
You can compile and run this above program.
14.1.3 Stack Implementation
We have the stack implementation and test code here: stack.h, stack_test.cpp.
14.2 Additional STL Container Classes: Queues
- A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle.
- Queues allow insertion at one end, called the back and removal from the other end, called the front.
- There is no access to values in the middle of a queue.
- Queues may be implemented efficiently in terms of a list. Using vectors for queues is also possible, but requires more work to get right.
- All queue operations are O(1).
14.2.1 Member functions of std::queue
- push(const T& value): Adds an element value to the rear of the queue. This operation is also known as enqueue.
- pop(): Removes the front element from the queue. This operation is also known as dequeue.
- front(): Returns a reference to the front element of the queue without removing it.
- empty(): Checks if the queue is empty. Returns true if the queue is empty, false otherwise.
- size(): Returns the number of elements in the queue.
14.2.2 Queue Example Program
- Following is an example program, remember to include the queue library.
#include <iostream>
#include <queue>
int main() {
std::queue<int> myQueue;
myQueue.push(10);
myQueue.push(20);
myQueue.push(30);
myQueue.push(40);
myQueue.push(50);
std::cout << "Size of queue: " << myQueue.size() << std::endl;
std::cout << "Front element: " << myQueue.front() << std::endl;
if (!myQueue.empty()) {
std::cout << "Queue is not empty" << std::endl;
} else {
std::cout << "Queue is empty" << std::endl;
}
myQueue.pop();
// What is the output of this next line?
std::cout << "Front element after pop: " << myQueue.front() << std::endl;
return 0;
}
You can compile and run this above program.
14.3 Stack Example Problem
Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
An input string is valid if:
- Open brackets must be closed by the same type of brackets.
- Open brackets must be closed in the correct order.
- Every close bracket has a corresponding open bracket of the same type.
Example 1: Input: s = "()" Output: true
Example 2: Input: s = "()[]{}" Output: true
Example 3: Input: s = "(]" Output: false
Example 4: Input: s = "([])" Output: true
Constraints: 1 <= s.length <= 104; s consists of parentheses only '()[]{}'.
We have the solution here:
bool isValid(string s) {
std::stack<char> myStack;
int len = s.length();
char c;
for(int i=0;i<len;i++){
// push all the open brackets into the stack
if(s[i]=='(' || s[i]=='{' || s[i]=='['){
myStack.push(s[i]);
}else{
// if we encounter a close bracket first, it's already invalid.
if(myStack.empty()){
return false;
}
c = myStack.top();
myStack.pop();
// for every close bracket we encounter, there must be a corresponding open bracket at the top of the stack.
if(s[i]==')' && c!='('){
return false;
}
if(s[i]=='}' && c!='{'){
return false;
}
if(s[i]==']' && c!='['){
return false;
}
}
}
// if it's empty, we are good.
if(myStack.empty()){
return true;
}else{
return false;
}
}
- Play this animation to see how this program works.