逆波兰计算器

最新推荐文章于 2022-12-18 14:14:09 发布
最新推荐文章于 2022-12-18 14:14:09 发布
阅读量341 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mooganic/article/details/97621977
版权

逆波兰计算器的C语言实现

这个函数完成的功能：输入一个中缀表达式（支持负数和小数），输出相应的计算结果
例如：输入(1+3)*4+5.2/2#， 输出结果18.600000
(#代表表达式结束)

主要使用栈来实现操作。第一步将输入的中缀表达式转换为后缀表达式，存储在字符数组中；第二部计算后缀表达式

下面是代码，不足之处还望大佬指出

修改之后可以支持负数和小数的计算

// code

//逆波兰计算器
//支持负数和小数计算

#include <stdio.h>
#include<stdlib.h>
#include<ctype.h>

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10
#define buffer_size 10 //缓存数字串的大小
#define STORESIZE 100  //存储后缀表达式的字符数组长度 如果过小需要手动扩容

typedef char ElemTypec;  //栈1元素为字符
typedef double ElemTyped;  //栈2元素为浮点数
typedef struct
{
    ElemTypec *base;
    ElemTypec *top;
    int stack_size;
}sqStack1; //栈1用来将中缀表达式转换为后缀表达式

typedef struct
{
    ElemTyped *base;
    ElemTyped *top;
    int stack_size;
}sqStack2;  //栈2用来计算后缀表达式


//初始化
void InitStack1(sqStack1 *s)
{
    s->base = (ElemTypec *)malloc(STACK_INIT_SIZE*sizeof(ElemTypec));
    if( !s->base)
    {
        exit(0);
        
    }
    
    s->top = s->base;
    s->stack_size = STACK_INIT_SIZE;
    
}

void InitStack2(sqStack2 *s)
{
    s->base = (ElemTyped *)malloc(STACK_INIT_SIZE*sizeof(ElemTyped));
    if( !s->base)
    {
        exit(0);
        
    }
    
    s->top = s->base;
    s->stack_size = STACK_INIT_SIZE;
    
}

//入栈
void Push1(sqStack1 *s, ElemTypec e)
{
    //自动扩容
    if(s->top - s->base >= s->stack_size)
    {
        s->base = (ElemTypec *)realloc(s->base, (s->stack_size + STACKINCREMENT)*sizeof(ElemTypec));
        if( !s->base)
        {
            exit(0);
                                          
        }
        s->top = s->base + s->stack_size;
        s->stack_size = s->stack_size + STACKINCREMENT;
        
                                      
    }
                                      
    *(s->top) = e;
    s->top++;
}
void Push2(sqStack2 *s, ElemTyped e)
{
    if(s->top - s->base >= s->stack_size)
    {
        s->base = (ElemTyped *)realloc(s->base, (s->stack_size + STACKINCREMENT)*sizeof(ElemTyped));
        if( !s->base)
        {
            exit(0);
            
        }
        s->top = s->base + s->stack_size;
        s->stack_size = s->stack_size + STACKINCREMENT;
        
        
    }
    
    *(s->top) = e;
    s->top++;
}

//出栈
void Pop1(sqStack1 *s, ElemTypec *e)
{
    if(s->top == s->base)
    {
        exit(0);
    }
    *e = *--(s->top);
    
}

void Pop2(sqStack2 *s, ElemTyped *e)
{
    if(s->top == s->base)
    {
        exit(0);
    }
    *e = *--(s->top);
    
}

//检查长度
long STACKLENGTH(sqStack1 s)
{
    return (s.top - s.base);
}

//存入后缀表达式的结果
void SaveChar(char *array, int *count, char c)
{
    array[*count] = c;
    (*count)++;
}

//获取后缀表达式用于计算
char GetChar(char *array, int *count)
{
    char c;
    c = array[*count];
    (*count)++;
    return c;
}
                                      




int main()
{
     //中缀表达式变为后缀表达式
    sqStack1 s;
    
    char c, e;
    int count = 0, flag = 0, minus_flag = 0;
    
    
    char string_store[STORESIZE];
    
    InitStack1(&s);
    
    printf("请输入中缀表达式，以#结束\n");
    printf("例如:(1+3)*4+5.2/2#\n");
    scanf("%c", &c);
    if(c == '-')  //第一个数为负数
    {
        SaveChar(string_store, &count, c);
        minus_flag = 1;
        
    }
    
    while(c != '#')
    {
        if(flag && c != '-')  //左括号下一个不是-号，把flag置0
        {
            flag = 0;
        }
        
        while((c >= '0' && c <= '9') || c == '.')
        {
            SaveChar(string_store, &count, c);
            scanf("%c", &c);
            if( !((c >= '0' && c <= '9') || c == '.'))
            {
                SaveChar(string_store, &count, ' ');
                break;
            }
            
        }
        

        
        if(c == ')')
        {
            Pop1(&s, &e);
            while(e != '(')
            {
                SaveChar(string_store, &count, e);
                SaveChar(string_store, &count, ' ');
                Pop1(&s, &e);
            }
        }
        
        else if(c == '+')
        {
            if(!STACKLENGTH(s))
            {
                Push1(&s, c);
            }
            else
            {
                do
                {
                    Pop1(&s, &e);
                    if(e == '(' )
                    {
                        Push1(&s ,e);
                    }
                    else
                    {
                        SaveChar(string_store, &count, e);
                        SaveChar(string_store, &count, ' ');
                        
                    }
                    
                }while(STACKLENGTH(s) && e != '(');
                Push1(&s, c);
                
            }
        }
        
        else if(c == '-')
        {
            if(minus_flag && flag == 0)
            {
                scanf("%c", &c);  //输入开头为负数,跳到下一次循环
                minus_flag = 0;
                continue;

                
            }
            
            if(!STACKLENGTH(s) && minus_flag == 0 && flag == 0) //栈为空且开头没有负号，说明是减号，把减号入栈
            {
                Push1(&s, c);
            }
            else
            {
                //如果前一个字符是(，那么下一个字符为-则必为负号
                if(flag)
                {
                    SaveChar(string_store, &count, '-');
                }
                
                
                do
                {
                    Pop1(&s, &e);
                    if(e == '(' )
                    {
                        Push1(&s ,e);
                    }
                    else
                    {
                        SaveChar(string_store, &count, e);
                        SaveChar(string_store, &count, ' ');
                        
                    }
                    
                }while(STACKLENGTH(s) && e != '(');
                if(flag == 0)
                {
                    Push1(&s, c);
                }
                else
                {
                    flag = 0;
                }
                
            }
        }
        
        
            

        else if('*' == c || '/' == c)
        {
            if(!STACKLENGTH(s))
            {
                Push1(&s, c);
            }
            else
            {
            
                Pop1(&s, &e);
                if(e == '+' || e == '-')
                {
                    Push1(&s, e);
                    Push1(&s, c);
                }
                else if(e == '*' || e == '/')
                {
                    SaveChar(string_store, &count, e);
                    SaveChar(string_store, &count, ' ');
                    Push1(&s, c);
                }
                else if(e == '(')
                {
                    Push1(&s, e);
                    Push1(&s, c);
                }
            }
        }
        
        else if(c == '(')
        {
            Push1(&s, c);
            flag = 1;
        }
            
        else if(c == '#')
        {
                break;
        }
        
        else
        {
            printf("输入有误\n");
        }
            
            scanf("%c", &c);
    };
    
    while(STACKLENGTH(s))
    {
        Pop1(&s, &e);
        SaveChar(string_store, &count, e);
        SaveChar(string_store, &count, ' ');
        
    }
    getchar();
    printf("\n");
    
    string_store[count] = '\0';
    printf("逆波兰表达式:%s\ncount:%d\n", string_store, count);
        
    
    //把后缀表达式计算出来
    sqStack2 s2;
    int i = 0;
    flag = 0;
    
    double sum1, sum2, temp;
    char buffer[buffer_size];
    char detect;
    
    InitStack2(&s2);
    count = 0;//count从头遍历

    c = GetChar(string_store, &count);
    while( c != '\0' )
    {
        //数字则入栈
        while(isdigit(c) || c == '.')
        {
            buffer[i++] = c;
            buffer[i] = '\0';
            if(i >= buffer_size-1)
            {
                printf("输入数据过大\n");
                return -1;
            }
            
            c = GetChar(string_store, &count);
            
            if( c == ' ')
            {
                temp = atof(buffer); //字符转换为数字
                if(flag)
                {
                    temp = -temp; //如果是负数
                    flag = 0;
                }
                Push2(&s2, temp);
                i = 0;
                
                break;
            }
        }
        
        
        //遇到操作符就运算
        switch ( c )
        {
                
            case ' ':
                break;
            case '+':
                Pop2(&s2, &sum1);
                Pop2(&s2, &sum2);
                Push2(&s2, sum1 + sum2);
                break;
                
            case '-':
                //读取到字符‘-’, 要检测是负号还是减号
                
                detect = GetChar(string_store, &count);
                if(detect == ' ') //下一个字符为空，则是减号 正常操作进行弹栈
                {
                    count--;
                    Pop2(&s2, &sum1);
                    Pop2(&s2, &sum2);
                    Push2(&s2, sum2 - sum1);
                }
                else if (isdigit(detect))  //下一个字符为数字，则是负号
                {
                    count--;
                    flag = 1;
                }
                
                break;
                
            case '*':
                Pop2(&s2, &sum1);
                Pop2(&s2, &sum2);
                Push2(&s2, sum1 * sum2);
                break;
                
            case '/':
                Pop2(&s2, &sum1);
                Pop2(&s2, &sum2);
                if(sum1 != .0)
                {
                    Push2(&s2, sum2 / sum1);
                }
                else
                {
                    printf("除数为0,错误");
                    return -1;
                }
                break;
                
            default:
                printf("非四则运算\n");
                return -1;
        }
        
        c = GetChar(string_store, &count);
        
    }
    Pop2(&s2, &sum1);
    printf("输出计算结果:%f\n", sum1);
    

        
    return 0;
        
}

下面是测试用例：
输入：3+2.5*2#
输出：8.000000 正确

输入：-3*2+5-2/8+(-2+5)*3+2#
输出：9.750000 正确

输入：-1.52.8+(-2.5-4)/23#
输出：-13.950000 正确

输入：-2.12*23+(-5.212+2.3)*3+((-2.1+3)*2+5)*1.1#
输出：-50.016 正确

输入：-2.12*23+(-5.212+2.3)*3+(-2.1+3)*2+5#
输出：-50.696000 正确

输入：-2.12245+(((23+1.1)+4.1)*2.4-(-1.1+3)/2)*2.1#
输出：-464.947000 正确

通过测试过程修正了代码，如果遇到了不正确的输出可以与我交流

无名高
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
表达式计算 逆波兰式 栈 可括号小数负数
12-25
栈作中介，将表达式转化成逆波兰式，然后计算表达式的值。支持括号。允许负数和小数。
逆波兰表达式
热门推荐
jxsfreedom的专栏
12-10 1万+
以前写过计算一个字符串的表达式，当时都不知道有逆波兰这东西，- -！真是孤陋寡闻了，不过勉强用其他方法写了出来，用到了递归，不过整体来说很罗索！逆波兰对这种字符串的表达式计算很容易，只要把一个普通的表达式转换成逆波兰后计算就轻松很多！首先看一下普通表达式：(1+2)*(2-1)  转成逆波兰后变成 1 2 + 2 1 - *下面说说怎么转成逆波兰，然后再说计算逆波兰！ 假设要转
【随笔】带正负和单目计算逆波兰表达式求值（安卓）
na2wo4的博客
03-28 1767
最近上安卓课，需要写一个计算器，自己加了个需求：需要实现表达式计算，还要实现优先级运算和单目运算符（如负号，根号）运算； 首先看一下逆波兰表达式的转换过程，逆波兰式的定义大家自己查一下就好啦。 我这个计算器里面设定了一些规则来确保表达式正确，在输入的时候就尽可能避免错误了，剩下的则是在情况在计算解析的时候抛出异常。规则如下（判断优先级逐条递减）： 若是表达式第一个字符， - 、(、√、数字可直...
150.逆波兰表达式求值
zrh_CSDN的博客
10-26 398
根据逆波兰表示法，求表达式的值。 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 输入: ["2", "1", "+", "3", "*"] 输出: 9 解释: ((2 + 1) * 3) = 9 示...
简单的控制台版逆波兰计算器
06-12
这是我在大一下学期结束时做的课程设计，能力有限，是控制台版的 代码看起来有点不伦不类，是因为要求用c++写，我先用c写的，然后改了下头文件和函数，但是完全可以用 当时是用的vs2010编译的，有些代码可能不通用。...
mfc逆波兰计算器
09-08
逆波兰计算器，也被称为后缀表达式计算器，是一种在编程和计算领域中常见的设计模式，尤其是在解释器或计算器的实现中。MFC（Microsoft Foundation Classes）是微软提供的一套C++类库，用于构建Windows应用程序。这...
逆波兰计算器 栈
07-13
逆波兰计算器，也被称为后缀表达式计算器，是一种利用栈数据结构进行计算的算法。它在计算时将操作符置于操作数之后，因此无需括号来确定运算顺序，简化了计算过程。在这个场景中，我们将重点讨论如何用Java实现逆...
逆波兰计算器C代码
03-27
用中缀表达式计算 。
逆波兰计算器 数据结构
05-05
逆波兰计算器，也被称为后缀表达式计算器，是一种基于栈操作的计算模型，它在计算过程中避免了使用括号，并且使得计算过程更为简洁。这种计算器的运算规则是将操作符放在操作数之后，比如“2 3 +”代表“2 + 3”。...
波兰式与逆波兰式
Lavi的专栏
01-07 1814
1 波兰式 波兰式是在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之前，所以，这种表示法也称为前缀表达式。例如：3*（2-（5+1）），用波兰式来表示是：* 3 - 2 + 5 1。 阅读这个表达式需要从左至右读入表达式，如果一个操作符后面跟着两个操作数时，则计算，然后将结果作为操作数替换这个操作符和两个操作数，重复此步骤，直至所有操作符处理完毕。从左往右依次读取，直到遇到+ 5 1，...
逆波兰式（后缀式）详解
tianmo2010的专栏
09-23 5581
1、建立连接协议（三次握手） （1）客户端发送一个带SYN标志的TCP报文到服务器。这是三次握手过程中的报文1。 （2） 服务器端回应客户端的，这是三次握手中的第2个报文，这个报文同时带ACK标志和SYN标志。因此它表示对刚才客户端SYN报文的回应；同时又标志SYN给客户端，
逆波兰计算器，实现对负数的支持（TCPL,练习4-3）
hanyi0000的专栏
08-30 2516
关于逆波兰计算，（5-3）*2 表示为 5 3 - 2 * 这样的表示中，是不支持负数的，因为所有出现的“-”都会被认为是“减号”，例如5*（-3），逆波兰表示为5 -3 * ，按照规则，遇到“-”时，取栈顶的两位，便会报错（只有一个5）。 因此，为了支持负数，可以引进一个符号位，标记可能出现的负数。尝试引进左括号“（”，于是上式便可以写为 5 （-3 * 作为标识符，为了延展通用性，即便是正
逆波兰计算器 进阶版（可以直接计算中缀表达式，支持 小数，负数）
牛大春の博客
10-08 566
2020年 4-27号 ，我发表了这篇文章， 然后这篇文章的代码不支持 小数，负数，然后于今天 21点07分 我把这个问题解决了（不是从四月份开始解决的，是因为 之前上网课没时间弄，然后这个学期学数据结构，所以就搞一波，没有看网上的博客，然后全都是自己一个人解决的） 直接上代码！ #include<iostream> #include<cstring> #include<math.h> #include<ctype.h>//isdigit()头文件 #in
逆波兰表达式计算器
weixin_44076260的博客
04-10 529
前缀、中缀、后缀表达式(逆波兰表达式)： 前缀表达式：又称波兰表达式，前缀表达式的运算符位于操作数之前 举例：(3+4)*5-6,对应的前缀表达式为- * + 3 4 56 中缀表达式：就是常见的运算表达式，如：(3+4)*5-6 后缀表达式：又称为逆波兰表达式，与前缀表达式相似，只是运算符...
C语言使用栈实现逆波兰计数器
最新发布
知识改变命运！
12-18 210
第二个计算的是5 + （6 + 7）* 8 + 9 / 4。第一个计算的是(1 - 2) + (4 * 5)逆波兰计数器又叫后缀表达式。
使用Go语言实现stack包与逆波兰计算器
"这篇资料是关于Go语言的学习指南，涵盖了从入门到高级的知识，并提到了一个名为`stack`的包的创建与单元测试，以及如何使用这个包来实现逆波兰计算器。" 在Go语言中，包是组织代码的基本单位，它们提供了一种模块...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值