栈的应用

栈具有先进后出的特点，这个特点在解决某些问题时是很有效的。本节我们来看几个栈的常见应用以及栈结构适合解决的问题类型。

1 数制转换

我们日常生活中用的是十进制，而计算机中绝大多数时候是二进制，八进制或十六进制，这就涉及到数制转换的问题。十进制向其他进制转换一般是通过连除实现的，例如，如果我们想找出十进制的 42 对应的二进制表示，就需要对 42 连除 2，直到商为 0 。下图展示了完整过程：

用公式概括就变为了：
N=(Ndivd)×d+NmoddN = (N\ \mathrm{div} \ d ) \times d + N\ \mathrm{mod}\ d N=(N div d)×d+N mod d
其中，div\mathrm{div}div 为整除运算，mod\mathrm{mod}mod 为求余运算。

假设现在要编写一个程序来将任意的十进制数转换为八进制数。由于上述方法最先计算出的余数位于最低位，最后计算出的位于最高位，符合后入先出的思想，所以可以用栈来保存余数。

/** Function: 进制转换函数* ----------------------------* 输入一个十进制数，转换为对应的八进制表示。*/
void conversion(int n){int r;          // 用来保存余数LinkedStack S;InitStack(S);while (n!=0){r = n % 8;    // 求余数n = n / 8;   // 将n更新为商，以便后续运算Push(S, r); // 将余数入栈}Print(S);       // 将栈内元素输出
}

2 括号匹配问题

括号匹配问题是关于栈的结构考察中最常见的一类问题，也是很能体现栈的结构特点的一类问题。假设一个表达式中可以包含三种括号：小括号，中括号和大括号，我们要用程序来检测这个表达式中每一个左括号是否都有以正确形式与之对应的右括号。例如：

// 为了表示方便，表达式中只写出括号
{[()]}          // 正确
{}[()]()        // 正确
)[]             // 错误，缺失对应的括号
[(])            // 错误，对应形式不正确

让我们先以 “{ [ ( ) ] }” 为例，分析一下如何正确的检测。

首先我们会接收第一个左大括号 “{”，为了与之匹配，我们希望尽快接到一个右大括号 “}”。
然后我们会接收到一个左中括号 “[”。此时，我们希望尽快接收到一个右中括号来正确匹配，否则就会出现如 “{ [ }” 的错误匹配。因此，我们最紧急的任务就从匹配大括号变为了匹配中括号。
之后我们会接收到一个左小括号 “(”，按照上述分析，我们最紧急的任务又变成了匹配小括号。
接收右小括号，完成匹配并消除小括号，开始处理中括号的匹配。
接收右中括号，完成匹配并消除中括号，开始处理大括号的匹配。
接收右大括号，完成匹配并消除打括号，匹配完成。

通过上述分析我们发现，在解决括号匹配问题的过程中，我们提出了一系列的任务，最后被提出的任务拥有最高的优先级，即最紧急的任务，需要最早被完成。这一点也正好符合栈的特点：后入先出，因此可以用栈来帮助解决这个问题。详细的实现步骤如下：

创建一个栈用来接收待读取的括号。
逐个检测括号，首先检测括号表达式的第一位是否为左括号，如不是则直接返回 false；如是则压入栈中。
如果不是第一位且为左括号，压入栈中。
如果不是第一位且为右括号，将栈顶元素与该括号匹配，如能匹配则弹出栈顶元素；如不能则直接返回 false。
循环第3-4步直到读取完所有的括号。
检测栈是否为空，如果为空，则代表所有的括号全部正确匹配，返回 true；否则就代表有多余的左括号，返回 false。

上述步骤中，左括号会被压入栈内，但右括号一定不会被压入栈内，只用来检测栈顶元素是否匹配。这主要是因为在该问题中左括号和右括号有不同的作用，左括号可以被抽象地理解为待操作的数值，待解决的问题等，而右括号就是对应的操作或解决办法。具体到这个问题，左括号就代表一个待匹配的任务，而对应的右括号就代表完成了匹配任务。尝试将输入数据分为待操作的数值和对应的操作两类是用栈解决很多问题时的常用思路，在下面的问题中会有更多说明。

括号匹配问题实现代码如下：

/** Function: 括号匹配检测* ----------------------------* 检测一个表达式中的括号是否匹配正确。* 支持的括号种类有三种：{}, []和()。*/
bool bracketMatch(string str){LinkedStack S;InitStack(S);string match = "{[(}])";    // 用来记录可能的括号输入char bracket;// 首先检测第一个元素是左括号还是右括号if (match.find(str[0])>2){return false;}for (int i=0;i<str.length();i++){// 开始配对if (match.find(str[i])<3){  // 如果是是左括号Push(S, str[i]);      } else {                    // 如果是右括号GetTop(S, bracket);if (match.find(str[i])-3==match.find(bracket)){       Pop(S, bracket);} else {return false;}}}return StackEmpty(S);
}

3 行编辑程序

行编辑程序是一种简单的文本编辑程序，它的主要功能是：接收用户输入的数据并存如数据区。但是用户在进行输入时不能保证不出差错，所以如果每输入一个数据就立刻保存显然是一种不好的做法。因此，我们希望有一段缓冲区，可以接收用户输入的一行数据，如果发现错误可以及时更改。例如，可以规定 “#” 为退格符，表示前一位数据无效；如果发现一行内有太多错误，可以规定 “@” 为退行符，表示当前行无效。例如，假设程序接收了这样的两行：

whli##ile (s#*s)outcha@putchar(*s=#++);

实际有效的是下列两行：

while (*s)putchar(*s++);

这种编辑程序的特点就是无法使用光标选择想要修改的位置，当前操作只能修改最新输入的字符，正好符合栈只能在栈顶修改元素的特性。在这一个问题中，我们将所有的输入数据分为两类，字符和操作符。我们只定义了两个操作符对字符进行操作，且都是对位于操作符之前的字符进行操作，所以结合栈的结构还是很好理解的。具体实现时，可以逐个检测输入的字符，如果是字符则存入栈内，如果是符号则弹出栈顶或是栈内全部元素。

4 综合计算器

下面来想一个稍复杂一点的问题，如何用栈实现一个简单的综合计算器。这个综合计算器有加减乘除四种操作，出于简单考虑，操作数仅限于整数。我们想输入一个表达式，然后让综合计算器来计算这个表达式，例如：计算 3+6*2-2。

第一眼看上去这个问题和行编辑程序问题很类似，输入数据都可以分为两类：操作数和操作符。但也有两点区别：一，计算器的操作符通常是二元的，即操作符左右两边的数都是它的操作数；二，计算器的操作符有不同的优先级，如乘除的优先级高于加减。

结合之前的想法，我们将输入数据分为操作数和操作符，依次读取表达式的元素，如果为数值就压入栈中；如果为操作符就开始对栈顶元素进行计算。那么首先将 3 入栈，然后检测到加法操作符，将 3 出栈并读取下一位数据 6，计算他们的和。但这时就会发现一个问题，原式中 6 应该属于优先级更高的乘法操作符的操作数，直接将它给予加法操作符会导致计算顺序产生错误。因此，我们还需要一些额外的信息来保存操作符的优先级，优先级最高的操作符应该是最早被执行的。而我们之前提到，栈的元素顺序就可以表示优先级，越靠近栈顶优先级越高。因此可以用栈来保存操作符，只需要将优先级最高的操作符放在栈顶即可。

那么，该问题的解决思路就是：

创建两个栈分别记录数字和符号。
遍历表达式，如果为数字，则直接入数字栈。
如果为符号，检测符号栈是否为空，如果为空，直接入栈。
如果不为空，
4.1. 待入栈符号的优先级高于或等于栈中符号的优先级，则直接入栈。
4.2.若待入栈符号的优先级小于栈中符号的优先级，则将数字栈前两位出栈，将当前符号栈中第一位出栈，运算后得到数字加入数字栈中，再加入符号。
重复第 2-4 步直到遍历完成。
若栈为空则直接返回；若栈不为空则将数字栈前两位出栈，符号栈第一位出栈，运算后得到数字加入数字栈中。
重复第 6 步直到数字栈中只有一位数字

注意： 上述第 4 步需要判断符号的优先级，虽然经常说加减属于同一优先级，但是加法满足交换律和结合律，而减法不满足，所以此处减法的优先级应当高于加法。例如：我们想计算 3-12+1 = -8，如果将加法和减法视为同样优先级的操作，按照上面的操作可得下图，那么最终计算出来的结果会是 3-(12+1) = -10，这显示是错误的。乘除同理。
以下只有部分代码，完整代码见附录。

/* Global variable */
stack<int> SN;      // 数字栈
stack<int> SO;      // 符号栈，用数字-4，-3，-2，-1来表示加，减，乘，除
string op = "+-*/"; // 记录四种操作符/** Function: 判断数字函数* Usage: bool b = isNumber(c);* ----------------------------* 判断输入的字符是否属于数字,* 如是则返回true；否则返回false。*/
bool isNumber(char c);/** Function: 读取函数* Usage: int read = readStr(str, i)* ---------------------------------* 用来读取表达式位置i之后的数字或符号。* 如果读取的是数字，则直接返回数字。* 如果读取的是符号，将加减乘除分别以整数-4,-3,-2,-1返回。*/
int readStr(string str, int &i);/** Function: 计算函数* Usage: int res = caculate(num1, num2, op);* ------------------------------------------* 用来计算运算结果并返回。*/
int caculate(int num1, int num2, int op);/** Function: 综合计算器* ----------------------------* 可以处理加减乘除在整数范围内的运算。* 不包括括号。*/
int counter(string str){int i = 0;          // 用来遍历表达式字符串int read = 0;       // 用来保存读取到的值int res = 0;        // 用来保存计算的结果int num1, num2;     // 用来保存从数字栈中弹出的值int op;             // 保存从符号栈中弹出的符号// 遍历字符串    while (i<str.length()){read = readStr(str, i);if (read>=0){               // 如果读取的是数字SN.push(read);          // 将数字压入栈中    } else {                    // 如果读取的是符号if (SO.empty() || SO.top()<read){        // 如果符号栈为空或待入栈符号的SO.push(read);                       // 优先级更高，直接压入    } else {                // 否则，先运算再压入while (!SO.empty() && read< SO.top()){num2 = SN.top(); SN.pop();num1 = SN.top(); SN.pop();op = SO.top(); SO.pop();res = caculate(num1, num2, op);SN.push(res);                     // 将新计算出来的值压入栈中}SO.push(read);}}}// 清空栈while (!SO.empty()){num2 = SN.top(); SN.pop();num1 = SN.top(); SN.pop();op = SO.top(); SO.pop();res = caculate(num1, num2, op);SN.push(res);                     // 将新计算出来的值压入栈中}return SN.top();
}

注意： 上述代码在只涉及整数（要求操作数必须是整数，操作的结果也必须是整数）时，可正常实现表达式的求值。但是在操作数为整数，操作结果不为整数时会和实际值有一些不同，这主要是因为C++的 “/” 符号代表的是求整数商。例如：计算 1+2*3/4 时，程序会先计算 3/4，整数商为 0，整个表达式结果为 1，不符合实际。只要将操作数类型从整数类型扩展为浮点数类型就可解决这个问题。

5 后缀表达式 Reverse Polish

通过综合计算器的实现，我们可以发现，对于计算机来说，即使是一个很简单的表达式也需要很繁琐的步骤来计算它。不过这主要是因为我们没有把表达式翻译为计算机可以理解的格式，在计算时需要用很多判断语句来帮助其理解正确的运算顺序。现在我们来介绍一种计算机更容易看懂的表达式——后缀表达式。

数学表达式可分为三种：前缀、中缀和后缀。我们一般使用的都是中缀表达式，即运算符在数字之间，这种表示方式人类很容易理解，但不利于计算机做运算。因此产生了前缀表达式（波兰式）和后缀表达式（逆波兰式），前和后分别表示二元运算符位于运算对象之前和之后，这两种表达式仅依靠入栈，出栈两种操作就可以完成中缀表达式的全部运算。

假如我们有表达式 (3+4)*5-6 ，那么其中缀、前缀及后缀表达式分别为：

中缀表达式： (3+4)*5-6
前缀表达式：- * + 3 4 5 6
后缀表达式：3 4 + 5 * 6 -

可以观察到前缀和后缀表达式都不含括号，这是因为他们经过格式转换后，符号的顺序就代表了计算的顺序，因此不再需要括号。我们上面实现的简易综合计算器就是一种中缀计算器，它其实更适合用树来实现，而前缀和后缀计算器更适合用栈实现。

5.1 后缀表达式

又称为逆波兰式，比前缀表达式更加常用，二元运算符总是置于与之相关的两个运算对象之后。例如，3 4 + 5 * 6 -，加号位于它的两个运算对象之后，第一个数 3 是加号的左操作数，第二个数 4 是加号的右操作数。

给定一个后缀表达式，它的运算规则如下：

运算规则

创建一个栈，用来保存数字
从左至右扫描后缀表达式，将数字依次存入数字栈
遇到运算符时，弹出栈顶的两个数
计算结果，压入数字栈中
重复上述步骤直到扫描到表达式的最右边

上述过程简洁易懂，可以看出后缀表达式在计算上的优势。这也表示如果有已经“翻译”好的表达式，计算机是可以进行快速又简洁的运算的。因此，我们再来看一下如何将中缀表达式转换为后缀表达式。

转换规则

创建两个栈，分别保存数字和运算符
从左到右遍历中缀表达式，如果是数字，就直接压入数字栈中
如果是 “(”，就直接压入符号栈
如果是 “)”，就从符号栈中弹出栈顶符号，压入数字栈中，重复该步骤直到将 “(” 弹出
如果是非括号符号+ - * /，则：
1. 如果符号栈为空，直接压入符号栈
2. 如果符号栈不为空且栈顶为 “(”，直接压入符号栈
3. 如果符号栈不为空且栈顶为非括号运算符，判断符号优先级。如果当前符号优先级高于或等于栈顶符号优先级，则直接压入符号栈
4. 如果当前符号优先级低于栈顶符号优先级，则需要从符号栈中弹出栈顶符号并压入数字栈中，重复该步骤直到当前符号优先级高于或等于栈顶符号优先级
重复第 2-5 步直到遍历整个中缀表达式
将符号栈元素出栈，压入数字栈中
最终数字栈中从栈底往栈顶方向就是完整的后缀表达式

注意：上述方法的转换结果有些问题，不符合从左向右的运算规则。例如计算 “A+B*(C-D)-E/F” , 用上述方法得到的后缀表达式为 “ABCD-*EF/-+”，按规则计算该后缀表达式，得如下步骤：

(C-D)
B*(C-D)
E/F
B*(C-D)-E/F
A+B*(C-D)-E/F

其中前三步都没有问题，但是到了第四步我们已经分别计算出了该表达式的三个部分：A、B*(C-D) 和 E/F，接下来按照从左向右的顺序计算即可。但是按照上述规则，我们先计算了减法部分，后计算的加法部分。这样做对答案不会产生影响，但是违反了从左向右计算的运算规则，所以得到的其实是错误的后缀表达式。（以后修改代码）

部分实现代码如下，完整代码见附录：

/* Global variable */
LinkedStack SN;     // 数字栈
LinkedStack SO;     // 符号栈
string op = "(+-*/)";   // 用来匹配符号，符号的位序越小代表其优先级越低/** Function: 判断数字函数* Usage: bool b = isNumber(c);* ----------------------------* 判断输入的字符是否属于数字,* 如是则返回true；否则返回false。*/
bool isNumber(char c);/** Function: 读取函数* Usage: int read = readStr(str, i);* ---------------------------------* 用来读取表达式位置i之后的数字或符号。* 如果读取的是数字，则直接返回数字。* 如果读取的是符号，将(,+,-,*,/,)分别以* 整数-6,-5,-4,-3,-2,-1返回。*/
int readStr(string str, int &i);void print();/** Function: 转换函数* Usage: conversion(string str);* ------------------------------* 输入一个中缀表达式，将其转换为后缀表达式，* 存入SO中并输出后缀表达式。*/
void conversion(string str){int i=0;        // 用来遍历中缀表达式int read=0;     // 用来保存读取到的值int res=0;      // 遍历表达式while (i<str.length()){read = readStr(str, i);if (read>=0){               // 如果读取的是数字Push(SN, read);         // 将数字压入数字栈中    } else {                                        // 如果读取的是符号if (read==-6){                              // 1.如果是左括号，则直接压入符号栈Push(SO, read);}else if (read==-1){                         // 2.如果是右括号，则将栈顶符号弹出并while (GetTop(SO)!=-6){                 // 压入数字栈，直到遇见左括号                      Push(SN, Pop(SO));}Pop(SO);                                // 将左括号弹出       } else if (StackEmpty(SO) || GetTop(SO)<read){// 3.如果符号栈为空或待入栈符号的Push(SO, read);                         // 优先级更高，直接压入符号栈}else {                                      // 4.如果符号栈非空且栈顶元素优先级更高，while (!StackEmpty(SO) && read< GetTop(SO)){  // 则将栈顶符号弹出并压入数字栈，Push(SN, Pop(SO));                  // 直到栈顶元素优先级低于待入栈符号                           }Push(SO, read);                         // 将待入栈符号压入符号栈}                                            }}// 将符号栈清空while (!StackEmpty(SO)){Push(SN, Pop(SO));}// 将数字栈中的元素倒序，存入符号栈中while (!StackEmpty(SN)){Push(SO, Pop(SN));}// 输出print();
}

5.2 前缀表达式

又称为波兰式，前缀表达式和后缀表达式的作用一样，都是为了方便计算机计算。表达式 (3+4)*5-6 的前缀表达式为 - * + 3 4 5 6。前缀表达式的运算规则和后缀表达式很类似，唯一的区别就是遍历方向不同。

运算规则

从右至左扫描前缀表达式，将数字依次存入数字栈
遇到运算符时，弹出栈顶的两个数
计算结果，压入数字栈中
重复上述步骤直到扫描到表达式的最左边

转换规则

转换规则和后缀表达式类似，只是要注意从右到左扫描中缀表达式，且左右括号的优先级互换，剩下的操作和后缀表达式一致。详情见后缀表达式。

附录

综合计算器的实现

/** Filename: Counter.cpp* -----------------------* 用栈实现综合计算器。*/#include <iostream>
#include <string>
#include <stack>
using namespace std;/* Prototype */
bool isNumber(char c);
int readStr(string str, int &i);
int caculate(int num1, int num2, int op);
int counter(string str);/* Global variable */
stack<int> SN;      // 数字栈
stack<int> SO;      // 符号栈，用数字-4，-3，-2，-1来表示加，减，乘，除
string op = "+-*/"; // 记录四种操作符/* Main program */
int main(){string str = "4/2-6/2+1*3";int res = counter(str);printf("The result is %d.\n", res);return 0;
}/** Function: 判断数字函数* Usage: bool b = isNumber(c);* ----------------------------* 判断输入的字符是否属于数字,* 如是则返回true；否则返回false。*/
bool isNumber(char c){return (48<=c && c<=57);
}/** Function: 读取函数* Usage: int read = readStr(str, i);* ---------------------------------* 用来读取表达式位置i之后的数字或符号。* 如果读取的是数字，则直接返回数字。* 如果读取的是符号，将加减乘除分别以整数-4,-3,-2,-1返回。*/
int readStr(string str, int &i){string num; // 用来读取数字int n = 0;  // 用来记录多位数在字符串中的下标if (isNumber(str[i])){          // 如果读取到的是数字while (i+n<str.length() && isNumber(str[i+n])){num[n] = str[i+n];              // 将读取到的连续数字存入num中n++;}i = i+n;                            // 更新i的值return stoi(num);}                             return op.find(str[i++])-4;             // 如果读取到的是操作符,则直接转换为数字返回
}/** Function: 计算函数* Usage: int res = caculate(num1, num2, op);* ------------------------------------------* 用来计算每一步计算的结果并返回。*/
int caculate(int num1, int num2, int op){int res=0;switch(op){case -4:                        // 加法res = num1+num2;break;case -3:                        // 减法res = num1-num2;break;case -2:                        // 乘法res = num1*num2;break;case -1:                        // 除法res = num1/num2;break;}return res;
}/** Function: 综合计算器* ----------------------------* 可以处理加减乘除在整数范围内的运算。* 不包括括号。*/
int counter(string str){int i = 0;          // 用来遍历表达式字符串int read = 0;       // 用来保存读取到的值int res = 0;        // 用来保存计算的结果int num1, num2;     // 用来保存从数字栈中弹出的值int op;             // 保存从符号栈中弹出的符号// 遍历字符串    while (i<str.length()){read = readStr(str, i);if (read>=0){               // 如果读取的是数字SN.push(read);          // 将数字压入栈中    } else {                    // 如果读取的是符号if (SO.empty() || SO.top()<read){        // 如果符号栈为空或待入栈符号的SO.push(read);                       // 优先级更高，直接压入    } else {                // 否则，先运算再压入while (!SO.empty() && read< SO.top()){num2 = SN.top(); SN.pop();num1 = SN.top(); SN.pop();op = SO.top(); SO.pop();res = caculate(num1, num2, op);SN.push(res);                     // 将新计算出来的值压入栈中}SO.push(read);}}}// 清空栈while (!SO.empty()){num2 = SN.top(); SN.pop();num1 = SN.top(); SN.pop();op = SO.top(); SO.pop();res = caculate(num1, num2, op);SN.push(res);                     // 将新计算出来的值压入栈中}return SN.top();
}

后缀表达式

链栈定义及实现

/** Filename: LinkedStack.h* -----------------------* 使用单链表来实现链栈*/#ifndef _SINGLE_LINKED_LIST_h_
#define _SINGLE_LINKED_LIST_h_#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;/********** 链栈的结点的类型定义 **********/
typedef int ElemType;
// typedef char ElemType;
typedef struct LNode{ElemType data;              // 数据域struct LNode *next;         // 指针域
} LNode, *LinkedStack;/********** 主要操作的实现 **********/
/** Function: 初始化操作* ----------------------------* 初始化一个空栈*/
void InitStack(LinkedStack &S){S = new LNode;S->next = NULL;
}/** Function: 判空操作* ----------------------------* 判断栈S是否为空，若为空则返回true，否则返回false。*/
bool StackEmpty(LinkedStack S){return !S->next;
}/** Function: 读取栈顶元素操作* ----------------------------* 返回栈顶元素。*/
ElemType GetTop(LinkedStack S){return S->next->data;
}/** Function: 入栈操作* ----------------------------* 使用头插法将e插入，使之成为新栈顶。*/
void Push(LinkedStack &S, ElemType e){LNode *n = new LNode;n->data = e;n->next = S->next;S->next = n;
}/** Function: 出栈操作* ----------------------------* 弹出栈顶元素并返回。*/
ElemType Pop(LinkedStack &S){LinkedStack q;ElemType e;q = S->next;e = q->data;S->next = q->next;delete q;return e;
}/** Function: 输出操作* ----------------------------* 由于单链表的特性，更方便按从栈尾到栈头的顺序输出。* 后续可以用递归法来正向输出。*/
void Print(LinkedStack S){LinkedStack tmp=S;while (tmp->next!=NULL){tmp = tmp->next;// printf("%d <- ", tmp->data);printf("%d ", tmp->data);}// printf("base\n");printf("\n");
}#endif // _SINGLE_LINKED_LIST_h_

后缀表达式转换及运算的实现

/** Filename: ReversePolish.cpp* -----------------------* 用栈实现中缀表达式向后缀表达式转换* 以及计算后缀表达式的程序。*/#include <iostream>
#include <string>
#include "../LinkedStack/LinkedStack.h"
using namespace std;/* Global variable */
LinkedStack SN;     // 数字栈
LinkedStack SO;     // 符号栈
string op = "(+-*/)";   // 用来匹配符号，符号的位序越小代表其优先级越低/* Prototype */
bool isNumber(char c);
int readStr(string str, int &i);
void print();
void conversion(string str);
int caculate(int num1, int num2, int op);
int calculateReverse();/* Main program */
int main(){InitStack(SN);InitStack(SO);int res=0;string str = "1+2/2*(8-4)"; // "(3+4)*5-6"printf("Reverse polish is: ");conversion(str);res = calculateReverse();printf("The result is: %d\n", res);return 0;
}/** Function: 判断数字函数* Usage: bool b = isNumber(c);* ----------------------------* 判断输入的字符是否属于数字,* 如是则返回true；否则返回false。*/
bool isNumber(char c){return (48<=c && c<=57);
}/** Function: 读取函数* Usage: int read = readStr(str, i);* ---------------------------------* 用来读取表达式位置i之后的数字或符号。* 如果读取的是数字，则直接返回数字。* 如果读取的是符号，将(,+,-,*,/,)分别以* 整数-6,-5,-4,-3,-2,-1返回。*/
int readStr(string str, int &i){string num; // 用来读取数字int n = 0;  // 用来记录多位数在字符串中的下标if (isNumber(str[i])){          // 如果读取到的是数字while (i+n<str.length() && isNumber(str[i+n])){num[n] = str[i+n];              // 将读取到的连续数字存入num中n++;}i = i+n;                            // 更新i的值return stoi(num);}                             return op.find(str[i++])-6;             // 如果读取到的是操作符,则直接转换为数字返回
}void print(){LinkedStack tmp=SO;while (tmp->next!=NULL){tmp = tmp->next;if (tmp->data>=0){printf("%d ", tmp->data);} else {switch(tmp->data){case -5:printf("+ ");break;case -4:printf("- ");break;case -3:printf("* ");break;case -2:printf("/ ");break;}} }printf("\n");
}/** Function: 转换函数* Usage: conversion(string str);* ------------------------------* 输入一个中缀表达式，将其转换为后缀表达式，* 存入SO中并输出后缀表达式。*/
void conversion(string str){int i=0;        // 用来遍历中缀表达式int read=0;     // 用来保存读取到的值int res=0;      // 遍历表达式while (i<str.length()){read = readStr(str, i);if (read>=0){               // 如果读取的是数字Push(SN, read);         // 将数字压入数字栈中    } else {                                        // 如果读取的是符号if (read==-6){                              // 1.如果是左括号，则直接压入符号栈Push(SO, read);}else if (read==-1){                         // 2.如果是右括号，则将栈顶符号弹出并while (GetTop(SO)!=-6){                 // 压入数字栈，直到遇见左括号                      Push(SN, Pop(SO));}Pop(SO);                                // 将左括号弹出       } else if (StackEmpty(SO) || GetTop(SO)<read){// 3.如果符号栈为空或待入栈符号的Push(SO, read);                         // 优先级更高，直接压入符号栈}else {                                      // 4.如果符号栈非空且栈顶元素优先级更高，while (!StackEmpty(SO) && read< GetTop(SO)){  // 则将栈顶符号弹出并压入数字栈，Push(SN, Pop(SO));                  // 直到栈顶元素优先级低于待入栈符号                           }Push(SO, read);                         // 将待入栈符号压入符号栈}                                            }}// 将符号栈清空while (!StackEmpty(SO)){Push(SN, Pop(SO));}// 将数字栈中的元素倒序，存入符号栈中while (!StackEmpty(SN)){Push(SO, Pop(SN));}// 输出print();
}/** Function: 计算函数* Usage: int res = caculate(num1, num2, op);* ------------------------------------------* 用来计算运算结果并返回。*/
int caculate(int num1, int num2, int op){int res;switch(op){case -5:                        // 加法res = num1+num2;break;case -4:                        // 减法res = num1-num2;break;case -3:                        // 乘法res = num1*num2;break;case -2:                        // 除法res = num1/num2;break;}return res;
}/** Function: 计算后缀表达式函数* Usage: int res = calculateReverse(LinkedStack S);* -------------------------------------------------* 后缀表达式保存在栈S中，输入栈S，返回该表达式的值。*/
int calculateReverse(){int num1, num2, res=0;// 遍历后缀表达式while (!StackEmpty(SO)){if (GetTop(SO)>=0){Push(SN, Pop(SO));} else {num2 = Pop(SN);num1 = Pop(SN);res = caculate(num1, num2, Pop(SO));Push(SN, res);}}   return GetTop(SN);
}

八、【栈和队列】栈的应用相关推荐

数据结构与算法（C语言） | 栈和队列——栈(自己做过测试)
栈是一种重要的线性结构,通常称,栈和队列是限定插入和删除只能在表的"端点"进行的线性表.(后进先出) –栈的元素必须"后进先出". –栈的操作只能在这个线性表的 ...
实现if_数组实现固定栈和队列+栈与队列相互实现
文章目录一.数组实现固定栈和队列 1.数组实现固定栈 2.数组实现固定队列二.栈与队列相互实现 1.两个队列实现栈 2.两个栈实现队列一.数组实现固定栈和队列 1.数组实现固定栈代码如下: c ...
从无到有算法养成篇-栈和队列·栈
一.栈结构示意图二.栈的常规操作 1.定义一个栈结构 /* 顺序栈结构 */ typedef struct {SElemType data[MAXSIZE];int top; /* 用于栈顶指针 * ...
第三章：3.栈和队列 -- 栈与递归的实现
前言: 栈还有一个总要应用是在程序设计语言中实现递归.一个直接调用自己或通过一系列的调用语句间接地调用自己的函数,称作递归函数. 目录: 1.栈 2.栈的应用举例 3.栈与递归的实现 4.队列 5.离 ...
数据结构（八） -- C语言版 -- 栈和队列 - 队列的设计与实现
我让你知道我有啥零.读前说明一.队列的概述二.队列的操作三.队列的两种存储结构的模型概述四.顺序存储结构的队列及实现 4.1.顺序存储结构的传统队列简易实现与测试 4.2.顺序存储结构的队列 ...
前端编程应该了解的数据结构——栈、队列
数据结构数据结构并没有官方的定义,在民间有各种定义: 1.数据结构是数据对象,以及存在于该对象的实例和组成实例的数据元素之间的各种联系: 2.数据结构是计算机中存储.组织数据的方式,通常情况下,精心 ...
简单数据结构(队列栈树堆 )
基础知识基本概念程序 = 算法 + 数据结构数据结构是计算机存储.组织数据的方式.数据结构是指相互之间存在一种或多种特定关系的数据元素的集合.通常情况下,精心选择的数据结构可以带来更高的运行或者存 ...
android栈和队列
android栈和队列栈和队列是两种特殊的线性表,它们的逻辑结构和线性表相同,只是其运算规则较线性表有更多的限制,故又称它们为运算受限的线性表.LinkedList数据结构是一种双向的链式结构,每一 ...
数组模拟栈和队列板子
使用数组模拟数据结构栈和队列栈:后进先出对于栈:我们使用tt表示栈顶的下标,如果tt==0表示栈空队列:先进先出对于队列,我们使用hh表示队首,tt表示队尾,tt初始化为-1,判断队列是否为空 ...
左神算法课笔记（二）：链表、栈和队列、递归Master公式、哈希表、有序表
单向链表双向链表单链表.双链表最简单的面试题 1.单链表和双链表如何反转 package class02;import java.util.ArrayList;public class Code0 ...

八、【栈和队列】栈的应用