栈和队列的基本含义
栈 (Stack)：栈是一种数据结构，它遵循“后进先出” (LIFO, Last In First Out) 的原则。这意味着最后放入栈中的元素最先被取出。
- 压栈 (Push)：将一个元素放入栈顶。
- 弹栈 (Pop)：从栈顶取出一个元素。
- 栈顶 (Top/Peek)：查看栈顶元素而不移除它。
队列 (Queue)：队列是一种数据结构，它遵循“先进先出” (FIFO, First In First Out) 的原则。这意味着最先放入队列中的元素最先被取出。
- 入队 (Enqueue)：将一个元素添加到队列的末尾。
- 出队 (Dequeue)：从队列的前端取出一个元素。
- 队首 (Front/Peek)：查看队列前端的元素而不移除它。
栈、队列实现
最小栈
class MinStack {
public:
stack<pair<int, int>> st;
MinStack() {
}
void push(int val) {
if (st.size() == 0 || st.top().second > val) {
st.push({val, val});
}
else {
st.push({val, st.top().second});
}
}
void pop() {
st.pop();
}
int top() {
return st.top().first;
}
int getMin() {
return st.top().second;
}
};
用队列实现栈
// 双端队列，只要在队尾进行操作即可；
// 队列，需要一个辅助队列，将全部元素倒入辅助队列里，使得原先的队尾元素变成队头元素
class MyStack {
public:
queue<int> queue1;
queue<int> queue2;
MyStack() {
}
void push(int x) {
queue2.push(x);
while (!queue1.empty()) {
queue2.push(queue1.front());
queue1.pop();
}
swap(queue1, queue2);
}
int pop() {
int x = queue1.front();
queue1.pop();
return x;
}
int top() {
return queue1.front();
}
bool empty() {
return queue1.empty();
}
};
用栈实现队列
仅使用两个栈 st1 和 st2 实现先入先出队列
- 正常的往 st1 放入元素，此时最先放进入的元素在 st1 的底端
- 当 pop() 和取队头元素时，栈的底端元素是拿不到的，我们需要 倒 出来，放到 st2 ，此时 st2 从底端到顶端的元素顺序正好为入队顺序；因此当 st2 不为空时，对于队列的队头元素，或取或删的操作对象为 st2 的栈顶元素，若 st2 为空，我们再将 st1 的元素 倒 进 st2 中。
class MyQueue {
public:
stack<int> st1;
stack<int> st2;
MyQueue() {
}
void push(int x) {
st1.push(x);
}
int pop() {
int x = peek();
st2.pop();
return x;
}
int peek() {
if (st2.empty()) {
while (!st1.empty()) {
st2.push(st1.top());
st1.pop();
}
}
return st2.top();
}
bool empty() {
return st1.empty() && st2.empty();
}
};
设计循环队列
题目要求我们使用数组来实现一个队列，并且循环的队列是首尾相连，从逻辑上看成一个环。
- 双指针：front 指向队头元素的索引，rear 指向队尾元素的下一个元素的索引，也就是下一个入队元素的位置；初始状态时这两个指针同时为 0；后续两个指针的移动可以根据数组的大小进行取模运算实现指针的循环移动。
- 为了避免「队列为空」和「队列为满」的判别条件冲突，我们有意浪费了一个位置，因此将 capacity = k + 1 ；
- 当队列为空的时候，联想到初始状态，front 和 rear 指向同一个索引，因此可以根据 rear == front 判断队列是否为空；
- 当队列为满的时候，相当于 front 指针在 rear 指针的下一位置，作为队列呈“满”状态的标志；
- (rear + 1) % capacity == front 作为判断依据；
- 此时是浪费了一个位置的：循环数组中任何时刻一定至少有一个位置不存放有效元素
capacity = 4, rear = 3, front = 0，即为(rear + 1) % capacity = front，此时队列为满的状态。
class MyCircularQueue {
public:
int front, rear, capacity;
vector<int> vec;
MyCircularQueue(int k) {
capacity = k + 1;
front = 0, rear = 0;
vec = vector<int>(capacity);
}
bool enQueue(int value) {
if (isFull()) return false;
vec[rear] = value;
rear = (rear + 1) % capacity;
return true;
}
bool deQueue() {
if (isEmpty()) return false;
front = (front + 1) % capacity;
return true;
}
int Front() {
if (isEmpty()) return -1;
return vec[front];
}
int Rear() {
if (isEmpty()) return -1;
return vec[(rear - 1 + capacity) % capacity];
}
bool isEmpty() {
return rear == front;
}
bool isFull() {
return (rear + 1) % capacity == front;
}
};
设计循环双端队列
class MyCircularDeque {
public:
int front, rear, capacity;
vector<int> vec;
MyCircularDeque(int k) {
capacity = k+1;
rear = 0, front = 0;
vec = vector<int>(capacity);
}
bool insertFront(int value) {
if (isFull()) return false;
front = (front - 1 + capacity) % capacity;
vec[front] = value;
return true;
}
bool insertLast(int value) {
if (isFull()) return false;
vec[rear] = value;
rear = (rear + 1) % capacity;
return true;
}
bool deleteFront() {
if (isEmpty()) return false;
front = (front + 1) % capacity;
return true;
}
bool deleteLast() {
if (isEmpty()) return false;
rear = (rear - 1 + capacity) % capacity;
return true;
}
int getFront() {
if (isEmpty()) return -1;
return vec[front];
}
int getRear() {
if (isEmpty()) return -1;
return vec[(rear - 1 + capacity) % capacity];
}
bool isEmpty() {
return front == rear;
}
bool isFull() {
return (rear+1) % capacity == front;
}
};
设计一个支持增量操作的栈
// 方式一：暴力解法
class CustomStack {
public:
vector<int> vec;
int top;
CustomStack(int maxSize) {
vec = vector<int>(maxSize);
top = -1;
}
void push(int x) {
if (top != vec.size() - 1) {
++top;
vec[top] = x;
}
}
int pop() {
if (top == -1) return -1;
top--;
return vec[top+1];
}
void increment(int k, int val) {
int n = k < top+1 ? k : top+1;
for (int i=0; i<n; i++) {
vec[i] += val;
}
}
};
// 方式二：数组 vec + 栈 st
class CustomStack {
public:
int n;
vector<int> vec;
stack<int> st;
CustomStack(int maxSize) {
n = maxSize;
vec = vector<int>(n);
}
void push(int x) {
if (st.size() < n) st.push(x);
}
int pop() {
int i = st.size() - 1;
if (i < 0) return -1;
if (i > 0) vec[i-1] += vec[i];
int res = vec[i] + st.top(); st.pop();
vec[i] = 0;
return res;
}
void increment(int k, int val) {
int size = st.size();
int i = min(k, size) - 1;
if (i >= 0) vec[i] += val;
}
};
最大频率栈
我们把原始栈拆分成多个栈，每个栈都存储着相同频率的数字（这里的频率指的是数字入栈时的频率），且保持了原有的入栈顺序，因此弹出的是一定最接近栈顶的那个数字。
因此我们使用了两个哈希表：一个用来存储元素出现次数的哈希表 map ，它的的键值对为 {element: frequency}，一个是用来存储具有相同频率的元素的 frequencyMap ，它的键值对为 {frequency: elements of the same frequency}【将 frequency 作为 key 】；在 push 操作中，更新元素的频率并将当前元素加入对应频率的栈中。
- 当栈内的元素为 [5, 7, 4]，此时 frequencyMap 为 {1: [5, 7, 4]}；
- 当加入新的元素，变为 [5, 7, 4, 5]，此时 frequencyMap 为 {1: [5, 7, 4], 2: [5]}；
- 之后加入几个新的元素，变为 [5, 7, 4, 5, 7, 5]，此时 frequencyMap 为 {1: [5, 7, 4], 2: [5, 7], 3: [5]}。
class FreqStack {
public:
unordered_map<int, int> map;
unordered_map<int, stack<int>> frequencyMap;
int maxFrequency;
FreqStack() {
maxFrequency = 0;
}
void push(int val) {
map[val] += 1;
int curFrequency = map[val];
frequencyMap[curFrequency].push(val);
maxFrequency = max(maxFrequency, curFrequency);
}
int pop() {
int x = frequencyMap[maxFrequency].top(); frequencyMap[maxFrequency].pop();
if (frequencyMap[maxFrequency].size() == 0) maxFrequency--;
map[x]--;
return x;
}
};
424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
