堆栈应用：表达式求值（C语言）

最新推荐文章于 2022-05-10 19:53:36 发布
最新推荐文章于 2022-05-10 19:53:36 发布
阅读量2k 收藏 23
点赞数 5
分类专栏： 数据结构与算法应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42313728/article/details/99625250
版权

文章目录

堆栈应用：表达式求值（C语言）

两个定义

  • 中缀表达式：运算符号位于两个运算数之间。如：a + b * c - d / e
  • 后缀表达式：运算符号位于两个运算数之后。如：a b c * + d e / -

大致过程

  1. 用后缀表达式求值：
    对于后缀表达式，可以比较容易处理。大致过程为：将后缀表达式从左到右扫描，遇到数字就将数字压如堆栈中，遇到运算符就将运算符前面的两个数字出栈，将运算符置于两数字之间运算，将运算结果入栈。最后栈中剩余的最后一个元素就是运算结果。

    • 【例子】求：6 2 / 3 - 4 2 * +

      步骤：

      1. 从左到右扫描，遇到6和2，分别将其压进堆栈中。
      2. 遇到除号，将6和2出栈，计算6/2=3，将3入栈；继续扫描，后面遇见一个3，继续入栈。
        在这里插入图片描述
      3. 遇到减号，将两个3出栈，计算3-3=0，将0入栈；继续扫描，后面遇见4与2，将其入栈。
        在这里插入图片描述
      4. 遇到乘号，将4和2出栈，计算4*2=8，将8入栈；
        在这里插入图片描述
      5. 遇到加号，将0和8出栈，计算0+8=8，将8入栈，扫描之后发现已经没有字符，而堆栈中只有8这个元素，故结果为8。
        在这里插入图片描述

  2. 将中缀表达式转换为后缀表达式
    所以现在我们要做的就是将中缀表达式变成后缀表达式。观察两种表达式的转换：2 + 9 / 3 - / 5 —> 2 9 3 / + 5 -

    1. 运算数相对顺序不变
    2. 运算符号顺序发生改变
      • 需要存储“等待中”得运算符号
      • 要将当前运算符号与“等待中”的运算符号比较

    中缀表达式转换为后缀表达式的过程：

    • 从头到尾读取中缀表达式的每个对象，对不同的对象按照不同的情况处理。

      1. 运算符：直接输出；
      2. 左括号：压入堆栈；
      3. 右括号：将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出）；
      4. 运算符：
        • 若优先级大于栈顶运算符时，则把它压入栈中；
        • 若优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出；在比较新的栈顶元素运算符，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压入栈中。
      5. 若各对象处理完毕，则将堆栈中存留的运算符一并输出。

      在这里插入图片描述

具体代码

  1. main.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

int main(void)
{
    char InfixStr[MAXSIZE] = { 0 }, SuffixStr[MAXSIZE] = { 0 };
    Read_Expression(InfixStr,MAXSIZE);//将在键盘上输入的中缀表达式保存在字符串InfixStr中
    //puts(InfixStr);
    InfixToSuffix(InfixStr, SuffixStr,MAXSIZE);//将中缀表达式抓换成后缀表达式
    //puts(SuffixStr);
    printf("\n结果是：%f\n", Calculate(SuffixStr, MAXSIZE));

    system("pause");
    return 0;
}

  2. Expression_evaluation.h

    #define MAXSIZE 100

//存放字符的堆栈
struct SNode {
    char Data[MAXSIZE];
    int Top;
};
typedef struct SNode* Stack;

//存放浮点数的堆栈
struct SNodeOfInt {
    float Data[MAXSIZE];
    int Top;
};
typedef struct SNodeOfInt* StackOfFloat;

int Compare(char, Stack);//在中后缀表达式转换的时候，加减乘除号比较优先级，判断加减乘除号是否入栈
void Read_Expression(char[], int);//读取键盘输入的表达式
void InfixToSuffix(char[], char[], int);//将中缀表达式转换为后缀表达式
float Calculate(char[], int);//由后缀表达式求出表达式结果

//入栈
void Push(Stack, char);
void PushFloat(StackOfFloat, float);

//出栈
char Pop(Stack);
float PopFloat(StackOfFloat);

  3. Read_Expression.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"


void Read_Expression(char str[], int length)
{
    printf("请输入所需求值的中缀表达式（英文输入法）：\n");
    gets(str);

    return str;
}

  4. InfixToSuffix.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

void InfixToSuffix(char Infix[], char Suffix[], int length)
{
    int i = 0,j=0,Tag=0;
    //建立一个空栈
    struct SNode S_1 = { {'\0'},-1 };
    Stack SPtr = &S_1;

    //扫描中缀表达式的所有字符，根据字符的值做出不同操作
    while (Infix[i] != '\0')
    {
        //当扫描到数字的时候，直接输出到字符串Suffix中
        if (Infix[i] <= '9'&&Infix[i] >= '0')
        {
            Suffix[j] = Infix[i];
            j++;
        }
        //当扫描到空格的时候，直接输出到字符串Suffix中
        else if (Infix[i] == ' ')
        {
            Suffix[j] = Infix[i];
            j++;
        }
        //当扫描到加减乘除运算符的时候，将其与堆栈顶元素比较优先级，根据优先级决定进栈还是栈顶元素出栈输出
        else if (Infix[i] == '+' || Infix[i] == '-' || Infix[i] == '*' || Infix[i] == '/')
        {
            Suffix[j] =' ';
            j++;
            //当栈顶元素出栈输出时，扫描到的元素要继续与新的栈顶元素比较优先级，直至扫描到的元素入栈
            Tag = 0;
            while (Tag == 0)
            {
                Tag = Compare(Infix[i], SPtr);
                if (Tag == 0)
                {
                    Suffix[j] = Pop(SPtr);
                    j++;
                }
                else
                {
                    Push(SPtr, Infix[i]);
                }
            }
        }
        //如果扫描到左括号，直接进栈
        else if(Infix[i]=='(')
        {
            Push(SPtr, Infix[i]);
        }
        //如果扫描到右括号，一直出栈输出直到栈顶元素是左括号，然后将栈顶的左括号出栈但不输出
        else if (Infix[i] == ')')
        {
            Suffix[j] = ' ';
            j++;
            while (SPtr->Data[SPtr->Top] != '(')
            {
                Suffix[j] = Pop(SPtr);
                j++;
            }
            Pop(SPtr);
        }
        i++;
    }
    //扫描完之后将堆栈中所有元素出栈
    while (SPtr->Top != -1)
    {
        Suffix[j] = Pop(SPtr);
        j++;
    }
}

  5. Compare.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

int Compare(char ch_1, Stack SPtr)
{
    //如果堆栈空，将扫描到的运算符号进栈
    if (SPtr->Top == -1)
    {
        return 1;
    }
    //当栈顶是左括号时，将扫描到的运算符号进栈
    if (SPtr->Data[SPtr->Top] == '(')
    {
        return 1;
    }
    //当栈顶是乘号或者除号的情况
    else if (SPtr->Data[SPtr->Top] == '/' || SPtr->Data[SPtr->Top] == '*')
    {
        //如果扫描到的也是乘号或除号，将栈顶元素出栈
        if (ch_1 == '*' || ch_1 == '/')
        {
            return 0;
        }
        //如果扫描到的是加号或者减号，将栈顶元素出栈
        else
        {
            return 0;
        }
    }
    //当栈顶元素是加号或者减号时
    else
    {
        //如果扫描到的也是乘号或除号，将栈顶元素进栈
        if (ch_1 == '*' || ch_1 == '/')
        {
            return 1;
        }
        //如果扫描到的是加号或者减号，将栈顶元素出栈
        else
        {
            return 0;
        }
    }
}

  6. Calculate.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

float Calculate(char Suffix[], int length)
{
    float sum = 0, temp = 0, first = 0, last = 0;
    int i = 0;
    //建立一个空栈
    struct SNodeOfInt S = { {0},-1 };
    StackOfFloat SPtr = &S;
    while (Suffix[i] != '\0')
    {
        //扫描后缀表达式，计算结果
        while (Suffix[i] != '\0')
        {
            //当扫描到的是数字字符，将其转换成数字，并将其压入栈中
            if (Suffix[i] <= '9'&&Suffix[i] >= '0')
            {
                sum = 0;
                while (Suffix[i] <= '9'&&Suffix[i] >= '0')
                {
                    temp = (float)(Suffix[i] - '0');
                    sum = sum * 10 + temp;
                    i++;
                }
                PushFloat(SPtr, sum);
            }

            //当扫描到空格，忽略
            if (Suffix[i] == ' ')
            {
                i++;
            }
            //当扫描到加减乘除号，将栈顶两个元素弹出，并将其用扫描到的运算符号计算，将结果压入栈中
            if (Suffix[i] == '+' || Suffix[i] == '-' || Suffix[i] == '*' || Suffix[i] == '/')
            {
                last = PopFloat(SPtr);
                first = PopFloat(SPtr);
                if (Suffix[i] == '+')
                {
                    PushFloat(SPtr, first + last);
                    i++;
                }
                else if (Suffix[i] == '-')
                {
                    PushFloat(SPtr, first - last);
                    i++;
                }
                else if (Suffix[i] == '*')
                {
                    PushFloat(SPtr, first*last);
                    i++;
                }
                else
                {
                    PushFloat(SPtr, first / last);
                    i++;
                }
            }

        }
        return PopFloat(SPtr);//栈中最后一个数字就是结果，将其返回
    }

}

  7. Pop.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

char Pop(Stack SPtr)
{
    if (SPtr->Top == -1)
    {
        printf("堆栈空");
        return '\n';//栈空时返回回车键
    }
    else
    {
        return (SPtr->Data[(SPtr->Top)--]);//先返回栈顶元素，再将Top减一。
    }
}

float PopFloat(StackOfFloat SPtr)
{
    if (SPtr->Top == -1)
    {
        printf("堆栈空");
        return '\n';//栈空时返回回车键
    }
    else
    {
        return (SPtr->Data[(SPtr->Top)--]);//先返回栈顶元素，再将Top减一。
    }
}

  8. Push.c

    #include<stdio.h>
#include<stdlib.h>
#include"Expression_evaluation.h"

void Push(Stack SPtr, char itme)
{
    if (SPtr->Top == MAXSIZE - 1)
    {
        printf("堆栈满");
        return;
    }
    else
    {
        SPtr->Data[++(SPtr->Top)] = itme;//Top先自加一，然后再给栈顶元素赋值。
        return;
    }
}

void PushFloat(StackOfFloat SPtr, float itme)
{
    if (SPtr->Top == MAXSIZE - 1)
    {
        printf("堆栈满");
        return;
    }
    else
    {
        SPtr->Data[++(SPtr->Top)] = itme;//Top先自加一，然后再给栈顶元素赋值。
        return;
    }
}
过客WZX
关注
专栏目录
“栈”的典型应用—表达式求值（C语言实现）
yuluo
06-13 9万+
表达式求值是程序设计语言编译中的一个基本问题。它的实现就是对“栈”的典型应用。本文针对表达式求值使用的是最简单直观的算法“算符优先法”。 我们都知道算术四则运算的运算规则是： 先乘除，后加减。 从左到右计算 先算括号内，再算括号外 表达式组成 任何一个表达式都有操作数、运算符和界定符组成。 操作数即可以是常量，也可以是被说明为变量或常量的标识符。 运算符可以分为算术运算，关系运算和
堆栈应用：表达式求值
梁超的博客
08-21 1100
表达式求值： 应用堆栈实现表达式求值的过程：从左到右读入后缀表达式的各项，并根据读入的对象判断执行操作。操作分下列3情况： 当读入的是一个运算数时，把它压入栈中； 当读入的是一个运算符时，就从堆栈中弹出适当数量的运算数，对该运算进行计算，计算结果再压回到栈中； 处理完整个后缀表达式之后，堆栈顶上的元素就是表达式的结果值。 下面我们给出了利用堆栈求后缀表达式值的完整程序。为简便起见，我们假设后缀...
c语言表达式求值对于栈的应用
08-23
数据结果，C语言表达式求值，堆栈经典应用。输入表达式，如1+2*3，输出运算后的值。
C语言数据结构堆栈应用：表达式求值
weixin_52308754的博客
11-04 525
堆栈应用：表达式求值 中缀表达式如何转换为后缀表达式？ 从头到尾读取中缀表达式的每个对象，对不同对象按不同的情况处理。 ①运算数：直接输出 ②左括号：压入堆栈 ③右括号：将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出） ④运算符： 若优先级大于栈顶运算符时，则把它压栈 若优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出；再比较新的栈顶运算符，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压栈； ⑤若各对象处理完毕，则把堆栈中存留的运算符一并输出。 ...
用栈的应用编一个表达式求值的程序（c语言）
06-12
用栈的应用编一个表达式求值的程序（c语言）
表达式求值（c语言实现--基于栈）
05-10
数据结构的高级运用，主要是栈的运用！这个是清华大学数据结构书上的题，将算法改成了c函数，或许对你有点用！调试过的运用程序也在，其中有点小问题希望高人指点！
C语言编写的表达式求值　用栈实现
12-13
自己编写的　　可能代码有点冗余　　欢迎大家提意见
C语言数据结构用栈实现表达式求值
10-26
在本项目中，我们将探讨如何利用C语言的数据结构——栈，来实现表达式的求值。栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则，非常适合处理具有运算顺序的计算问题，如数学表达式的求值。 首先，...
数据结构07：栈的应用（表达式求值）
qq_70132617的博客
05-10 1186
摘要：表达式求值是对栈的一个进阶应用，巧妙地运用了栈的特性，创建了两个栈，一个存放数值，一个存放运算符。看懂这个代码，我们就会对栈的理解更进一步。 实际是这个代码是不好写的，我参考了教材相关内容及其他同学的代码后，才理解并写出以下代码。 由于栈的基本操作等已经在前文说过，这里先只展示有关表达式求值的函数 一.代码块 1）判断优先级函数 char priority(char ch1,char ch2) { //对于优先级的判定，我在书上找到了一个表。对此用二位数组实现比较方便 //书上是添加一个#号代
栈的应用实例---表达式求值（C语言）
王雅瑾---上善若水，水善利万物而不争
06-26 1699
考试中。。。。。。
表达式求值 C语言版
04-25
一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正整数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。引入表达式起始、结束符是为了方便。编程利用“算符优先法”求算术表达式的值。
表达式求值，栈的应用（C语言）
永远的第一天
10-28 3707
无语死了，好在终于弄出来了。 题目：利用栈编写表达式求值程序：输入含有“+”、“-”、“*”、“/”四则运算的表达式，其中负数要用（0-正数）表示，并以=结束。要求输出表达式的值（两运算符号的有限关系见教材《数据结构》表3.1）。 测试样式： 【第一组自测数据】 【键盘输入】 3*（9-7）#↙ 【正确输出】 6 【第二组自测数据】 【键盘输入】 （0-
堆栈经典应用-表达式求值
chenxingp123的专栏
04-24 663
/*==============================================================  *   使用栈完成四则表达式的计算,支持大中小括号以及负数,不支持浮点数  *       参考: Hu Chunxu  *=============================================================*/ #includ
C语言堆栈实现表达式运算
一个安静的程序员
09-16 724
表达式求值，这里用的是算符优先法的方式实现。任何一个表达式都可以由操作数、运算符和界限符组成，算符之间的关系有三种：&gt; &lt; =，介于这三种关系，我们可以列出所有的关系            +               -             *             /           (              )             # ----------...
堆栈的例子——来解决计算机的表达式计算
liutong1995的博客
05-13 747
计算机一般利用后缀表达式来计算多项式：比如对于中缀表达式a+b*c-d/e 其后缀表达式为a b c * + d e / - 策略是：遇到运算数：存储起来 遇到运算符号：将最近存储的两个数进行运算，然后再把运算结果存储回去。 这显然就是后进先出的堆栈模型。 利用堆栈，具体例子：6 2 / 3 - 4 2 * + 遇到6 存储 遇到2 存储 遇到除号，将前边两位取出，进行前边除以后边
栈实现表达式计算
jdbfvhxx的博客
07-28 1071
package com.pro.stack; public class CalculatorTest { public static void main(String[] args) { String expression = "7*2*2-5+1-5+3-4"; // 创建两个栈,数栈,一个符号栈 CalculatorStack numStack = new Calculat...
栈（后缀表达式的计算）
waldeinNJU的博客
09-12 2317
后缀表达式简单后缀表达式的计算后缀表达式的计算（完全） 简单后缀表达式的计算 就我个人来说，后缀表达式看起来很别扭，但是从变成来看，后缀表达式的处理比中缀表达式的处理方便很多。 中缀表达式：( 30 + 4 ) x 5 - 6 = 164 后缀表达式：30 4 + 5 x 6 - = 164 对于中缀表达式而言，一般需要两个栈：数栈和符号栈，并且处理过程中需要注意括号运算。就上面的中缀表达式来看，先计算括号里的+，再计算x，最后计算 - 。但是，就后缀表达式来看，表达式中的运算符号出现顺序与中缀表达式对应的
C语言堆栈实现算术表达式求值
总结来说，本文主要涉及C语言中的堆栈数据结构应用、表达式转换、后缀表达式的优点以及如何实现一个能够处理实数运算的表达式求值函数。通过理解并实现这些核心功能，可以更好地理解和使用C语言处理数学表达式。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值