栈的几个问题

1.合法的出栈序列

代码如下：

#include<cstdio>
#include<stack>

using namespace std;

/*
现有一个空栈s，和一个正整数n，将1,2,3,...,n依次入栈，期间任意时刻出栈。
然后给定一个出栈序列，问其是否是一个合法的出栈序列。
*/

int main()
{
	int n;
	scanf("%d", &n);
	stack<int> s;

	int x, nowMax = 0; //x用来存储序列中的一个数,nowMax用来存储当前最大整数
	bool isValid = true;//用来判断序列是否合理

	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		if (x > nowMax)//如果下一个数比之前的最大数大
		{	//则从之前的最大数下一个数开始入栈
			for (int j = nowMax+1; j <=x ; j++)
			{
				s.push(j);
			}
			nowMax = x;
		}

		if (s.top() != x) {
			isValid = false;
			break;
		}
		else
		{
			s.pop();
		}
	}

	printf(isValid ? "Yes" : "No");

	return 0;
}

2.可能的出栈序列

这道题可以结合第一道题，用到了DFS思想

3.后缀表达式-无优先级

开始的时候我以为要用到栈结构，结果是我想复杂了

代码如下：

#include<iostream>
#include<string>

using namespace std;

string toPostfixExpr(string infixExpr) {
	string result = "";//用于存储后缀表达式。

	//将中缀表达式的第一个字符直接加入结果字符串 result 中
	result += infixExpr[0];
	
	for (int i = 2; i < infixExpr.length(); i+=4)
	{
		//添加一个空格，用于分隔后缀表达式中的各个元素。
		result += " ";

		//将下一个操作数加入 result
		result += infixExpr[i + 2];
		
		//添加一个空格，用于分隔后缀表达式中的各个元素。
		result += " ";

		//将当前操作符加入 result
		result += infixExpr[i];
	}
	return result;
}

int main()
{
	string expr;
	getline(cin, expr);
	cout << toPostfixExpr(expr);
	return 0;
}

4.后缀表达式-有优先级

代码及注释如下：

#include<iostream>
#include<vector>
#include<stack>
#include<map>
#include<string>

using namespace std;

//涉及多值（数字、字符和优先级）可以考虑用结点
struct Node {
	int num;
	char op;
	bool isOp;//用来判断是数字还是字符
};

map<char, int> priority;//字符＆优先级的映射

//将输入的中缀表达式转换为节点向量 infix
//将字符串分类处理，放入vector容器中
vector<Node> toNodeVector(string expr) {
	vector<Node> nodes;

	for (int i = 0; i < expr.length(); i++)
	{
		if (expr[i] == ' ') {
			continue;
		}

		if (expr[i] >= '0' && expr[i] <= '9') {
			Node numNode;
			numNode.isOp = false;
			numNode.num = expr[i] - '0';//字符串转变为数字存储
			nodes.push_back(numNode);//在vector后面添加元素numNode
		}
		else
		{
			Node opNode;
			opNode.isOp = true;
			opNode.op = expr[i];
			nodes.push_back(opNode);
		}
	}
	return nodes;
}

//其转换为后缀表达式存储在 postfix 中
//infix是上面处理后的字符串所存储在的vector
vector<Node> toPostfixVector(vector<Node> infix) {
	vector<Node> postfix;//存储最终的后缀表达式节点序列
	stack<Node> opStack;//用于存储操作符的栈

	//对字符串所在vector容器进行处理
	for (int i = 0; i < infix.size(); i++)
	{
		//如果当前节点是操作符
		if (infix[i].isOp) 
		{//则需要处理操作符的优先级和结合性
			while (!opStack.empty()&&priority[infix[i].op]<=priority[opStack.top().op])
			{//如果此时入栈操作符  比栈顶操作符（即*或/）优先级低，或等于栈顶操作符优先级 
			 //或者说  入栈操作符是  -或+	
			 //则将栈内操作符弹出到postfix中先结合
				postfix.push_back(opStack.top());
				opStack.pop();
			}
			opStack.push(infix[i]);
		}
		//如果当前节点是操作数
		else
		{
			postfix.push_back(infix[i]);//直接将其加入后缀表达式序列 postfix 中
		}
	}

	while (!opStack.empty())
	{
		postfix.push_back(opStack.top());
		opStack.pop();
	}

	return postfix;
}

int main()
{
	priority['+'] = priority['-'] = 0;
	priority['*'] = priority['/'] = 1;

	string expr;
	getline(cin, expr);

	vector<Node> infix = toNodeVector(expr);
	vector<Node> postfix = toPostfixVector(infix);

	for (int i = 0; i < postfix.size(); i++)
	{
		if (postfix[i].isOp) {
			cout << postfix[i].op;
		}
		else {
			cout << postfix[i].num;
		}
		if (i < (int)postfix.size() - 1) {
			cout << " ";
		}
	}

	return 0;
}

主要分三步走：

①输入的运算式字符串分类处理，存储在vector容器中

②将vector中存储的中缀表达式按照一定规则转换成后缀表达式

③按照要求输出表达式

5.后缀表达式-求值

#include<iostream>
#include<cstdio>
#include<string>
#include<map>
#include<vector>
#include<stack>

using namespace std;

struct Node {
	int num;
	char op;
	bool isOp;
};

map<char, int> priority;

vector<Node> toNodeVector(string expr) {
	vector<Node> nodes;

	for (int i = 0; i < expr.length(); i++)
	{
		if (expr[i] == ' ')
			continue;
		if (expr[i] >= '0' && expr[i] <= '9') {
			Node numNode;
			numNode.num = expr[i] - '0';
			numNode.isOp = false;
			nodes.push_back(numNode);
		}

		else
		{
			Node opNode;
			opNode.op = expr[i];
			opNode.isOp = true;
			nodes.push_back(opNode);
		}
	}

	return nodes;
}

double eval(vector<Node> postfix) {
	stack<double> numStack;
	
	for (int i = 0; i < postfix.size(); i++)
	{
		if (!postfix[i].isOp)
			numStack.push(postfix[i].num);

		else
		{
			double num2 = numStack.top();
			numStack.pop();
			double num1 = numStack.top();
			numStack.pop();
			if (postfix[i].op == '+')
				numStack.push(num1 + num2);
			else if (postfix[i].op == '-')
				numStack.push(num1 - num2);
			else if (postfix[i].op == '*')
				numStack.push(num1 * num2);
			else
				numStack.push(num1 / num2);
		}
	}

	return numStack.top();
}

int main()
{

	string expr;
	getline(cin, expr);

	vector<Node> postfix = toNodeVector(expr);
	printf("%.2f", eval(postfix));

	return 0;
}

总结：

开始的时候我考虑到运算符优先级问题，后面发现可以不用到优先级，因为后缀表达式本身就是便于计算机求解的式子，运用栈的特点可以很方便地求解出来。

①先处理原始后缀表达式字符串，放入数组中（基本操作，可参考问题4）

②结合栈的特点，判断运算符类型，计算

6.简单计算器

结合问题4、问题5，组合一下代码就可以了，代码如下：

#include<iostream>
#include<vector>
#include<map>
#include<stack>
#include<string>

using namespace std;

struct Node {
	int num;
	char op;
	bool isOp;
};

map<char, int> priority;

vector<Node> toNodeVector(string expr) {
	vector<Node> nodes;
	
	for (int i = 0; i < expr.length(); i++)
	{
		if (expr[i] == ' ') {
			continue;
		}

		if (expr[i] >= '0' && expr[i] <= '9') {
			Node numNode;
			numNode.isOp = false;
			numNode.num = expr[i] - '0';
			nodes.push_back(numNode);
		}

		else
		{
			Node opNode;
			opNode.isOp = true;
			opNode.op = expr[i];
			nodes.push_back(opNode);
		}
	}

	return nodes;
}

vector<Node> toPostfixVector(vector<Node> infix) {
	vector<Node> postfix;
	stack<Node> opStack;

	for (int i = 0; i < infix.size(); i++)
	{
		if (infix[i].isOp)
		{
			while (!opStack.empty()&&priority[infix[i].op]<=priority[(opStack.top()).op])
			{
				postfix.push_back(opStack.top());
				opStack.pop();
			}

			opStack.push(infix[i]);
		}
		else
		{
			postfix.push_back(infix[i]);
		}
	}

	while (!opStack.empty())
	{
		postfix.push_back(opStack.top());
		opStack.pop();
	}

	return postfix;
}

double eval(vector<Node> postfix) {
	stack<double> numStack;

	for (int i = 0; i < postfix.size(); i++)
	{
		if (!postfix[i].isOp)
			numStack.push(postfix[i].num);

		else
		{
			double num2 = numStack.top();
			numStack.pop();
			double num1 = numStack.top();
			numStack.pop();
			if (postfix[i].op == '+')
				numStack.push(num1 + num2);
			else if (postfix[i].op == '-')
				numStack.push(num1 - num2);
			else if (postfix[i].op == '*')
				numStack.push(num1 * num2);
			else
				numStack.push(num1 / num2);
		}
	}

	return numStack.top();
}

int main()
{
	priority['+'] = priority['-'] = 0;
	priority['*'] = priority['/'] = 1;

	string expr;
	getline(cin, expr);

	vector<Node> infix = toNodeVector(expr);
	vector<Node> postfix = toPostfixVector(infix);

	printf("%.2f", eval(postfix));

	return 0;

}