栈——后进先出

1、STL stack

stack<type> s //定义栈
s.push(item) //把item放到栈顶
s.top() 	 //返回栈顶元素，不会删除
s.pop()		 //删除栈顶元素，但不会返回。
//出栈时需执行两步操作，先使用top()获取栈顶元素，再使用pop()删除栈顶元素
s.size()	 //返回栈中元素的个数
s.empty() 	 //检查栈是否为空，为空则返回true，否则返回false

对比列表命令如下：

queue<Type> q//定义队列，Type为数据类型，如int,float,char等
q.push(i)
q.front()//队首
q.pop()
q.back()//队尾
q.size()
q.empty()

翻转字符串
输入样例：
2
hello world!
r u okay?
输出样例：
olleh !dlrow
r u ?yako

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n;
	cin>>n;
	getchar();
	while(n--){
		stack<char> s;
		while(true){
			char ch=getchar();
			if(ch==' ' ||ch=='\n' ||ch==EOF){
				while(!s.empty()){
					cout<<s.top();
					s.pop();
				}
				if(ch=='\n'||ch==EOF)
					break;
				cout<<' ';
			}
			else
				s.push(ch);
		}
		cout<<'\n';
	} 
	return 0;
} 

如果是整行翻转呢？（即遇空格时不做处理）

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n;
	cin>>n;
	getchar();
	while(n--){
		stack<char> s;
		while(1){
			char ch=getchar();
			if(ch=='\n' ||ch==EOF){
				while(!s.empty()){
					cout<<s.top();
					s.pop();
				}
			}
			else
				s.push(ch);
		}
		cout<<'\n';
	} 
	return 0;
} 

翻转整篇文档？

#include<bits/stdc++.h>
using namespace std;
int main(){
	stack<char> s;
	while(1){
		char ch=getchar();
		if(ch==EOF){
			while(!s.empty()){
				cout<<s.top();
				s.pop();
			}
			break; 
		}
		else
			s.push(ch);
	}
	return 0;
} 

2、手写栈

#include<bits/stdc++.h>
using namespace std;
const int N=100100;

struct mystack{
	char a[N];
	int t=0;
	void push(char x){a[++t]=x;}
	char top(){return a[t];}
	void pop(){t--;}
	int empty(){return t==0?1:0;}
}st;

int main(){
	int n;
	cin>>n;getchar();
	while(n--){
		while(true){
			char ch=getchar();
			if(ch==' ' || ch=='\n' || ch==EOF){
				while(!st.empty()){
					cout<<st.top();
					st.pop();
				}
				if(ch=='\n'||ch==EOF) break;
				cout<<' ';
			}else	st.push(ch);
		}
		cout<<'\n';
	}
	return 0;
}

3、单调栈

定义：单调栈内的元素是单调递增或递减的
例如，单调递减栈从栈顶到栈底从小到大顺序，当一个元素入栈时，与栈顶比较，若比栈顶小，则入栈。若比栈顶大，则弹出栈顶，直到这个数能入栈为止。

例题：向右看齐 洛谷P2947
输入样例：
6
3
2
6
1
1
2
输出样例：
3
3
0
6
6
0

思路：先读入每个奶牛的身高，从后向前遍历奶牛，之后使用一个单调栈保存从低到高的奶牛身高，栈顶的最矮，栈底的最高。
具体操作：遍历到奶牛i时，将栈顶的奶牛与其进行比较，如果不比奶牛i高，则弹出栈顶，知道栈顶的奶牛比奶牛i高，这就是奶牛的仰望对象；然后把i放进栈顶，栈中的奶牛依然保持从低到高。
每头奶牛只进栈一次，所以时间复杂度为O(n)

STL stack:

#include<bits/stdc++.h>
using namespace std;
int h[100001],ans[100001];

int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>h[i];
	stack<int> st;
	for(int i=n;i>=1;i--){
		while(!st.empty() && h[st.top()]<=h[i])
			st.pop();//栈顶奶牛没有i高，弹出它，直到栈顶奶牛更高为止
		if(st.empty()) 
			ans[i]=0;
		else
			ans[i]=st.top();
		st.push(i);			 
	}
	for(int i=1;i<=n;i++)
		cout<<ans[i]<<'\n';
	return 0;
} 

手写栈：

#include<bits/stdc++.h>
using namespace std;
const int N=100100;

struct mystack{
	int a[N];
	int t=0;
	void push(int x){a[++t]=x;}
	int top(){return a[t];}
	void pop(){t--;	}
	int empty(){return t==0?1:0;}
}st;

int h[N],ans[N];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>h[i];
	for(int i=n;i>=1;i--){
		while(!st.empty() && h[st.top()]<=h[i])
			st.pop();//栈顶奶牛没有i高，弹出它，直到栈顶奶牛更高为止
		if(st.empty()) 
			ans[i]=0;
		else
			ans[i]=st.top();
		st.push(i);			 
	}
	for(int i=1;i<=n;i++)
		cout<<ans[i]<<'\n';
	return 0;
}