一本通 3.1.1 栈的基本应用

1331：【例1-2】后缀表达式的值

【题目描述】

从键盘读入一个后缀表达式（字符串），只含有0-9组成的运算数及加（+）、减（—）、乘（*）、除（/）四种运算符。每个运算数之间用一个空格隔开，不需要判断给你的表达式是否合法。以@作为结束标志。

比如，16–9*(4+3)转换成后缀表达式为：16□9□4□3□+*–，在字符数组A中的形式为：

栈中的变化情况：

运行结果：-47 

提示：输入字符串长度小于250，参与运算的整数及结果之绝对值均在范围内，如有除法保证能整除。

【题目分析】

读入一个字符c
如果为数字，进行数字的记录，num=num*10+c-'0'
如果为空格，将记录的数字入栈 sta.push(num),num=0;
如果为加号，从栈中取出两个数进行加运算，再放入栈
如果为减号，从栈中取出两个数进行减运算，再放入栈
如果为乘号，从栈中取出两个数进行乘运算，再放入栈
如果为除号，从栈中取出两个数进行除运算，再放入栈
最后结果为栈顶数

【代码实现】

#include <bits/stdc++.h>

using namespace std;

stack<long long> st;
int main() {
	//input data
	char c;
	long long num = 0;
	while (scanf("%c", &c), c != '@') {
		if (c >= '0' && c <= '9') {
			num = num * 10 + c - '0';
		}
		if (c == '+') {
			long long x = st.top();
			st.pop();
			long long y = st.top();
			st.pop();
			st.push(y + x);
		}
		if (c == '-') {
			long long x = st.top();
			st.pop();
			long long y = st.top();
			st.pop();
			st.push(y - x);
		}
		if (c == '*') {
			long long x = st.top();
			st.pop();
			long long y = st.top();
			st.pop();
			st.push(y * x);
		}
		if (c == '/') {
			long long x = st.top();
			st.pop();
			long long y = st.top();
			st.pop();
			st.push(y / x);
		}
		if (c == ' ') {
			st.push(num);
			num = 0;
		}
	}
	cout << st.top();
	return 0;
}

1353：表达式括号匹配(stack)

【题目描述】

假设一个表达式有英文字母（小写）、运算符（+，—，∗，/+，—，∗，/）和左右小（圆）括号构成，以“@@”作为表达式的结束符。请编写一个程序检查表达式中的左右圆括号是否匹配，若匹配，则返回“YES”；否则返回“NO”。表达式长度小于255，左圆括号少于2020个。

【题目分析】

定义一个字符栈sta，循环读入一个字符c
如果是左括号，直接入栈 
如果是右括号，判断栈是否为空，不为空弹出一个元素，如果为空，压入当前括号，退出循环
最后判断栈是否为空，如果为空 输出“YES” 否则输出“NO”

【代码实现】

#include <bits/stdc++.h>

using namespace std;

stack<char> st;
//当栈为空时，不能访问st.top()
int main() {
	//input data
	char c;
	while (scanf("%c", &c), c != '@') {
		if (c == '(') {
			st.push('(');
		}
		if (c == ')') {
			if (st.empty()) {
				st.push(c);
				break;
			} else
				st.pop();
		}
	}
	if (st.empty()) cout << "YES";
	else cout << "NO";

	return 0;
}

 1354：括弧匹配检验

【题目描述】

假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ］）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。

现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？

输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。输入一个字符串：［（［］［］）］，输出：OK。

【题目分析】

定义一个字符栈，循环读入一个字符c
如果为“[”或者"(",直接入栈，
如果为“]”判断栈不为空且栈顶元素为"]" 弹出一个元素 否则 压入c，退出循环
如果为“)”判断栈不为空且栈顶元素为"(" 弹出一个元素 否则 压入c，退出循环
最后判断栈为空，输出“YES” 否则输出“NO”

【代码实现】

#include <bits/stdc++.h>

using namespace std;

stack<char> st;
int main() {
	//input data
	char c;
	while (scanf("%c", &c), c != '\n') {
		if (c == '(' || c == '[') st.push(c);
		if (c == ')') {
			if (!st.empty() && st.top() == '(') st.pop();
			else {
				st.push(c);
				break;
			}
		}
		if (c == ']') {
			if (!st.empty() && st.top() == '[') st.pop();
			else {
				st.push(c);
				break;
			}
		}
	}

	if (st.empty())  cout << "OK";
	else   cout << "Wrong";
	return 0;
}

 1355：字符串匹配问题(strs)

【题目描述】

字符串中只含有括号 (),[],<>,{},判断输入的字符串中括号是否匹配。如果括号有互相包含的形式，从内到外必须是<>,(),[],{}，例如。输入: [()] 输出:YES，而输入([])，([)]都应该输出NO。

【题目分析】

特别的：如果括号有互相包含的形式，从内到外必须是<>,(),[],{} 中间可以省略一种括号，例如。输入: [()] 输出:YES，而输入([])，([)]都应该输出NO   

对括号进行编号：1 <>,2 (),3 [], 4 {}

循环读入每个字符c，对每个字符进行匹配：
如果字符为“<” 直接压入栈，如果字符为“>”而且栈首元素为1，将队首弹栈，否则设置退出循环标志
如果字符为“>” 且栈首元素为1，将队首弹栈，否则设置循环退出标记
如果字符为“(”  判断队首元素是否>=2（满足括号顺序）或者栈为空，2进栈，否则设置循环退出标记
如果字符为“）”且栈首元素为2，将队首弹栈，否则设置循环退出标记
如果字符为“[”  判断队首元素是否>=3（满足括号顺序）或者栈为空，3进栈，否则设置循环退出标记
如果字符为“]”  且栈首元素为3，将队首弹栈，否则设置循环退出标记
如果字符为“{”  判断队首元素是否==4（满足括号顺序）或者栈为空，4进栈，否则设置循环退出标记
如果字符为“}”  且栈首元素为4，将队首弹栈，否则设置循环退出标记
根据循环退出标记判断是否退出循环
循环外进行栈为空且退出标记不为-1，输出YES，否则输出NO

【代码实现】

#include <bits/stdc++.h>

using namespace std;

stack<char> st;
vector<char> back;
bool isdig(char c) {
	if (c >= '0' && c <= '9') return true;
	else return false;
}
int main() {
	//input data
	char c;
	//将中缀表达方式转化为后缀表达式  back
	while (scanf("%c", &c), c != '\n') {
		if (isdig(c)) back.push_back(c);
		else {
			if (isdig(back.back())) back.push_back('@');
			if (st.empty()) st.push(c);
			else { //判断一下优先级
				if (c == '(') st.push(c);
				if (c == ')') {
					while (st.top() != '(') {
						back.push_back(st.top());
						st.pop();
					}
					st.pop();
				}
				if (c == '+' || c == '-') {
					while (st.top() != '(' ) {
						back.push_back(st.top());
						st.pop();
						if (st.empty()) break;
					}
					st.push(c);
				}
				if (c == '*' || c == '/' || c == '^') {
					while (st.top() == '^' || st.top() == '*' || st.top() == '/') {
						back.push_back(st.top());
						st.pop();
						if (st.empty()) break;
					}
					st.push(c);
				}
			}
		}
	}
	if (isdig(back.back())) back.push_back('@');
	while (!st.empty()) {
		back.push_back(st.top());
		st.pop();
	}
	for (int i = 0; i < (int)back.size(); i++) {
		cout << back[i];
	}
	cout << endl;
//计算后缀表示式的数值
	stack<long long> stt;
	long long num = 0;
	for (int i = 0; i < (int)back.size(); i++) {
		if (back[i] >= '0' && back[i] <= '9') {
			num = num * 10 + back[i] - '0';
		}
		if (back[i] == '@') {
			stt.push(num);
			num = 0;
		}
		if (back[i] == '+') {
			long long x = stt.top();
			stt.pop();
			long long y = stt.top();
			stt.pop();
			stt.push(y + x);
		}
		if (back[i] == '-') {
			long long x = stt.top();
			stt.pop();
			long long y = stt.top();
			stt.pop();
			stt.push(y - x);
		}
		if (back[i] == '*') {
			long long x = stt.top();
			stt.pop();
			long long y = stt.top();
			stt.pop();
			stt.push(y * x);
		}
		if (back[i] == '/') {
			long long x = stt.top();
			stt.pop();
			long long y = stt.top();
			stt.pop();
			stt.push(y / x);
		}
		if (back[i] == '^') {
			long long x = stt.top();
			stt.pop();
			long long y = stt.top();
			stt.pop();
			stt.push((long long)pow(y, x));
		}
	}

//clock_t s = clock();
	cout << stt.top();
//cout <<endl<< clock() - s<<endl;
	return 0;
}

1356：计算(calc)

【题目描述】

小明在你的帮助下，破密了Ferrari设的密码门，正要往前走，突然又出现了一个密码门，门上有一个算式，其中只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，求出的值就是密码。小明数学学得不好，还需你帮他的忙。(“/”用整数除法)

【题目分析】

使用栈将中缀转化为后缀

1.设定运算符栈；
2.从左到右遍历中缀表达式的每个数字和运算符；
3.若当前字符是数字，则直接输出成为后缀表达式的一部分；
4.若当前字符为运算符，则判断其与栈顶运算符的优先级，若优先级大于栈顶运算符，则进栈；若优先级小于等于栈顶运算符，退出栈顶运算符成为后缀表达式的一部分，然后将当前运算符放入栈中；
5.若当前字符为“(”，进栈；
6.若当前字符为“)”，则从栈顶起，依次将栈中运算符出栈成为后缀表达式的一部分，直到碰到“(”。将栈中“(”出栈，不需要成为后缀表达式的一部分，然后继续扫描表达式直到最终输出后缀表达式为止。

使用栈算后缀表达式的值

当前是数字，数字累加，当前不是数字 将记录的数字入栈
当前是运算符，从栈中取出两个数进行运算符的计算
循环结束，在栈首的元素即为后缀表达式的值

两者可以同时进行  特别的：数字可能为0，数字可能是多位数，^ * / 三者的优先级相同

【代码实现】

#include <bits/stdc++.h>

using namespace std;

char a[255];
stack<int> st_int;

void calc(char c) {
	int x = st_int.top();
	st_int.pop();
	int y = st_int.top();
	st_int.pop();
	switch (c) {
		case '+':
			x = x + y;
			break;
		case '-':
			x = y - x;
			break;
		case '*':
			x = x * y;
			break;
		case '/':
			x = y / x;
			break;
		case '^':
			x = pow(y, x);
			break;
	}
	st_int.push(x);
}
int main() {
	//input data
	cin.getline(a, 255);
	int n = strlen(a);
	stack<char> st_ch;
	int num = 0;
	bool flag = 0;
	for (int i = 0; i < n; i++) {
		if (isalnum(a[i])) {
			num = num * 10 + a[i] - '0';
			flag = 0;
		} else {
			if (flag == 0) {
				st_int.push(num);
				num = 0;
				flag = 1;
			}
			switch (a[i]) {
				case '+':
					while (!st_ch.empty() && st_ch.top() != '(') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.push(a[i]);
					break;
				case '-':
					while (!st_ch.empty() && st_ch.top() != '(') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.push(a[i]);
					break;
				case '*':
					while (!st_ch.empty() && st_ch.top() != '(' && st_ch.top() != '+' && st_ch.top() != '-') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.push(a[i]);
					break;
				case '/':
					while (!st_ch.empty() && st_ch.top() != '(' && st_ch.top() != '+' && st_ch.top() != '-') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.push(a[i]);
					break;
				case '^':
					while (!st_ch.empty() && st_ch.top() != '(' && st_ch.top() != '+' && st_ch.top() != '-') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.push(a[i]);
					break;
				case '(':
					st_ch.push(a[i]);
					break;
				case ')':
					while (st_ch.top() != '(') {
						calc(st_ch.top());
						st_ch.pop();
					}
					st_ch.pop();
					break;
			}
		}
	}
	if (flag == 0) {
		st_int.push(num);
		num = 0;
	}
	while (!st_ch.empty()) {
		calc(st_ch.top());
		st_ch.pop();
	}
	cout << st_int.top();
	return 0;
}

1357：车厢调度(train)

【题目描述】

有一个火车站，铁路如图所示，每辆火车从A驶入，再从B方向驶出，同时它的车厢可以重新组合。假设从A方向驶来的火车有n节（n≤1000），分别按照顺序编号为1，2，3，…，n�。假定在进入车站前，每节车厢之间都不是连着的，并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C，它就不能再回到A方向的铁轨上了，并且一旦当它进入B方向的铁轨，它就

不能再回到车站C。

负责车厢调度的工作人员需要知道能否使它以a1,a2,…,an的顺序从B方向驶出，请来判断能否得到指定的车厢顺序。 

【题目分析】

内层循环：（栈为空 or 栈顶不和需要的元素匹配）and 外面还有元素，就将外面的元素入栈
内层循环：（栈不为空 and 栈顶元素与需要的元素匹配），出栈
外层 循环上述过程，外面没有元素 退出循环 
栈不为空，输出NO，否则 输出YES

【代码实现】

#include <bits/stdc++.h>

using namespace std;

int n, cnt = 1;
int a[1005];
stack<int> sta;
int main() {
	//input data
	cin >> n;
	for (int i = 1; i <= n; i++) {
		scanf("%d", a + i);
	}
	int i = 1;
	while (cnt <= n) {
		while ((sta.empty() || sta.top() != a[i]) && cnt <= n)	sta.push(cnt++);
		while (!sta.empty() && sta.top() == a[i])   sta.pop(), i++;
	}
	if (sta.empty()) cout << "YES";
	else cout << "NO";
	return 0;
}

1358：中缀表达式值(expr)

【题目描述】

输入一个中缀表达式（由0-9组成的运算数、加+减-乘*除/四种运算符、左右小括号组成。注意“-”也可作为负数的标志，表达式以“@”作为结束符），判断表达式是否合法，如果不合法，请输出“NO”；否则请把表达式转换成后缀形式，再求出后缀表达式的值并输出。

注意：必须用栈操作，不能直接输出表达式的值。

【题目分析】

合法与不合法的说明    

1、负号只可能出现在最前面或者左括号的右边
2、先进行括号匹配  进行不合法的输出
3、运算符与数字的数量 存在1的差值，否则不合法

使用栈将中缀转化为后缀

1.设定运算符栈；
2.从左到右遍历中缀表达式的每个数字和运算符；
3.若当前字符是数字，则直接输出成为后缀表达式的一部分；
4.若当前字符为运算符，则判断其与栈顶运算符的优先级，若优先级大于栈顶运算符，则进栈；若优先级小于等于栈顶运算符，退出栈顶运算符成为后缀表达式的一部分，然后将当前运算符放入栈中；
5.若当前字符为“(”，进栈；
6.若当前字符为“)”，则从栈顶起，依次将栈中运算符出栈成为后缀表达式的一部分，直到碰到“(”。将栈中“(”出栈，不需要成为后缀表达式的一部分，然后继续扫描表达式直到最终输出后缀表达式为止。

使用栈算后缀表达式的值

当前是数字，数字累加，当前不是数字 将记录的数字入栈
当前是运算符，从栈中取出两个数进行运算符的计算
循环结束，在栈首的元素即为后缀表达式的值

入栈条件判断：只有栈顶元素为加减，加入的元素为乘除时才返回true，否则返回false  可写成函数

【代码实现】

#include<bits/stdc++.h>

using namespace std;
/*运算符的优先级判断*/
bool judge(char a, char b) {
	return (a == '*' || a == '/' || a == '^') && (b == '+' || b == '-') ? true : false;
}
bool tf(char a[], char b[]) { //将a数组转化为b数组，既将中缀表达式转化为后缀表达式
	int len = strlen(a);
	char oper[255];
	memset(oper, 0, sizeof(oper));
	int top = 0, cnt = 0, i = 0;
	int num_or_oper = 0, pair_ = 0;
	bool flag;
	if (a[i] == '-')flag = true;
	else flag = false;
	while (i < len) {               //依次对a数组中的元素进行处理
		if ((a[i] >= '0' && a[i] <= '9') || flag == true) {
			if (flag == true) {
				b[cnt++] = '#';
				flag = false;
			}
			while (a[i] >= '0' && a[i] <= '9')b[cnt++] = a[i++];
			b[cnt++] = ' '; //如果为数字就直接输出
			num_or_oper++;
		} else if (a[i] == '(') {
			oper[++top] = a[i++];
			if (a[i] == '-') flag = true;
			pair_++;
		} else if (a[i] == ')') {
			while (oper[top] != '(') b[cnt++] = oper[top--];
			top--;
			i++;
			pair_--;
		} else { //输入为操作符
			while ((top != 0) && (oper[top] != '(') && (!judge(a[i], oper[top]))) { //出栈的条件：栈未空，操作优先级低，而且栈内不是左括号
				b[cnt++] = oper[top--];
			}
			oper[++top] = a[i++];      //运算符直接入栈
			num_or_oper--;
		}
	}
	while (top != 0)b[cnt++] = oper[top--];
	if (pair_ == 0 && num_or_oper == 1) return true;
	else return false;
}
int calc(char b[]) {
	int s = 1, i = 0;
	int stacks[255], top = 0;
	int len = strlen(b);
	memset(stacks, 0, sizeof(stacks));
	int flag = false;
	while (i < len) {
		switch (b[i]) {
			case '+':
				stacks[--top] += stacks[top + 1];
				break;
			case '-':
				stacks[--top] -= stacks[top + 1];
				break;
			case '*':
				stacks[--top] *= stacks[top + 1];
				break;
			case '/':
				stacks[--top] /= stacks[top + 1];
				break;
			case '^':
				s = 1;
				while (stacks[top]--) s *= stacks[top - 1];
				stacks[--top] = s;
				break;
			default :
				if (b[i] == '#')flag = true;
				s = 0;
				while (b[i] != ' ') s = s * 10 + b[i++] - '0';
				if (flag) {
					stacks[++top] = -s;
					flag = false;
				} else stacks[++top] = s;
				break;
		}
		i++;
	}
	return stacks[top];
}

int main() {
	char a[1010];
	char b[1010];
	memset(a, 0, sizeof(a));
	memset(b, 0, sizeof(b));
	cin >> a;
	a[strlen(a) - 1] = 0;
	if (tf(a, b))	cout << calc(b) << endl;
	else 		cout << "NO";
	return 0;
}