基础：
栈是一种后进先出的数据结构。栈顶指针是始终指向栈最上方元素的一个标记。
实现：
使用s[]实现栈（数组方法实现）
栈清空:Top = -1；
进栈 s[++top] = x;
出栈：Top--；
获取栈顶元素： return s[Top];
获取size: return Top+1；
判断空: return Top ==-1;
C++ STL 提供stack的容器
#include<stack>
提供的函数有 push pop empty top size
不提供clear
可以自己实现:
while(!s.empty()){
s.pop();
}
注意重新定义一个栈的时间复杂度是O(1)，所以可以重新定义以实现变相的清空栈。
pop没有返回值
编程常见错误
pop和top的时候栈一定不为空，注意在逻辑判断中常常忽略；
所以编程结束后，逐个判断一下pop和top函数能不能用。
应用栈思想，题目一：
有时候应用栈的思想没必要定义一个栈，只需要一个int型变量来模拟栈顶的变化。如题：
链接：https://leetcode-cn.com/problems/remove-outermost-parentheses
class Solution {
public:
string removeOuterParentheses(string S) {
string result;
int top = 0;
for(char c : S){
if(c == '(' && top++ > 0) result += c;
if(c == ')'&&--top > 0) result += c;
}
return result;
}
};
单调栈 题目二：
单调栈就是栈里面存放的数据都是有序的，所以可以分为单调递增栈和单调递减栈两种。
单调递增栈就是从栈底到栈顶是从大到小，如果栈为空或入栈元素值小于栈顶元素值，则入栈；否则，如果入栈则会破坏栈的单调性，则需要把比入栈元素小的元素全部出栈。
单调递减栈就是从栈底到栈顶是从小到大
参考：https://zhuanlan.zhihu.com/p/101785785
链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/xia-yi-ge-geng-da-yuan-su-i-by-leetcode/
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
map<int,int> hash;
stack<int> s;
vector<int> result;
for(int i: nums2){
while(!s.empty() && s.top() < i ){
hash[s.top()] = i;
s.pop();
}
s.push(i);
}
while(!s.empty()){
hash[s.top()] = -1;
s.pop();
}
for(int i: nums1){
result.push_back(hash[i]);
}
return result;
}
};
二叉树遍历的非递归实现 题目三：
星星：注意退出循环的条件。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> sequence;
stack <TreeNode*> s;
vector<int> inorderTraversal(TreeNode* root) {
TreeNode *cur;
if(root == NULL) return sequence;
s.push(root);
cur = root->left;
while(cur||!s.empty()){
if(cur){s.push(cur); cur = cur->left;}
else{
cur = s.top();
sequence.push_back(cur->val);
s.pop();
cur = cur->right;
}
};
return sequence;
}
};
队列
队列是一种先进先出的数据结构。队列总是从队尾加入元素，而从队首移除元素。
整型队列实现
清空队列 front = rear = - 1;
获取size return rear -front;
判空 return rear == front;
入队列 q[++rear] = x;
出队列 front++;
获取队首元素 return q[front+1];
获取队尾元素 return q[rear];
STL容器实现
#include<queue>
提供函数接口 front() back() pop() empty() size() push()
使用front() pop() back()前务必判断队列不为空
清空队列需要自己实现。
优先队列
priority_queue优先队列，其底层是用堆实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。
任何时候都可以向priority_queue里push元素，priority_queue底层的heap会随时调整结构，使得每次的队首元素都是优先级最大的。
使用priority_queue 应先添加头文件#include<queue>;
优先队列中没有front和back函数。只能用top()函数访问队首元素（堆顶元素）。
使用top前需要判断队列是否为空。
priority_queue支持的操作有push top pop empty size.
设置priority_queue内元素的优先级
基本数据类型优先级设定：
默认int,double数字大的优先级高，char型默认字典序大的优先级高。
priority_queue<elemtype, vector<elemtype>, less<elemtype> > q;
vector<elemtype>填写的是用来承载底层数据结构堆的容器。
最后一个参数, less<elemtype>表示数字大的优先级大，而greater<int>表示数组小的优先级高。
结构体优先级设定：
最直观的方法是重载运算法 <
例如：
struct fruit{
string name;
int price;
friend bool operator < (fruit f1, fruit f2){
return f1.price < f2.price;
}
}
这时就可以直接定义 priority_queue<fruit>q;
还可以通过重载函数：
struct cmp{
bool operator()(fruit f1, fruit f2){
return f1.price > f2.price;
}
priority_queue<fruit,vector<fruit>,cmp> q;
}
使用引用可以提高效率，建议加入&和const
friend bool operator < (const fruit &f1,const fruit &f2){]
bool operator()(const fruit &f1,const fruit &f2){}
题目 优先队列
class Solution {
public:
int getKthMagicNumber(int k) {
priority_queue<long,vector<long>,greater<long> > q;
long temp = 0;
q.push(1);
while(k--){
while(temp== q.top()){
q.pop();
}
temp = q.top();
q.pop();
q.push(temp*3);
q.push(temp*5);
q.push(temp*7);
}
return temp;
}
};
循环队列与双端队列
为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。通常rear指向队尾下一个，用front==rear判断是否为空，(rear +1)%size == front判断是否满，这样会浪费一个空间。
双端队列是指两端都可以进行入队和出兑操作的队列。
题目，循环双端队列
class MyCircularDeque {
public:
int sizeofq;
vector<int> deque;
int front,rear;
/** Initialize your data structure here. Set the size of the deque to be k. */
MyCircularDeque(int k) {
sizeofq = k;
deque.resize(sizeofq + 1);
front = 0;
rear = 0;
}
/** Adds an item at the front of Deque. Return true if the operation is successful. */
bool insertFront(int value) {
if(isFull()) return false;
else if (isEmpty()){
deque[rear] = value;
rear = ++rear%(sizeofq + 1);
return true;
}
else{
front = (--front + (sizeofq+1))%(sizeofq+1);
deque[front] = value;
return true;
}
}
/** Adds an item at the rear of Deque. Return true if the operation is successful. */
bool insertLast(int value) {
if(isFull()) return false;
deque[rear] = value;
rear = ++rear %(sizeofq+1);
return true;
}
/** Deletes an item from the front of Deque. Return true if the operation is successful. */
bool deleteFront() {
if(isEmpty()) return false;
front = ++front % (sizeofq+1);
return true;
}
/** Deletes an item from the rear of Deque. Return true if the operation is successful. */
bool deleteLast() {
if(isEmpty()) return false;
rear = (--rear + (sizeofq+1)) % (sizeofq+1);
return true;
}
/** Get the front item from the deque. */
int getFront() {
if(isEmpty()) return -1;
return deque[front];
}
/** Get the last item from the deque. */
int getRear() {
if(isEmpty()) return -1;
return deque[(rear+sizeofq) % (sizeofq+1)];
}
/** Checks whether the circular deque is empty or not. */
bool isEmpty() {
return front == rear;
}
/** Checks whether the circular deque is full or not. */
bool isFull() {
return (rear + 1)%(sizeofq + 1) == front;
}
};
/**
* Your MyCircularDeque object will be instantiated and called as such:
* MyCircularDeque* obj = new MyCircularDeque(k);
* bool param_1 = obj->insertFront(value);
* bool param_2 = obj->insertLast(value);
* bool param_3 = obj->deleteFront();
* bool param_4 = obj->deleteLast();
* int param_5 = obj->getFront();
* int param_6 = obj->getRear();
* bool param_7 = obj->isEmpty();
* bool param_8 = obj->isFull();
*/
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
