栈的几个问题

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思想

具体过程细节

1. DFS生成排列：

   • 我们使用一个布尔数组used来记录哪些数字已经被使用。
   • 在DFS函数中，我们递归地尝试将每个未使用的数字加入到当前排列temp中，然后继续递归，直到生成一个完整的排列。
   • 当生成一个完整的排列后，我们调用isValidSeq函数来验证这个排列是否是一个合法的出栈序列。

2. 验证合法性：（此处可以参考Q1.合法的出栈序列函数）

   • 在isValidSeq函数中，我们使用一个栈s来模拟入栈和出栈的过程。
   • 我们维护一个变量nowMax，表示当前已经入栈的最大元素。对于排列中的每个元素，如果它大于nowMax，则我们需要将nowMax+1到该元素之间的所有元素依次入栈。
   • 每次遍历到一个元素时，我们检查栈顶元素是否与该元素相等。如果相等，则出栈；否则，说明这个排列不是一个合法的出栈序列。

时空复杂度

• 时间复杂度：生成所有排列的时间复杂度是O(n!)，验证每个排列的时间复杂度是O(n)。因此，总的时间复杂度是O(n!⋅n)。
• 空间复杂度：我们需要存储所有排列和中间结果，因此空间复杂度是O(n!)。

 

#include <cstdio>
#include <vector>
#include <stack>
using namespace std;

const int MAXN = 8 + 1;
vector<vector<int> > result;
vector<int> temp;
bool used[MAXN] = {false};

bool isValidSeq(vector<int> v) {
    stack<int> s;
    int nowMax = 0;
    for (int i = 0; i < v.size(); i++) {
        if (v[i] > nowMax) {
            for (int j = nowMax + 1; j <= v[i]; j++) {
                s.push(j);
            }
            nowMax = v[i];
        }
        if (s.top() != v[i]) {
            return false;
        } else {
            s.pop();
        }
    }
    return true;
}

void DFS(int idx, int n) {
    if (idx == n + 1) {
        if (isValidSeq(temp)) {
            result.push_back(temp);
        }
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (!used[i]) {
            temp.push_back(i);
            used[i] = true;
            DFS(idx + 1, n);
            used[i] = false;
            temp.pop_back();
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    DFS(1, n);
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            printf("%d", result[i][j]);
            printf(j + 1 < result[i].size() ? " " : "\n");
        }
    }
    return 0;
}

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;

}