用栈做一个简单的计算器（表达式的计算）

最新推荐文章于 2024-06-06 14:29:15 发布
最新推荐文章于 2024-06-06 14:29:15 发布
阅读量1k 收藏 9
点赞数 10
CC 4.0 BY-SA版权
文章标签： 栈 c语言 表达式计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44049351/article/details/89343029
本文介绍了一种使用栈数据结构解决复杂表达式计算问题的方法，包括操作数栈和运算符栈的设计，以及如何处理整数、小数和运算符的优先级比较。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

用栈解决表达式的计算问题
1.首先要有两个栈一个操作数栈一个运算符栈；
2.设置表达式的结束符是#，预设运算符
3.若当前字符是操作数，则直接压入操作数栈
4.若当前字符是运算符，且运算符的优先级高于栈顶运算符则进栈，否则从操作数栈中弹出两个操作数并弹出运算符栈的栈顶运算符，经计算后，将结果压入操作数栈。

//操作数栈
typedef struct{
float an[20];
int topn;
}OPRD;

//运算符栈
typedef struct{
char ac[20];
int topc;
}OPTR;

在做的过程中有以下几个问题吧：
问题一：如何把输入的字符转化为浮点型

 wb = wb + ((float)love[i-n]-48) * (power(10,n-1));

用到了一个类型转化符，里面的power()函数是一个求指数的函数;具体代码如下：

//求指数
int power(int a , int b)
{
        int i=0;
        int wb=1;
        for(;i<b;i++)
                wb *= a;
        return wb;
}

问题二：如果输入的是‘2’‘1’，怎么让他读入21；

n=0
if(love[i]>='0' && love[i]<='9')
                {
                        while(love[i]>='0' && love[i]<='9')
                        {
                                n++;
                                i++;
                        }
                        while(n!=0)
                        {
                                wb = wb + ((float)love[i-n]-48) * (power(10,n-1));
                                n--;
                        }
                }

问题三：如果是小数怎么办

 if(love[i] == '.')
                        {
                                i++;
                                while(love[i]>='0' && love[i]<='9')
                                {
                                        n++;
                                        i++;
                                }
                                while(n!=0)
                                {
                                        wb = wb + ((float)love[i-n]-48) / (power(10,n));
                                        n--;
                                }
                        }

问题四：运算符的比较
就是用switch函数对两个运算符进行比较通过返回值判断大小具体函数在下面；

下面放完整代码

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

//操作数栈
typedef struct{
float an[20];
int topn;
}OPRD;

//运算符栈
typedef struct{
char ac[20];
int topc;
}OPTR;

//字符串输入函数
char *s_gets(char  *a , int n)
{
        char *b;
        int i=0;
        b= fgets(a,n,stdin);
        if(b)
        {
                while(a[i]!='\n' && a[i]!='\0')
                        i++;
                if(a[i]=='\n')
                        a[i]='\0';
                else
                        while(getchar()!='\n')
                                continue;
        }
        return b;
}

//求指数
int power(int a , int b)
{
        int i=0;
        int wb=1;
        for(;i<b;i++)
                wb *= a;
        return wb;
}

//操作数入栈函数
int push_n(OPRD *s , float x)
{
        if(s->topn == 19)
                return 0;
        else
                s->an[++s->topn] = x;
        return 1;
}

//运算符的比较
int bijiao(char a , char b)
{
        switch(a)
        {
                case '+':
                        {
                                switch(b)
                                {
                                        case '+':return 0;
                                        case '-':return 0;
                                        case '*':return 1;
                                        case '/':return 1;
                                        case '(':return 1;
                                        case ')':return 0;
                                        case '#':return 0;
                                        default:break;
                                }
                        }
                case '-':
                        {
                                switch(b)
                                {
                                        case '+':return 0;
                                        case '-':return 0;
                                        case '*':return 1;
                                        case '/':return 1;
                                        case '(':return 1;
                                        case ')':return 0;
                                        case '#':return 0;
                                        default:break;
                                }
                        }
                case '*':
                        {
                                switch(b)
                                {
                                        case '+':return 0;
                                        case '-':return 0;
                                        case '*':return 0;
                                        case '/':return 0;
                                        case '(':return 1;
                                        case ')':return 0;
                                        case '#':return 0;
                                        default:break;
                                }

                        }
                case '/':
                        {
                                switch(b)
                                {
                             case '+':return 0;
                                        case '-':return 0;
                                        case '*':return 0;
                                        case '/':return 0;
                                        case '(':return 1;
                                        case ')':return 0;
                                        case '#':return 0;
                                        default:break;
                                }

                        }
                case '(':
                        {
                                switch(b)
                                {
                                        case '+':return 1;
                                        case '-':return 1;
                                        case '*':return 1;
                                        case '/':return 1;
                                        case '(':return 1;
                                        default:break;
                                }

                        }
                case ')':
                        {
                                switch(b)
                                {
                                        case '+':return 0;
                                        case '-':return 0;
                                        case '*':return 0;
                                        case '/':return 0;
                                        case ')':return 0;
                                        case '(':return 2;
                                        case '#':return 0;
                                        default:break;
                                }

                        }
                case '#':
                        {
                                switch(b)
                                {
                                        case '+':return 1;
                                        case '-':return 1;
                                        case '*':return 1;
                                        case '/':return 1;
                                        case '(':return 1;
                                        case '#':return 2;
                                        default:break;
                                }

                        }
        }
}

//操作数出栈
int popn(OPRD *s , float *x)
{
        if(s->topn == -1)
                return 0;
        else
                *x = s->an[s->topn--];
        return 1;
}

//运算符出栈
int popc(OPTR *s , char *x)
{
        if(s->topc == -1)
                return 0;
        else
                *x = s->ac[s->topc--];
        return 1;
}

//判断运算符栈空
int kong_c(OPTR *s)
{
        if(s->topc == -1)
                return 0;
        else
                return 1;
}

int main()
{
        OPTR *s;
        OPRD *p;
        int k,i,n;
        i=0;
        n=0;
        float wb=0;
        char ch;
        char love[40];
        float a,b;
        s = (OPTR*)malloc(sizeof(OPTR));
        p = (OPRD*)malloc(sizeof(OPRD));
        s->topc = -1;
        printf("%d",s->topc);
        p->topn = -1;
        printf("输入以#开头以#结尾的表达式:\n");
        s_gets(love,40);
        k = strlen(love);
        for(;i<k;)
        {
                wb=0;
                if(love[i]>='0' && love[i]<='9')
 {
                        while(love[i]>='0' && love[i]<='9')
                        {
                                n++;
                                i++;
                        }
                        while(n!=0)
                        {
                                wb = wb + ((float)love[i-n]-48) * (power(10,n-1));
                                n--;
                        }
                        if(love[i] == '.')
                        {
                                i++;
                                while(love[i]>='0' && love[i]<='9')
                                {
                                        n++;
                                        i++;
                                }
                                while(n!=0)
                                {
                                        wb = wb + ((float)love[i-n]-48) / (power(10,n));
                                        n--;
                                }
                        }
                        push_n(p,wb);
                }
                else
                {
                        if(kong_c(s) == 0 || love[i]=='(')
                        {
                                push_c(s,love[i]);
                                i++;
                        }
                        else
                        {
                                getac(s,&ch);
                                while(bijiao(ch,love[i])!=1 && bijiao(ch,love[i])!=2)
                                {
                                        popc(s,&ch);
                                        popn(p,&a);
                                        popn(p,&b);
                                        switch(ch)
                                        {
                                                case '+':wb = b + a;break;
                                                case '-':wb = b - a;break;
                                                case '*':wb = b * a;break;
                                                case '/':wb = b / a;break;
                                                case ')':break;
                                                default:break;
                                        }
                                        push_n(p,wb);
                                        getac(s,&ch);
                                }
 if(bijiao(ch,love[i])==2)
                                {
                                        popc(s,&ch);
                                        i++;
                                }
                                else if(bijiao(ch,love[i])==1)
                                {
                                        push_c(s,love[i]);
                                        i++;
                                }
                        }
                }

        }
        popn(p,&wb);
        printf("结果是%.2f\n",wb);
}
使用栈实现简单计算器
Little Big Us的博客
10-24 1399
描述： 输入一串字符串，输出它的计算结果。//考虑输入不正确的情况 例如输入：722-5+1-5+3-4 输出18 代码如下： public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); Stack<Character> stack2 = new Stack<>();
数据结构——栈实现综合计算器（中缀表达式）
m0_75013084的博客
05-01 632
输入一个字符串类型的表达式，例如：7*2*2-5+1-5+3-3，计算出结果。
栈实现综合计算器（中缀表达式）
qq_43552242的博客
02-28 481
计算1+5*13等表达式 package com.hhit.stack; public class Calculator { public static void main(String[] args) { String expression = "70*2*2-5+1+1"; // 15//如何处理多位数的问题？ //创建两个栈，数栈，一个符号栈 ...
用栈实现简单的计算器
u014663439的博客
02-15 2909
我们知道在计算的时候，运算符的优先级是很关键的，如乘除法的优先级要高于加减法，而括号里面的优先级要高于括号外面的优先级。为了表示运算符的优先级，我们先定一个哈希表来表示运算符和其优先级 # value越大 优先级越高 symbolDict = {"+":0,"-":0,"*":1,"/":1,"^":2,"(":3,")":3} 如果我们要实现一个简单的计算器，我们就需要正确的处理运算符的优先
用栈实现的计算器
04-11
这是我写的，用一种类型栈：字符栈实现的计算器，包括括号判别。 缺点是不涉及小数和负数的运算，错误提示代码也没编写。主要是依照严蔚敏数据结构思想。供大家参考。 说明文档里有思路和问题解析，另外一个CPP文件里附有重要注释
用栈实现计算器
mlfc0422的博客
02-05 329
（3）‘（’在左边出现时，其优先级低于右边出现的算符，如‘+’、‘-’、‘*’等，‘（’=‘）’表示括号内运算结束；‘（’在右边出现时，其优先级高于左边出现的算符，如‘+’、‘-’、‘*’等。‘）’在右边出现时，其优先级低于左边出现的算符，如‘+’、‘-’、‘*’等。（5）‘）’与‘（’、‘#’与‘）’、‘（’与‘#’之间无优先关系，在表达式中不允许相继出现，如果出现认为是语法错误。（2）同级别的算符遇到时，左边算符的优先级高于右边算符的优先级，如‘+’与‘+’、‘-’与‘-’、‘+’与‘-’等。
java栈实现计算器中缀表达式
10-23
“计算中缀表达式”可以称得上是一个特别经典的关于栈的算法题，几乎在所有数据结构教材中都会涉及，而且很多公司面试或者笔试的时候都会把这道题作为一个考察点。可以说，这是一道必须要掌握的算法题。中缀表达式、...
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。...
Infix_to_Suffix.rar_suffix 和 infix_数学_表达式计算_表达式计算器_计算器 表达式
09-24
然后对后缀表达式进行计算，可以使用两个栈，一个用于存储操作数，另一个用于临时存放运算符。这样，我们可以构建一个高效且易于理解的表达式计算器。 总结来说，中缀表达式到后缀表达式的转换和后缀表达式的计算是...
C++实现一个简单的表达式计算器
02-13
这个计算机实现了： 1. 基本计算 (e * ** / % + -) * 括号的处理会让代码逻辑变得混乱得多，所以还没实现左右括号 * 仅支持二元操作符 * 支持小数 2. 优先级 3. 错误回显：可指出出错位置、原因 4. 中间...
利用stack实现简单的计算器
06-19
利用Stack开发一款简单的表达式求值软件；熟练掌握Stack的逻辑结构、存储结构、基本操作；灵活运用Stack的各种基本操作；熟练掌握如何编辑、编译、链接和运行一个C++程序;
C++ 栈实现简单计算器
03-14
c++ 利用数组做底层存储，实现入栈 出栈 栈空/满判断等基本操作，计算器实现加减乘除简单功能 ，支持中缀表达式
数据结构-Stack：使用栈来实现一个简易的算术表达式计算器
cowboygzchen的专栏
05-02 519
package org.cgz.practice; import java.util.Stack; import java.util.StringTokenizer; class Caculator { /** * 计算算术表达式的结果 * @param expression 表达式字符串 * @return */ public static...
使用栈实现一个简单的计算器
最新发布
jsjsbsb464548的博客
06-06 1234
else if (isdigit(expression[i]) || (expression[i] == '-' && (i == 0 || expression[i - 1] == '('))) { // 如果是数字或负号。ops.empty() && priority(ops.top()) >= priority(expression[i])) { // 当栈顶操作符优先级大于等于当前操作符时。else if (expression[i] == '(') { // 如果是左括号，将左括号压入操作符栈。
使用栈实现简单的计算器
qq_66387228的博客
09-06 841
使用栈完成计算一个表达式
用栈写一个表达式计算器
05-27
好的，下面是一个用栈实现的表达式计算器，它支持加、减、乘、除、括号等基本运算符和功能： ```c #include <stdio.h> #include <stdlib.h> #include <ctype.h> // 定义栈结构 struct stack { int *data; int top; int size; }; // 创建栈 struct stack *create_stack(int size) { struct stack *s = (struct stack*)malloc(sizeof(struct stack)); s->data = (int*)malloc(size * sizeof(int)); s->top = -1; s->size = size; return s; } // 销毁栈 void destroy_stack(struct stack *s) { if (s != NULL) { free(s->data); free(s); } } // 入栈 void push(struct stack *s, int val) { if (s->top < s->size - 1) { s->top++; s->data[s->top] = val; } } // 出栈 int pop(struct stack *s) { if (s->top >= 0) { int val = s->data[s->top]; s->top--; return val; } return 0; } // 获取栈顶元素 int top(struct stack *s) { if (s->top >= 0) { return s->data[s->top]; } return 0; } // 判断栈是否为空 int is_empty(struct stack *s) { return s->top < 0; } // 解析数字 int parse_number(char *expr, int *index) { int val = 0; while (isdigit(expr[*index])) { val = val * 10 + (expr[*index] - '0'); (*index)++; } return val; } // 计算表达式 int eval_expr(char *expr) { struct stack *nums = create_stack(100); struct stack *ops = create_stack(100); int index = 0; while (expr[index] != '\0') { if (isdigit(expr[index])) { int val = parse_number(expr, &index); push(nums, val); } else if (expr[index] == '(') { push(ops, '('); index++; } else if (expr[index] == '+' || expr[index] == '-') { while (!is_empty(ops) && top(ops) != '(') { int val2 = pop(nums); int val1 = pop(nums); int op = pop(ops); if (op == '+') { push(nums, val1 + val2); } else if (op == '-') { push(nums, val1 - val2); } } push(ops, expr[index]); index++; } else if (expr[index] == '*' || expr[index] == '/') { while (!is_empty(ops) && (top(ops) == '*' || top(ops) == '/')) { int val2 = pop(nums); int val1 = pop(nums); int op = pop(ops); if (op == '*') { push(nums, val1 * val2); } else if (op == '/') { push(nums, val1 / val2); } } push(ops, expr[index]); index++; } else if (expr[index] == ')') { while (!is_empty(ops) && top(ops) != '(') { int val2 = pop(nums); int val1 = pop(nums); int op = pop(ops); if (op == '+') { push(nums, val1 + val2); } else if (op == '-') { push(nums, val1 - val2); } else if (op == '*') { push(nums, val1 * val2); } else if (op == '/') { push(nums, val1 / val2); } } pop(ops); index++; } else { index++; } } while (!is_empty(ops)) { int val2 = pop(nums); int val1 = pop(nums); int op = pop(ops); if (op == '+') { push(nums, val1 + val2); } else if (op == '-') { push(nums, val1 - val2); } else if (op == '*') { push(nums, val1 * val2); } else if (op == '/') { push(nums, val1 / val2); } } int result = top(nums); destroy_stack(nums); destroy_stack(ops); return result; } // 主函数 int main() { char expr[100]; printf("请输入表达式："); scanf("%s", expr); int result = eval_expr(expr); printf("表达式的值为：%d\n", result); return 0; } ``` 您可以将以上代码保存为一个.c文件并编译运行，输入表达式后即可计算出表达式的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值