【献给过去的自己】栈实现计算器（C语言）

news2024/12/23 18:57:53

背景

        记得在刚学C语言时，写了一篇栈实现计算器-CSDN博客文章。偶然间看到了文章的阅读量以及评论，居然有1.7w的展现和多条博友的点评，反馈。

        现在回过头来看，的确有许多不严谨的地方，毕竟当时分享文章时，还未毕业。理论和思维还不够严谨。但是我还依稀记得，班级上当时写出这个程序的同学，稀疏可数。所以在当时，还是有骄傲的资本的。本着对技术精益求精的态度，再通过本篇文章希望能够帮助刚接触C语言的朋友，也是给过去的自己一个满意的答复~

规则

        对于一个表达式，我们应该如何去识别它呢？当时，老师和我们说，按照如下规则进行解析即可。

        当时我们并不懂这个规则的由来，只知道按照这个规则去编程即可。再后来的工作中，因为考《软件设计师》资格证，了解到上述的规则，其实就是后缀表达式。同理还有前缀表达式，中缀表达式。

中缀表达式

        中缀表达式就是我们常用的一种算数表示方式。它的特点是操作符以中缀的方式处于操作数中间。但是中缀表达比较适合人类计算，对于计算机而言过于复杂。前缀表达式和后缀表达式对于计算机而言，更加友好。

        因此，我们想用程序实现计算器功能，有两种方式：

中缀表达式--> 前缀表达式-->计算

中缀表达式--> 后缀表达式-->计算

前缀表达式

        前缀表达式的运算符位于两个操作数之前，又称为前缀记法或波兰式。比如表达式（中缀）5+4，前缀表达式+ 5 4。因此使用前缀表达式进行计算，需要两个步骤。

  1. 如何将中缀表达式转换为前缀表达式

  2. 计算机如何识别前缀表达式并计算

中缀表达式转换前缀表达式

        根据文中描述，中缀表达式转换为前缀表达式的规则如下：

  1. 初始化两个栈：运算符栈S1和存储中间结果的栈S2;

  2. 从右至左扫描中缀表达式；

  3. 遇到操作数时，将其压入S2;

  4. 遇到运算符时，比较其与S1栈顶运算符的优先级；

    1. 如果S1为空，或栈顶运算符为右括号)，则将此运算符入栈；

    2. 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1;

    3. 否则，将S1栈顶的运算符弹出并压入到S2,再次转到4.1与S1中新的栈顶运算符相比较；

  5. 遇到括号时：

    1. 如果是右括号)，则直接压入S1;

    2. 如果是左括号(，则依次弹出S1栈顶的运算符，并压入S2,直到遇到右括号为止，此时将这一对括号丢弃；

  6. 重复步骤2至5,直到表达式的最左边；

  7. 将S1中剩余的运算符依次弹出并压入S2;

  8. 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。

        虽然规则很复杂，但是编码难度并不是很大，大家可以按照自己的技术能力尝试一下。

分析思路

        我们以表达式1+(2+3)*4-5举例。

        1. 因为输入表达式是字符串，后续我们需要从右往左扫描表达式，因此首先需要将字符串表达式中的运算符和操作数进行区分，可以用整型数组如下图：

        2. 根据2至5规则，进行分析。

       

        3. 弹出S2中的数据元素：- + 1 * + 2 3 4 5;

代码示例

我的代码示例如下：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<stdint.h>
#include<stdbool.h>

#define STACK_LEN 1024

/** 中缀表达式栈*/
static int32_t g_infix_expression[1024] = {0};

/** 前缀表达式栈*/
static int32_t g_prefix_expression[1024] = {0};

/** 后缀表达式栈*/
static int32_t g_suffix_expression[1024] = {0};

/**
 * @brief 将输入的字符串表达式转换为中缀表达式
 *
 * @param [in] expression 字符串表达式
 * @return int 0 成功 non-0 失败
 * */
int expression2infix(const char* expression)
{
    if(expression == NULL)
    {
        printf("input error\n");
        return -1;
    }
    
    int dataTmp = 0; //表达式中的操作数
    
    bool dataFlag = false; // 操作数标识,表示当前是否有数据需要入栈

    const char* ptr = expression;
    int32_t* infix_index = g_infix_expression;
    
    printf("expression = %s\n",expression);

    while(*ptr != '\0')
    {
        /** 字符为数字*/
        if('0' <= *ptr  && *ptr <= '9')
        {
            dataTmp = dataTmp*10 +(*ptr - '0');
            dataFlag = true;
        }
        /**字符为操作符或括号*/
        else if(*ptr == '+' || *ptr == '-' || *ptr == '*' || *ptr == '/' 
            || *ptr == '(' || *ptr == ')')
        {
            if(dataFlag == true)
            {
                *(infix_index++) = dataTmp;
                dataFlag = false;
                dataTmp = 0;
            }
            *(infix_index++) = *ptr;
        }
        else
        {
            printf("wrong exptrssion\n");
            return -1;
        }

        ptr++;
    }

    /**将最后一个操作数，入栈*/
    if(dataFlag == true)
    {
        *(infix_index++) = dataTmp;
        dataFlag = false;
        dataTmp = 0;
    }
    return 0;
}

/**
 * @brief 将中缀表达式转换为前缀表达式
 *
 * @return int 0 成功 non-0 失败
 * */
int infix2prefixExpression()
{
    /**初始化运算符栈和中间结果栈*/
    int32_t stack_s1[STACK_LEN] = {0};
    int32_t stack_s1_top = 0;

    int32_t stack_s2[STACK_LEN] = {0};
    int32_t stack_s2_top = 0; 

    int32_t * index = g_infix_expression;

    /**获取中缀表达式最右侧操作数*/

    while(*(index+1) != 0)
    {
        index++;
    }

    while(index != g_infix_expression)
    {
        /** 操作符*/
        if(*index == '+' || *index == '-' || *index == '*' || *index == '/')
        {
            while(true)
            {
                /**S1为空，或栈顶运算符为右括号)，则将此运算符入栈*/
                if(stack_s1_top == 0 || stack_s1[stack_s1_top-1] == ')' || stack_s1[stack_s1_top-1] == '-'
                    || stack_s1[stack_s1_top-1] == '+')
                {
                    stack_s1[stack_s1_top++] = *index;
                    break;
                }

                stack_s2[stack_s2_top++] = stack_s1[stack_s1_top-1];
                stack_s1[stack_s1_top-1] = 0;
                stack_s1_top = stack_s1_top -1;
            }
        }
        /**左括号
         * 则依次弹出S1栈顶的运算符，并压入S2,直到遇到右括号为止
        */
        else if(*index == '(')
        {
            while(true)
            {
                /**异常*/
                if(stack_s1_top == 0)
                {
                    printf("infix experssion worong\n");
                    return -1;
                }

                /**遇到右括号,丢弃括号*/
                if(stack_s1[stack_s1_top-1] == ')')
                {
                    stack_s1[stack_s1_top-1] = 0;
                    stack_s1_top = stack_s1_top -1;
                    break;
                }
                /**其它符号需要入栈S2*/
                else
                {
                    stack_s2[stack_s2_top++] = stack_s1[stack_s1_top-1];
                    stack_s1[stack_s1_top-1] = 0;
                    stack_s1_top--;
                }

            }

        }
        /**右括号
         * 直接入运算符栈s1
        */
        else if(*index == ')')
        {
            stack_s1[stack_s1_top++] = *index;
        }
        /** 操作数
         * 直接加入栈s2*/
        else
        {
            stack_s2[stack_s2_top++] = *index;
        }
        index--;
#if 0
        printf("==============\n");
        printf("stack_s1=");
        for(int i = 0 ; i < stack_s1_top; i++)
        {
            (stack_s1[i] > 9) ? (printf("%c ",stack_s1[i])):(printf("%d ",stack_s1[i]));
        }
        printf("\n");

        printf("stack_s2=");
        for(int i = 0 ; i < stack_s2_top; i++)
        {
            (stack_s2[i] > 9) ? (printf("%c ",stack_s2[i])):(printf("%d ",stack_s2[i]));
        }
        printf("\n");
#endif  
    }

    /**将最左侧操作数压入s2*/
    stack_s2[stack_s2_top++] = *index;
    
    /**将s1中的符号压入s2*/
    for(int i = stack_s1_top - 1; i >= 0; i-- )
    {
        stack_s2[stack_s2_top++] = stack_s1[i];
        stack_s1[i] = 0;    
    }

    /**将s2中的数据弹出，放入前缀表达式栈中*/
    for(int i = 0 ; stack_s2_top > 0; i++,stack_s2_top--)
    {
        g_prefix_expression[i] = stack_s2[stack_s2_top-1];
    }

    return 0;
}



int main(int argc,char* argv[])
{
    if(argc != 2)
    {
        printf("please input experssion\n");
        return -1;
    }

    int32_t iRet = 0;

    iRet = expression2infix(argv[1]);
    if(iRet == 0)
    {
        for(int i = 0 ; i < STACK_LEN && g_infix_expression[i] != 0; i++)
        {
            if(g_infix_expression[i] == '+' || g_infix_expression[i] == '-' || g_infix_expression[i] == '*' || g_infix_expression[i] == '/')
            {
                printf("%c ",g_infix_expression[i]);
            }
            else
            {
                printf("%d ",g_infix_expression[i]);
            }
        }
        printf("\n");
    }

    iRet = infix2prefixExpression();
    if(iRet == 0)
    {
        for(int i = 0 ; i < STACK_LEN && g_prefix_expression[i] != 0; i++)
        {
            if(g_infix_expression[i] == '+' || g_infix_expression[i] == '-' || g_infix_expression[i] == '*' || g_infix_expression[i] == '/')
            {
                printf("%c ",g_infix_expression[i]);
            }
            else
            {
                printf("%d ",g_infix_expression[i]);
            }
        }
        printf("\n");
    }

    prefixExpressionCaculate();
    return 0;
}

前缀表达式计算

前缀表达式的计算规则如下：

  1. 从右至左扫描表达式；

  2. 遇到数字，压入栈中；

  3. 遇到运算符，弹出栈顶的两个数，并用运算符对这两个数做相应的计算，并将结果入栈；

  4. 重复上述2,3步骤，直到表达式最左端，最后的值为表达式的结果。

分析思路

        以上述后缀表达式举例:- + 1 * + 2 3 4 5。

        得出结果为16。

代码示例

新增prefixExpressionCaculate接口。代码如下：

/**
 * @brief 将前缀表达式进行计算
 *
 * @return int 0 成功 non-0 失败
 * */
int prefixExpressionCaculate()
{
    /**结果栈*/
    int32_t stack[1024] = {0};
    int32_t stack_len = 0;

    /**临时结果*/
    int32_t tmpResult = 0;
    int32_t data1 = 0;
    int32_t data2 = 0;

    /**获取后缀表达式的最右侧操作数*/
    int32_t* index = g_prefix_expression;
    while(*(index+1) != 0)
    {
        index++;
    }

    while(index >= g_prefix_expression)
    {
        /**弹出栈顶的两个数，并用运算符对这两个数做相应的计算，并将结果入栈*/
        if(*index == '+' || *index == '-' || *index == '*' || *index == '/')
        {
            data1 = stack[stack_len-1];
            data2 = stack[stack_len-2];
            if(*index == '+')
            {
                tmpResult = data1 + data2;
            }
            else if(*index == '-')
            {
                tmpResult = data1 - data2;
            }
            else if(*index == '*')
            {
                tmpResult = data1 * data2;
            }
            else if(*index == '/')
            {
                tmpResult = data1 / data2;
            }
            else
            {
                printf("worng prefixExperssion\n");
                return -1;
            }

            stack[stack_len-1] = 0;
            stack[stack_len-2] = tmpResult;
            stack_len --;
        }
        /**遇到数字，压栈*/
        else
        {
            stack[stack_len] = *index;
            stack_len ++;
        }
        index --;

    }
    printf("result = %d\n",stack[0]);
    return 0;
}

演示

后缀表达式

        后缀表达式与前缀表达式类似，只是运算符位于两个相应操作数之后，后缀表达式也称为后缀记法或逆波兰式。同样，我们需要解决两个问题。

  1. 如何将中缀表达式转换为后缀表达式

  2. 后缀表达式的计算规则

中缀表达式转后缀表达式

根据文中描述，中缀表达式转换为后缀表达式的规则如下：

  1. 初始化两个栈：运算符栈S1和存储中间结果的栈S2;

  2. 从左至右扫描中缀表达式；

  3. 遇到操作数时，将其压入S2;

  4. 遇到运算符时，比较其与S1栈顶运算符的优先级；

    1. 如果S1为空，或栈顶运算符为左括号(，则将此运算符入栈；

    2. 否则，若优先级比栈顶运算符的高，也将运算符压入S1;(注意是必须为高，相同或低于都不行)

    3. 否则，将S1栈顶的运算符弹出并压入到S2,再次转到4.2与S1中新的栈顶运算符相比较；

  5. 遇到括号时：

    1. 如果是左括号(，则直接压入S1;

    2. 如果是右括号)，则依次弹出S1栈顶的运算符，并压入S2,直到遇到左括号为止，此时将这一对括号丢弃；

  6. 重复步骤2至5,直到表达式的最右边；

  7. 将S1中剩余的运算符依次弹出并压入S2;

  8. 依次弹出S2中的元素并输出，结果即为中缀表达式对应的后缀表达式。

后缀表达式计算规则

后缀表达式的计算规则如下：

  1. 从左至右扫描表达式；

  2. 遇到数字，压入栈中；

  3. 遇到运算符，弹出栈顶的两个数，并用运算符对这两个数做相应的计算，并将结果入栈；

  4. 重复上述2,3步骤，直到表达式最右端，最后的值为表达式的结果。

        后缀表达式的代码示例可以参考前缀表达式的分析思路和代码，大家可以尝试编写。

总结

        时间流逝，在竞争激烈的社会背景下，我们的身处IT行业，不断逼迫自己去学习，去成长。但是总会觉得自己做的还不够。为什么总是赶不上别人的脚步，陷入怀疑自我的处境。

        朋友们，偶尔回头看看来时路上的自己，你会发现，你一直在成长，你的努力一直是正向反馈着你，不要轻视自己的努力。感谢csdn给予记录成长的平台，也感谢一直努力的自己。共勉~

参考文档

前缀表达式、中缀表达式和后缀表达式 - 乘月归 - 博客园

数据结构和算法（六）：前缀、中缀、后缀表达式

栈实现计算器-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1220459.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

实时人眼追踪、内置3D引擎，联想ThinkVision裸眼3D显示器创新四大应用场景

实时人眼追踪、内置3D引擎，联想ThinkVision裸眼3D显示器创新四大应用场景

11月17日&#xff0c;在以“因思而变 智领未来”为主题的Think Centre和ThinkVision 20周年纪念活动上&#xff0c;联想正式发布了业内首款2D/3D 可切换裸眼3D显示器——联想ThinkVision 27 3D。该产品首次将裸眼2D、3D可切换技术应用在显示器领域&#xff0c;并拓展了3D技术多…
阅读更多...
柯桥外语学校|西班牙语中关于金钱的俚语

柯桥外语学校|西班牙语中关于金钱的俚语

01 Estar forrado(a) “Forrado(a)”源自动词“forrar”&#xff0c;该动词本意为“包&#xff1b;裹”的动作。 在口语中&#xff0c;则是形容一个人被金钱所包裹&#xff0c;可见这个人是多么地有钱&#xff08;有点类似于我们的成语“腰缠万贯”所描绘的画面&#xff09;。…
阅读更多...
leetcode刷题日记:141. Linked List Cycle（环形链表）

leetcode刷题日记:141. Linked List Cycle（环形链表）

这一题是给我们一个链表让我们判断这是否是一个环形链表&#xff0c;我们知道如果一个链表中有环的话这一个链表是没有办法访问到尾的&#xff0c; 假若有如图所示的带环链表&#xff1a; 我们从图示中很容易看出来这一个链表在访问的时候会在里面转圈&#xff0c;我们再来看看…
阅读更多...
面试鸭 - 专注于面试刷题的网站

面试鸭 - 专注于面试刷题的网站

网上面试题有很多&#xff0c;但此套面试题真实、原创、高频&#xff0c;全网最强。 题目涵盖大中小公司&#xff0c;真实靠谱&#xff0c;有频率和难度的标记&#xff0c;助你成为Offer收割机。 面试鸭地址&#xff1a;https://mianshiya.skyofit.com/ 本套题是我原创&…
阅读更多...
浙大恩特客户资源管理系统CustomerAction.entphone；.js 接口任意文件上传漏洞复现 [附POC]

浙大恩特客户资源管理系统CustomerAction.entphone；.js 接口任意文件上传漏洞复现 [附POC]

文章目录 浙大恩特客户资源管理系统CustomerAction.entphone;.js 接口任意文件上传漏洞复现 [附POC]0x01 前言0x02 漏洞描述0x03 影响版本0x04 漏洞环境0x05 漏洞复现1.访问漏洞环境2.构造POC3.复现 0x06 修复建议 浙大恩特客户资源管理系统CustomerAction.entphone;.js 接口任…
阅读更多...
故障发现、定位提效超 70%，去哪儿可观测体系做了哪些优化？

故障发现、定位提效超 70%，去哪儿可观测体系做了哪些优化？

一分钟精华速览 去哪儿网的原有监控系统在指标数量上展现出了强大实力——上亿指标量和百万级的告警量&#xff0c;但在故障数据方面却稍显不足——订单类故障平均发现时间长达 4 分钟&#xff0c;仅有 20%的订单类故障能在 1 分钟内被发现&#xff0c;近半数的故障处理时长超…
阅读更多...
注册表单mvc 含源代码

注册表单mvc 含源代码

总结 jsp给我们的ControllerServlet.java,ControllerServlet.java获取参数,信息封装给RegisterFormBean.java的对象看是否符合格式,符合格式再信息封装给UserBean对象,调用Dbutil插入方法查重.]]要创建一个user集合成功跳哪个界面,打印信息注意什么时候要加getsession失败跳哪…
阅读更多...
超越视觉：探索The Foundry NUKE 15 的无限可能性

超越视觉：探索The Foundry NUKE 15 的无限可能性

你是否曾被电影中那些令人震撼的特效所吸引&#xff1f;是否曾梦想过自己也能制作出这样的特效&#xff1f;现在&#xff0c;这个梦想即将成为现实。今天&#xff0c;我们将向你介绍一款引领影视后期特效制作潮流的软件——The Foundry NUKE 15。 The Foundry NUKE 15是一款专…
阅读更多...
JVM类加载机制详解

JVM类加载机制详解

JVM类加载运行全过程 运行Math类的main函数&#xff0c;启动程序时&#xff0c;首先需要通过类加载器把类加载到JVM。 package com.cold;public class Math {public int compute() {int a 1;int b 2;int c (a b) * 10;return c;}public static void main(String[] args) …
阅读更多...
如何将中文翻译成荷兰语？

如何将中文翻译成荷兰语？

随着中国的崛起&#xff0c;荷兰与中国的交流日益频繁。越来越多的企业和个人需要荷兰语翻译服务。那么&#xff0c;如何将中文翻译成荷兰语&#xff0c;北京哪家翻译公司比较专业&#xff1f; 专业人士指出&#xff0c;要提供优质的荷兰语翻译服务&#xff0c;不仅需要扎实的荷…
阅读更多...
【hive-解决】HiveAccessControlException Permission denied: CREATEFUNCTION

【hive-解决】HiveAccessControlException Permission denied: CREATEFUNCTION

文章目录 一.任务描述二. 解决 一.任务描述 Error while compiling statement: FAILED: HiveAccessControlException Permission denied: Principal [nameroot, typeUSER] does not have following privileges for operation CREATEFUNCTION [ADMIN PRIVILEGE on INPUT, ADMIN…
阅读更多...
CSGO的那些事儿：CS2这么差，为什么不改回CS1?

CSGO的那些事儿：CS2这么差，为什么不改回CS1?

揭秘csgo饰品涨价背后的残酷真相 1、V社现在更新内容集中在游戏性的修复方面。 所以原来期望的新地图新大行动等&#xff0c;要等到游戏本体趋于稳定后才更新。但是&#xff0c;因为距离下一个大型活动&#xff0c;也就是丹麦major还有5个月时间&#xff0c;那这之间必然要有一…
阅读更多...
百度智能小程序源码系统：打造极致用户体验的关键 带完整搭建教程

百度智能小程序源码系统：打造极致用户体验的关键 带完整搭建教程

大家好啊&#xff0c;今天罗峰来给大家分享一款百度智能小程序系统源码。一起来看看吧。 百度智能小程序源码系统是百度从做智能小程序的第一天开始就致力于打造真正开源开放的生态的产物。作为目前业内唯一真正开源的平台&#xff0c;百度智能小程序将开放性放在重要位置&…
阅读更多...
kubernetes 高可用集群

kubernetes 高可用集群

目录 一、haproxy负载均衡 二、pacemaker高可用 三、部署control-plane 四、部署worker node 实验环境 主机名 IP 角色 docker 192.168.67.10 harbor k8s1 192.168.67.11 control-plane k8s2 192.168.67.12 control-plane k8s3 192.168.67.13 control-plane k8s…
阅读更多...
数字逻辑电路基础-组合逻辑电路之复用器

数字逻辑电路基础-组合逻辑电路之复用器

文章目录 一、复用器简介二、verilog源码三、综合及仿真结果一、复用器简介 本文介绍数字逻辑电路中一种常用的基础组合逻辑电路-两选一复用器，顾名思义，它的功能就是通过一个控制信号来选择两个输入中之一作为输出。 它的逻辑表达式为：out = ~sa + sb 它的逻辑真值表为：…
阅读更多...
元宇宙数字展厅无代码编辑工具的功能特点

元宇宙数字展厅无代码编辑工具的功能特点

商场如战场&#xff0c;营销是每个企业都必须重视的环节。随着科技的发展&#xff0c;3D展示营销制作平台作为企业快速搭建3D互动展厅的SaaS平台&#xff0c;逐渐崭露头角&#xff0c;为企业提供了诸多便利&#xff0c;让营销变得更加高效和引人入胜。 为企业提供身临其境的产品…
阅读更多...
IDEA 中设置 File Header 以及自定义类、方法注释模板的方法

IDEA 中设置 File Header 以及自定义类、方法注释模板的方法

目录 1 设置 File Header2 自定义类、方法注释生成类注解模板生成方法注解模板 1 设置 File Header File -> Settings -> File and Code Templates -> Includes -> File Header -> 编辑 2 自定义类、方法注释 File -> Settings -> Live Templates -&g…
阅读更多...
2023年最新软件安装管家目录

2023年最新软件安装管家目录

最新软件安装管家目录 软件目录 ①【电脑办公】电脑系统&#xff08;直接安装&#xff09;Win7Win8Win10OfficeOffice激活office2003office2007office2010office2013office2016office2019office365office2021wps2021Projectproject2007project2010project2016project2019projec…
阅读更多...
二层、三层交换机之间到底有什么区别?

二层、三层交换机之间到底有什么区别?

简单地说 二层交换机&#xff0c;没有充当三层网关角色的能力&#xff08;Capability&#xff09;。三层交换机&#xff0c;首先也是二层交换机。但是&#xff0c;它有一个额外的能力&#xff08;Capability&#xff09;&#xff0c;软件配置一下&#xff0c;可以充当三层网关…
阅读更多...
【嵌入式C】栈内存与printf，代码正确运行，删掉 printf 代码就崩溃了？？

【嵌入式C】栈内存与printf，代码正确运行，删掉 printf 代码就崩溃了？？

目录 1. 删掉 printf 代码就崩溃了2. 运行代码为什么报错2.1 为什么程序报错 Segmentation fault &#xff1f;2.2 为什么程序每次都稳定的报错&#xff1f;2.3 研究一下两个局部变量的值和地址&#xff1f; 3. 为什么加一个 “\n”就可以正确执行&#xff1f;疑问&#xff1f;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023