基于顺序栈实现的四则算术表达式计算

合集下载

C++实例（表达式求值（栈的应用））

表达式求值：设计⼀个程序实现输⼊⼀个表达式如3*(3+4)，以”#”结尾，求出其值。

分析：先分析⼀下四则运算的规则： 1. 先乘除后加减； 2. 从左到右计算； 3. 先括号内后括号外；于是我们要把运算符的优先级确定清楚。

这⾥我只⽤这⼏个运算符：+-*/()，可以知道+-的优先级低于*/，⽽对于()，当第⼀次遇到’(‘时，’(‘后⾯的就优先计算，直到遇到’)’为⽌，可以先把’(’的优先级定为⽐其它⼏个都⾼，然后遇到’)’时把⾥⾯的先算出来，再算括号外⾯的，具体实现在代码中会表现得很清楚。

考试2⼤提⽰这个程序还是⽤栈来实现，具体代码如下。

代码： #include #include using namespace std; const int STACK_INIT_SIZE=100; //The maximize length of stack template class Stack //A class of stack { public: Stack() //Constructor function { base = new int[STACK_INIT_SIZE]; if (!base) { cerr< exit(-1); } top=base; stacksize=STACK_INIT_SIZE; } ~Stack() //Destructor function { if (base) delete[] base; } T GetTop() { if (top==base) { cerr< exit(-1); } return *(top-1); } void Push(T e) { if (top-base>=stacksize) { base=new int[STACK_INIT_SIZE]; if(!base) { cerr< exit(-1); } top=base+STACK_INIT_SIZE; stacksize+=STACK_INIT_SIZE; } *top++=e; } void Pop(T& e) { if (top==base) { cerr< exit(-1); } e=*--top; } private: int *base; int *top; int stacksize; }; string op("+-*/()#"); //The set of operator bool In(char c,string op) //Judge the character whether belong to the set of operator { string::iterator iter=op.begin(); for (;iter!=op.end();++iter) if (*iter==c) return true; return false; } char Precede(char top,char c) //Confirm the precedence of operator { int grade_top=0,grade_c=0; switch (top) { case '#':grade_top=0;break; case ')':grade_top=1;break; case '+':grade_top=2;break; case '-':grade_top=2;break; case '*':grade_top=3;break; case '/':grade_top=3;break; case '(':grade_top=4;break; } switch (c) { case '#':grade_c=0;break; case ')':grade_c=1;break; case '+':grade_c=2;break; case '-':grade_c=2;break; case '*':grade_c=3;break; case '/':grade_c=3;break; case '(':grade_c=4;break; } if (grade_top>=grade_c) { if (top=='('&&c!=')') return ' else if (top=='('&&c==')') return '='; return '>'; } else if (top=='#'&&c=='#') return '='; else return ' } int Operate(int a,char theta,int b) //Calculate { if (theta=='+') return a+b; else if (theta=='-') return a-b; else if (theta=='*') return a*b; else if (theta=='/') return a/b; return 0; } int EvaluateExpression(Stack& OPTR,Stack& OPND) { int a=0,b=0,n=0; char x; char theta; string c; cin>>c; OPTR.Push('#'); while (c[0]!='#'||OPTR.GetTop()!='#') { if (!In(c[0],op)){ n=atoi(&c[0]); OPND.Push(n); cin>>c; } else switch (Precede(OPTR.GetTop(),c[0])) { case ' OPTR.Push(c[0]); cin>>c; break; case '=': OPTR.Pop(x); cin>>c; break; case '>': OPTR.Pop(theta); OPND.Pop(b); OPND.Pop(a); OPND.Push(Operate(a,theta,b)); break; } } return OPND.GetTop(); } int main() { Stack OPTR; Stack OPND; cout< cout< return 0; }。

利用栈来实现算术表达式求值的算法

利用栈来实现算术表达式求值的算法利用栈来实现算术表达式求值的算法算术表达式是指按照一定规则组成的运算式，包含数字、运算符和括号。

在计算机中，求解算术表达式是一项基本的数学运算任务。

根据算术表达式的性质，我们可以考虑利用栈这一数据结构来实现求值算法。

一、算法思路首先，我们需要明确一个重要概念——逆波兰表达式（ReversePolish notation）。

逆波兰表达式是一种没有括号的算术表达式，其运算规则是先计算后面的数字和运算符，再计算前面的数字和运算符。

例如，对于算术表达式“3+4*5-6”，其对应的逆波兰表达式为“3 45 * +6 -”。

那么，我们可以利用栈来实现将中缀表达式转化为逆波兰表达式的过程，具体步骤如下：1. 创建两个栈——操作数栈和操作符栈。

2. 从左到右扫描中缀表达式的每一个数字和运算符，遇到数字则压入操作数栈中，遇到运算符则进行如下操作：（1）如果操作符栈为空或当前运算符的优先级大于栈顶运算符的优先级，则将当前运算符压入操作符栈中。

（2）如果当前运算符的优先级小于或等于栈顶运算符的优先级，则将栈顶运算符弹出并加入操作数栈中，重复此过程直到遇到优先级较低的运算符或操作符栈为空为止，然后将当前运算符压入操作符栈中。

3. 扫描完中缀表达式后，若操作符栈不为空，则将其中所有运算符弹出并加入操作数栈中。

4. 最终，操作数栈中存放的就是逆波兰表达式，我们可以按照逆波兰表达式的计算规则来计算其结果。

二、算法优点利用栈来实现算术表达式求值的算法具有以下优点：1. 代码简洁易懂，易于实现和维护。

2. 由于将中缀表达式转化为逆波兰表达式后，可以减少运算符的优先级关系而消除括号，从而减少求值的复杂度，提高程序的执行效率。

三、代码实现下面是利用栈来实现算术表达式求值的算法的Python代码实现：```pythonclass Stack:def __init__(self):self.items = []def push(self, item):self.items.append(item)def pop(self):return self.items.pop()def peek(self):return self.items[-1]def is_empty(self):return len(self.items) == 0def size(self):return len(self.items)def calculate(op_num1, op_num2, operator):if operator == "+":return op_num1 + op_num2elif operator == "-":return op_num1 - op_num2elif operator == "*":return op_num1 * op_num2elif operator == "/":return op_num1 / op_num2def infix_to_postfix(infix_expr):opstack = Stack()postfix_expr = []prec = {"+": 1, "-": 1, "*": 2, "/": 2, "(": 0} token_list = infix_expr.split()for token in token_list:if token.isdigit():postfix_expr.append(token)elif token == '(':opstack.push(token)elif token == ')':top_token = opstack.pop()while top_token != '(':postfix_expr.append(top_token)top_token = opstack.pop()else:while (not opstack.is_empty()) and(prec[opstack.peek()] >= prec[token]):postfix_expr.append(opstack.pop())opstack.push(token)while not opstack.is_empty():postfix_expr.append(opstack.pop())return " ".join(postfix_expr)def postfix_eval(postfix_expr):opstack = Stack()token_list = postfix_expr.split()for token in token_list:if token.isdigit():opstack.push(int(token))else:op_num2 = opstack.pop()op_num1 = opstack.pop()result = calculate(op_num1, op_num2, token) opstack.push(result)return opstack.pop()infix_expr = "3 + 4 * 5 - 6"postfix_expr = infix_to_postfix(infix_expr)print(postfix_expr)print(postfix_eval(postfix_expr))```四、总结算术表达式求值是一项常见的数学运算任务，利用栈这一数据结构来实现求值算法是一种简单有效的方法，它将中缀表达式转化为逆波兰表达式后，可以消除括号并减少运算符的优先级关系，从而提高程序的执行效率。

用堆栈实现四则运算c语言

用堆栈实现四则运算c语言堆栈是一种常见的数据结构，它符合先进后出的原则。

在四则运算中，我们可以借助堆栈这种数据结构实现运算，方便高效，不易出错。

堆栈的实现包括两个基本操作：Push（入栈）和Pop（出栈）。

我们可以以此设计四则运算。

首先，我们需要将输入的四则运算表达式转换成后缀表达式。

后缀表达式也叫逆波兰表达式，相对于中缀表达式而言，运算符在后面，操作数在前面，这样方便计算机进行读取和计算。

例如：中缀表达式：5+3*2后缀表达式：5 3 2 * +将中缀表达式转换成后缀表达式，我们需要用到堆栈。

具体的实现方法是，从左向右遍历表达式，如果是数字，则直接输出；如果是符号，则将其与堆栈顶的符号进行比较，如果优先级高就入栈，否则不断将符号出栈并输出，直到当前符号优先级大于堆栈顶符号优先级，最后将当前符号入栈。

例如：表达式：5+3*2堆栈操作：1.将5输出，堆栈为空2.遇到+号，入栈3.将3输出，堆栈顶为+号4.遇到*号，入栈5.将2输出，堆栈顶为*号6.输出*号，堆栈顶为+号7.输出+号，堆栈为空得到后缀表达式：5 3 2 * +有了后缀表达式，我们可以用堆栈进行计算。

具体方法是，从左向右遍历后缀表达式，如果是数字则入栈，如果是符号则将栈顶两个数字出栈并进行计算，将结果入栈，最终得到最终的计算结果。

例如：后缀表达式：5 3 2 * +堆栈操作：1.将5入栈2.将3入栈3.遇到*号，出栈3和2，进行计算得到6，将6入栈4.将栈顶元素5出栈5.遇到+号，出栈6和5，进行计算得到11，将11入栈得到计算结果：11通过堆栈实现四则运算，可以有效简化我们的计算流程，避免复杂的优先级判断和计算错误。

同时，堆栈为我们提供了一种更加高效的数据结构，不仅在四则运算中可以发挥作用，在其他应用中也很常见。

当然，在实际应用中，我们需要考虑到多种情况的处理，例如负数、小数、括号等，以及错误处理等细节问题，才能保证算法的正确性和可靠性。

双栈四则运算

双栈四则运算
双栈四则运算系统是一个基于栈结构的计算器系统，用于处理四则运算。

这个系统包含两个栈：操作数栈和运算符栈。

操作数栈用于存储待计算的数字，运算符栈用于存储待执行的运算符号。

在双栈四则运算系统中，用户可以输入一串数字和运算符，系统会将数字压入操作数栈，将运算符压入运算符栈。

当用户按下等号时，系统会从操作数栈中弹出两个数字，从运算符栈中弹出运算符号，然后进行相应的运算，并将结果压入操作数栈。

双栈四则运算系统的核心算法包括以下步骤：
初始化两个空栈：操作数栈和运算符栈。

循环执行以下步骤，直到用户按下等号或退出程序：
读取用户输入的数字，并将其压入操作数栈。

读取用户输入的运算符，并将其压入运算符栈。

如果用户按下等号，则执行以下步骤：
弹出运算符栈中的运算符。

弹出操作数栈中的两个数字。

进行相应的运算，并将结果压入操作数栈。

如果用户没有按下等号，则继续等待用户输入。

程序结束。

需要注意的是，为了避免精度误差和溢出问题，双栈四则运算系统需要进行相应的处理。

例如，可以使用高精度算法来处理大数运算，或者使用浮点数运算来处理小数运算。

四则运算解析及计算

四则运算解析及计算四则运算是中缀表达式，需要将其转化为后缀表达式。

原因是计算中缀表达式很困难。

明确运算符的优先级：优先级（数字越⼤，优先级越⾼）运算符2+-1*/0()格式化四则表达式输⼊的表达式可能出现⽆⽤的字符，需要去除否则影响下⾯的判断逻辑。

处理⽅法为，遍历整个字符串，删除换⾏、空格和制表符。

后缀表达式转化中缀表达式转化为后缀表达式的基本步骤如下：1.初始化⼀个运算符栈。

2.从输⼊的表达式的字符串中依次从左向右每次读取⼀个字符。

3.如果当前读取的字符是操作数，则直接填写到后缀表达式中（如果后缀表达式末尾已经有操作数，需要使⽤逗号分隔开）。

4.如果当前字符是“（”左括号，将其压⼊运算符栈。

5.如果当前字符为运算符，则分三种情况：（1）当前运算符栈为空，将其压⼊运算符栈。

（2）当前运算符的优先级⼤于栈顶元素，则将此运算符压⼊运算符栈；否则，弹出栈顶的运算符到后缀表达式，反复弹出，直到该运算符优先级⼤于栈顶元素或者栈为空时，然后将当前运算符压栈。

回到步骤2继续读取。

（3）如果上⼀次读到的也是运算符，则中缀表达式错误直接返回6.如果当前字符是“）”右括号，反复将栈顶元素弹出到后缀表达式，直到栈顶元素是左括号“（”为⽌，并将左括号从栈中弹出丢弃。

如果找不到“（”则中缀表达式错误直接返回7.如果读取还未完成，回到步骤2.8.如果读取完成，则将栈中剩余的运算符依次弹出到后缀表达式。

※如果表达式中出现负数或者⼩数，需对负数和⼩数点采取特殊处理：（1）如果是负数，需要把“-”⼀起存放到后缀表达式中同时还要添加⼀个特殊字符“！”⽤于标记负数。

两种情况下出现“-”可判定为负数。

A.“-”为⾸字符且下⼀个字符为数字；B.“-”为⾮⾸字符且位于“（”之后且后⼀个字符为数字;（2）如果有⼩数，需要记录⼩数点的位数举例：输⼊的四则表达式是 -15. *((-5+.6)*87-(-4.592+3.33)*8)处理后的后缀表达式为：!-15.,!-5,.6,+87,*!-4.592,3.33,+8,*-*后缀表达式求值：从左到右读取1、设置⼀个栈，开始时，栈为空；2、然后从左到右读取后缀表达式，若遇操作数，则进栈；3、若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕；4、最后，栈中仅有⼀个元素，即为运算的结果。

C语言简单计算器实现四则运算可带括号

C语言简单计算器实现四则运算可带括号```c#include <stdio.h>#include <stdlib.h>int priority(char op)if (op == '+' ， op == '-')return 1;else if (op == '*' ， op == '/')return 2;else if (op == '(')return 0;elsereturn -1;void calculate(char op, int *numStack, int *top, char *opStack, int *opTop)int num2 = numStack[(*top)--];int num1 = numStack[(*top)--];switch (op)case '+':numStack[++(*top)] = num1 + num2; break;case '-':numStack[++(*top)] = num1 - num2; break;case '*':numStack[++(*top)] = num1 * num2; break;case '/':numStack[++(*top)] = num1 / num2; break;}int eval(char *expr)int numStack[100];char opStack[100];int numTop = -1;int opTop = -1;int num = 0;int sign = 1;while (*expr != '\0')if (*expr >= '0' && *expr <= '9')num = num * 10 + (*expr - '0');} else if (*expr == '+' ， *expr == '-')numStack[++numTop] = num * sign;num = 0;sign = (*expr == '+') ? 1 : -1;} else if (*expr == '*' ， *expr == '/')while (opTop >= 0 && priority(*expr) <=priority(opStack[opTop]))calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}opStack[++opTop] = *expr;} else if (*expr == '(')opStack[++opTop] = '(';} else if (*expr == ')')while (opStack[opTop] != '(')calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}opTop--;}expr++;}numStack[++numTop] = num * sign;while (opTop >= 0)calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}return numStack[0];int maichar expr[100];printf("请输入表达式：");scanf("%s", expr);int result = eval(expr);printf("计算结果：%d\n", result);return 0;```以上是一个简单的C语言四则运算计算器的实现。

运用栈方法的四则运算法

}
int Empty_SeqStack(PSeqStack S)
{
if(S->top1==-1)
return 1;
else
return 0;
}
int Pop_SeqStack(PSeqStack S,char *x)
{/*出栈*/
if(Empty_SeqStack(S))
s->top=-1;
k->top1=-1;
push1(k,'#');
while(a[i]!='='||(ch=get_top(k))!='#')
{
if(Isnum(a[i])) /*当前字符为数字*/
{
x=0;Int_part=0;float_part=0;
{
case '+':c=d+b;break;
case '-':c=d-b;break;
case '*':c=d*b;break;
S->top2++;
S->data[S->top2]=x;
return 1;
}
}
char GetTop_SeqStack(PSeqStack S,float *x)
{
if(Empty_SeqStack(S))
return 0;
else
*x=S->data[S->top2];
ch=pop1(k); /*从数据栈压出两个数,并从字符栈压出一个运算符进行计算*/
b=pop(s);

Java实现四则运算表达式

四则混合运算的算符优先算法Java实现它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。

它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。

举例：(3 + 4) × 5 - 6 就是中缀表达式- × + 3 4 5 6 前缀表达式3 4 + 5 × 6 - 后缀表达式中缀表达式（中缀记法）中缀表达式是一种通用的算术或逻辑公式表示方法，操作符以中缀形式处于操作数的中间。

中缀表达式是人们常用的算术表示方法。

虽然人的大脑很容易理解与分析中缀表达式，但对计算机来说中缀表达式却是很复杂的，因此计算表达式的值时，通常需要先将中缀表达式转换为前缀或后缀表达式，然后再进行求值。

对计算机来说，计算前缀或后缀表达式的值非常简单。

前缀表达式（前缀记法、波兰式）前缀表达式的运算符位于操作数之前。

前缀表达式的计算机求值：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素op 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

例如前缀表达式“- × + 3 4 5 6”：(1) 从右至左扫描，将6、5、4、3压入堆栈；(2) 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较），计算出3+4的值，得7，再将7入栈；(3) 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈；(4) 最后是-运算符，计算出35-6的值，即29，由此得出最终结果。

可以看出，用计算机计算前缀表达式的值是很容易的。

将中缀表达式转换为前缀表达式：遵循以下步骤：(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；(2) 从右至左扫描中缀表达式；(3) 遇到操作数时，将其压入S2；(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：(4-1) 如果S1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈；(4-2) 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1；(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；(5) 遇到括号时：(5-1) 如果是右括号“)”，则直接压入S1；(5-2) 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃；(6) 重复步骤(2)至(5)，直到表达式的最左边；(7) 将S1中剩余的运算符依次弹出并压入S2；(8) 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

1
概要详细
程序组织结构
排错程序
排错程序
1、遍历数组 2、括号匹配 3、条件判断“/” 4、条件判断“%”
1、记录出错索引 2、打印“^”标示
中序表达式转后缀表达式程序
1、操作数排入数组 2、操作符标识优先级入栈 3、操作符根据优先级出栈排入数组
后缀表达式计算程序
1、操作数入栈 2、条件判断操作符 3、操作数出栈计算 4、计算结果入栈 5、判断栈长度为1出栈
2
概要详细
平台选择
用户普及度高，操作熟悉，易移植
简单直接，一直在学在用
功能熟悉，操作简便
3
目录
需求分析
Demand Analysis
概要详细
Outline&Detail
算法设计
Algorithm Design
编码测试
Encoding&Test
算法设计 1 2 3
算法统计
算式排错算法
中序转后缀表达式算法
基于顺序栈实现的四术算数表达式计算
指导老师：杜晓凤汇报人：黄成旺
目录
需求分析
Demand Analysis
概要详细
Outline&Detail
算法设计
Algorithm Design
编码测试
Encoding&Test
目录
需求分析
Demand Analysis
概要详细
Outline&Detail
^
^
3
算法设计
中序表达式转后后缀表达式算法
puts(a);
3
+
(
3
+
2
*
3
)
\0
char ch[100]；
3 op
3 level
2
3
*
+
+
\0
stack st; * + ( + 2 1 -1
1
4
算法设计
算式排错算法
char ch[100]；
3
3
2
3
*
+
+
\0
stack numstack 9 + 3
3 6 2 3 9 12 3 3 6
12
6 9
+ *
32
5
目录
需求分析
Demand Analysis
概要详细
Outline&Detail
算法设计
Algorithm Design
编码测试
Encoding&Test
编码测试
容错测试：
1
编码测试
计算测试：
2
后话
1
后话
2
3
1、一个人做很累
2、一个人做很累
编码测试
Encoding&Test
概要详细
排错理
判断是否缺少括号，操作数是否符合标准
基本处理流程
输入一则四则运算，可带括号，可以是浮点数
算式处理排错处理
错误提示算式输入
错误提示
发现错误用“^”标出位置
调用函数，计算结果
正确计算
算式分析
算式修改
正确计算
算式修改
根据提示重新输入算式
后缀表达式计算算法
1
算法设计
算式排错算法
puts(a); stack che；
3 (（
+
(
3
+
2
）
+
3
\0
puts(b); char c[100]={‘ ’}; c[i]='^';
3
+
（
3
+
2
+
3
\0
^
2
算法设计
算式排错算法
puts(a); stack che；
3 (
+
(
3
/
0
）
%
3.1
\0
c[i]='^';
3、一个人做很累
3
谢谢聆听！
Thanks for listening！
指导老师：杜晓凤
汇报人：黄成旺
算法设计
Algorithm Design
编码测试
Encoding&Test
需求分析
功能需求
（
%整数
+&-
*&/
浮点运算
%
四则运算
算数排错
缺少括号
除数为0？
缺少运算符
1
目录
需求分析
Demand Analysis
概要详细
Outline&Detail
算法设计
Algorithm Design