数据结构（二）——栈和队列之表达式求解

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

题目描述：给定一个表达式，先求其后缀式，然后根据后缀式求表达式的值（测试用例 中，操作数的个数大于5）。

本题可以运用数据结构中的栈进行求解，其中有三个比较关键的步骤

一、如何将输入的字符数据中的两位即两位以上的数据转化成int型进行计算。
二、如何将表达式转化成逆波兰符号式并计算

这里，我先给出我的栈的结构体定义

typedef struct stack
{
    char sign[MAX][2];//存储数据的数组,一列为数据域，一列为符号域。
    //符号域中，0表示该数据域存储的为数字，1表示为'-'或'+'，2表示为'*'或'/'，3表示为'(',4表示为')',-1'#'
    int num[MAX];
    int size;//栈顶指针
}stack,*pstack;//定义栈的结构体

在稍后的处理中，我会用到两个栈，一个用来存储数据，一个用来存储运算符。

一、如何将输入的字符数据中的两位及两位以上的数据转化成int型进行计算。
1.首先我们要做的是将操作数和计算符分别识别，若是计算符，我们便将其存入存储运算符的栈中；若不是计算符，我们则将其进行转化为int型，并扫描下一个数据。
2.若下一个数据依旧是操作数，则将上一个操作数e1 * 10，并加上这个操作数，得到一个int型的参数，再继续扫描下一个数据。
3.直到下一个数据为计算符时，将int型参数e1存入操作数栈中。
在一边执行存入数据操作同时，也一边对数据进行着计算。放上代码

void renewdata_and_calculate(pstack stnum,pstack stsign,char b[MAX])
{
    int j,k=0;
    int e1=0;
    stsign->sign[stsign->size][0]='#';
    stsign->size++;
    for(j=0;b[j]!='#';j++)//判断b数组是否遍历完整
    {
        while(b[j]!='+'&&b[j]!='-'&&b[j]!='*'&&b[j]!='/'&&b[j]!='('&&b[j]!=')'&&b[j]!='#')//排除b[j]是运算符的可能
        {
            if((b[j]-'0')==0)//判断b[j]是否是0这个特殊数
            {
                e1=e1*10+b[j]-'0';//计算e1
                k++;//标记e1为特殊数0
            }
            else
            {
                e1=e1*10+b[j]-'0';//当e1不为0时，计算e1的数据
            }
            j++;//推动b数组遍历
        }
        if(e1!=0||k!=0)//判断是否是数字
        {
            Pushnum(stnum,e1);//存储数字
            printf("%d ",e1);
            if(b[j]!='#')
            {
                Pushsign(stsign,b[j]);//存储运算符
                Calculate(stnum,stsign);
            }
            else
            {
                Pushsign(stsign,b[j]);//存储运算符
                Calculate(stnum,stsign);
                j--;
            }
            k=0;//重新初始化标记数
            e1=0;//重新初始化计算的数据
        }
        else
        {
            Pushsign(stsign,b[j]);//存储运算符
            Calculate(stnum,stsign);
        }
    }
}

二、如何将表达式转化成逆波兰符号式
在存储计算符的时候，我们要考虑如何让计算机按照加减乘除的计算法进行计算。这里，我是运用了赋予计算符优先级，结合栈的数据结构进行操作
1.设立两个栈，一个用来存储操作数，一个用来存储计算符
2.给每个会出现的计算符赋优先级。符号域中，0表示该数据域存储的为数字，1表示为’-‘或’+’，2表示为’*‘或’/’，3表示为’(’,4表示为’)’,-1’#’。
3.当栈中数据，若将要进入栈中的运算符的优先级大于栈顶元素，则将计算符入栈（个别特俗运算符除外，如‘)’和‘#’）；否则，则将栈顶元素出栈，并依次取出存储操作数栈的栈顶元素两个，进行计算，得到的操作数存入存储操作数的栈中。直到读到‘#’符号，则将两个栈中的元素全部依次进行运算，以一个计算符，对应两个操作数的方式，进行运算，直到只剩一个操作数，并输出结果。

void Calculate(pstack stnum,pstack stsign)
{
    int n1;
    int i,j;
    char e1,e2;//用于暂时的存储数据
    if(stsign->sign[stsign->size-1][0]==')')//如果为）则将数据将到（全部出栈入队
    {
        Popsign(stsign);
        while(stsign->sign[stsign->size-1][0]!='(')
        {
            e1=Popsign(stsign);
            printf("%c ",e1);
            n1=Calculate2(stnum,e1);
            Pushnum(stnum,n1);
        }
        Popsign(stsign);
    }
    else if(stsign->sign[stsign->size-1][0]=='#')//如果为#则将栈内数据全部出栈
    {
        Popsign(stsign);
        while(stsign->sign[stsign->size-1][0]!='#')
        {
            e1=Popsign(stsign);
            printf("%c ",e1);
            n1=Calculate2(stnum,e1);
            Pushnum(stnum,n1);
            e1='\0';
        }
        printf("\n");
        printf("the result is %d",n1);
    }
    else
    {
        while((stsign->sign[stsign->size-1][1])<=(stsign->sign[stsign->size-2][1])&&(stsign->sign[stsign->size-2][0]!='(')&&stsign->sign[stsign->size-2][0]!='#')//如果为正常运算符则进行优先级的比较，若下一个符号为（则直接存入
        {
            e1=Popsign(stsign);//刚刚进入栈的数据
            e2=Popsign(stsign);//将要存入后序序列的数据
            printf("%c ",e2);
            n1=Calculate2(stnum,e2);
            Pushnum(stnum,n1);
            Pushsign(stsign,e1);//将入栈数据存入栈内
            e1='\0';
            e2='\0';
        }
    }
}

三、最后就是整个程序的源代码了：
里面有很多关于栈的基本操作，在实际操作中没有用到，当时只是当作复习就敲出来。故到时阅读代码时发现有些自定义函数没用到就不必奇怪了。

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

#define MAX 1000

typedef struct stack
{
    char sign[MAX][2];//存储数据的数组,一列为数据域，一列为符号域。
    //符号域中，0表示该数据域存储的为数字，1表示为'-'或'+'，2表示为'*'或'/'，3表示为'(',4表示为')',-1'#'
    int num[MAX];
    int size;//栈顶指针
}stack,*pstack;//定义栈的结构体

pstack CreateStack();//创建栈
void DestroyStack(pstack st);//摧毁栈
void ClearStack(pstack st);//清空栈
int EmptyStack(pstack st);//判栈空
int LengthStack(pstack st);//判栈长
char GetTopsign(pstack st);//取栈顶元素
int GetTopnum(pstack st);//取栈顶元素
void Pushsign(pstack st,char d);//入栈
void Pushnum(pstack st,int d);//入栈
char Popsign(pstack st);//出栈
int Popnum(pstack st);//出栈a
void StackTravers(pstack st);//遍历栈
void renewdata_and_calculate(pstack stnum,pstack stsign,char b[MAX]);//将数据处理后再存储
void Calculate(pstack stnum,pstack stsign);//将表达式转化为逆波兰符号
int Calculate2(pstack stnum,char a);//计算表达式的值

int main()
{
    char a[MAX]={'/0'};
    pstack stnum;
    pstack stsign;
    stnum=CreateStack();
    stsign=CreateStack();
    ClearStack(stnum);
    ClearStack(stsign);
    printf("Please input the math expression and end it with '#' :\n");
    printf("Example: 3+2*(30+3)#\n");
    printf("if you want to use '(' and ')',please use them in English sign;\n");
    gets(a);
    renewdata_and_calculate(stnum,stsign,a);
    return 0;
}
pstack CreateStack()
{
    pstack st;//定义一个栈
    st=(pstack)malloc(sizeof(stack));//申请空间
    if(st)
    {
        memset(st->sign,0,sizeof(st->sign));
        memset(st->num,0,sizeof(st->num));
        return st;//返回数组的地址
    }
    else//申请空间失败
    {
        printf("Fall to apply space!\n");
        return NULL;
    }
}

void DestroyStack(pstack st)
{
    free(st->sign);//释放栈的空间
    free(st->num);
    st->size=0;//将栈的大小置为0
    st=NULL;//将栈指向NULL
    printf("Destorying stack success!\n");
}

void ClearStack(pstack st)
{
    memset(st->sign,0,sizeof(st->sign));//清空数组
    memset(st->num,0,sizeof(st->num));
    st->size=0;//将数组大小赋值为0
}

int EmptyStack(pstack st)
{
    if(st->size==0)
    {
        return 0;//栈为空
    }
    else
    {
        return 1;//栈不空
    }
}

int LengthStack(pstack st)
{
    return st->size;//返回栈长
}

char GetTopsign(pstack st)
{
    char e;
    e=st->sign[st->size-1][0];
    return e;//返回栈顶元素
}

int GetTopnum(pstack st)
{
    int e;
    e=st->num[st->size-1];
}
void Pushsign(pstack st,char d)
{
    st->sign[st->size][0]=d;//入栈
    if(d=='#')
    {
        st->sign[st->size][1]='-1';
    }
    else if(d=='+'||d=='-')
    {
        st->sign[st->size][1]='1';
    }
    else if(d=='*'||d=='/')
    {
        st->sign[st->size][1]='2';
    }
    else if(d=='(')
    {
        st->sign[st->size][1]='3';
    }
    else if(d==')')
    {
        st->sign[st->size][1]='4';
    }
    else
    {
        st->sign[st->size][1]='0';
    }
    st->size++;//栈顶指针加1
}

void Pushnum(pstack st,int d)//入栈
{
    st->num[st->size]=d;
    st->size++;
}
char Popsign(pstack st)
{
    char e;
    e=st->sign[st->size-1][0];//弹出
    st->sign[st->size-1][0]='\0';
    st->size--;//栈的大小减一
    return e;//返回弹出的元素
}

int Popnum(pstack st)
{
    int e;
    e=st->num[st->size-1];
    st->num[st->size-1]=0;
    st->size--;
    return e;
}

void StackTravers(pstack st)
{
    int i;
    for(i=0;i<st->size;i++)//遍历打印
    {
        printf("%d.%c ",i,st->sign[i][0]);
        printf("%d.%d ",i,st->num[i]);
    }
}

void renewdata_and_calculate(pstack stnum,pstack stsign,char b[MAX])
{
    int j,k=0;
    int e1=0;
    stsign->sign[stsign->size][0]='#';
    stsign->size++;
    for(j=0;b[j]!='#';j++)//判断b数组是否遍历完整
    {
        while(b[j]!='+'&&b[j]!='-'&&b[j]!='*'&&b[j]!='/'&&b[j]!='('&&b[j]!=')'&&b[j]!='#')//排除b[j]是运算符的可能
        {
            if((b[j]-'0')==0)//判断b[j]是否是0这个特殊数
            {
                e1=e1*10+b[j]-'0';//计算e1
                k++;//标记e1为特殊数0
            }
            else
            {
                e1=e1*10+b[j]-'0';//当e1不为0时，计算e1的数据
            }
            j++;//推动b数组遍历
        }
        if(e1!=0||k!=0)//判断是否是数字
        {
            Pushnum(stnum,e1);//存储数字
            printf("%d ",e1);
            if(b[j]!='#')
            {
                Pushsign(stsign,b[j]);//存储运算符
                Calculate(stnum,stsign);
            }
            else
            {
                Pushsign(stsign,b[j]);//存储运算符
                Calculate(stnum,stsign);
                j--;
            }
            k=0;//重新初始化标记数
            e1=0;//重新初始化计算的数据
        }
        else
        {
            Pushsign(stsign,b[j]);//存储运算符
            Calculate(stnum,stsign);
        }
    }
}

void Calculate(pstack stnum,pstack stsign)
{
    int n1;
    int i,j;
    char e1,e2;//用于暂时的存储数据
    if(stsign->sign[stsign->size-1][0]==')')//如果为）则将数据将到（全部出栈入队
    {
        Popsign(stsign);
        while(stsign->sign[stsign->size-1][0]!='(')
        {
            e1=Popsign(stsign);
            printf("%c ",e1);
            n1=Calculate2(stnum,e1);
            Pushnum(stnum,n1);
        }
        Popsign(stsign);
    }
    else if(stsign->sign[stsign->size-1][0]=='#')//如果为#则将栈内数据全部出栈
    {
        Popsign(stsign);
        while(stsign->sign[stsign->size-1][0]!='#')
        {
            e1=Popsign(stsign);
            printf("%c ",e1);
            n1=Calculate2(stnum,e1);
            Pushnum(stnum,n1);
            e1='\0';
        }
        printf("\n");
        printf("the result is %d",n1);
    }
    else
    {
        while((stsign->sign[stsign->size-1][1])<=(stsign->sign[stsign->size-2][1])&&(stsign->sign[stsign->size-2][0]!='(')&&stsign->sign[stsign->size-2][0]!='#')//如果为正常运算符则进行优先级的比较，若下一个符号为（则直接存入
        {
            e1=Popsign(stsign);//刚刚进入栈的数据
            e2=Popsign(stsign);//将要存入后序序列的数据
            printf("%c ",e2);
            n1=Calculate2(stnum,e2);
            Pushnum(stnum,n1);
            Pushsign(stsign,e1);//将入栈数据存入栈内
            e1='\0';
            e2='\0';
        }
    }
}

int Calculate2(pstack stnum,char a)
{
    char op;
    int num1,num2,num3;
    num2=Popnum(stnum);//出栈计算时的后一个元素
    num1=Popnum(stnum);//出栈计算时的前一个元素
    op=a;//选择计算方式
    switch(op)
    {
    case '+':
        num3=num1+num2;
        break;
    case '-':
        num3=num1-num2;
        break;
    case '*':
        num3=num1*num2;
        break;
    case '/':
        num3=num1/num2;
        break;
    default:
        break;
    }
    return num3;
}
Double___H
关注
专栏目录
利用栈和队列进行表达式求值
Sunye_bunny的博客
04-15 1621
利用栈和队列进行表达式求值 一、实验目的 深入了解栈和队列的特性，学会在实际问题下灵活运用它们。 二、问题描述 表达式求值运算是实现程序设计语言的基本问题之一，也是栈应用的一个典型例子。设计并演示用算符优先级对算术表达式的求解过程。 三、实验要求 1、算法优先级别如下： 2、以字符序列的形式从终端输入语法正确、不含变量的算术表达式，利用给出的算符优先级关系，实现对算术四则混合运算的求解过程。 四...
表达式求值(栈和队列)
年轻过成了秃顶
01-04 1475
题目描述 利用栈来实现含有加，减，乘，除等基本运算，输出表达式的值(乘是字母x) 输入 3x(15/5)+8 输出 17 样例输入 Copy 24-[6+(27/3)x2] 样例输出 Copy 0 分析： 此题无疑多加了一个‘[]’。基本思路还是一样的，但是注意，此题的乘是‘X’。而不是’*‘。这是要点。基本思路还是逆波兰。` #include"stdio.h" #include"string....
数据结构-栈与队列--计算表达式
一棵灬大树的博客
10-21 306
问题分析 上一节我们已经知道该如何将中缀表达式转为后缀表达式（传送门），这里我们将直接将实际计算一个表达式，比如99+87×9899+87\times9899+87×98#，要求表达式结尾以’#‘结束； 实现方法 得到后缀表达式 这里我们用队列存储后缀表达式结果； 另一方面值得注意的是这里的操作数是不知几位的数字，在转后缀的要值得注意（小树我自己踩过的坑 ），解决方法是在遇到操作符前将操作数的每一位存储在一个字符串中，在遇到操作符时，将其存储在队列中，然后将字符串清空，存储下个操作数。具体代码如下：
栈实现运算表达式的求解
大草的博客
02-02 5205
一、题目  用栈实现运算表达式的求解。方法：通常称为“算符优先法”。  输入：（5+3*（4+1））/5#          //注：默认输入正确，多个回车都不行，回车也是字符，括号用英文输入  输出：4 二、题目分析  任何一个表达式，都有操作数，运算符，界限符组成。操作数一般为常量。运算符可以分为算术运算符，关系运算符和逻辑运算符。基本界限符有左右括号和表达式结束符组成。这里为了
数据结构----栈的应用（表达式求值）
m0_63160992的博客
05-10 494
老师的代码 #include <iostream> #include <cstring> #include <algorithm> #include <stack> #include <unordered_map> using namespace std; stack<int> num; stack<char> op; void eval() { auto b = num.top(); num.po
数据结构---栈的表达式求解
weixin_52715409的博客
10-06 206
#include<iostream> using namespace std; #define MAXSIZE 100 typedef struct { char *base; char *top; int size; }Stack; typedef struct { int *base; int *top; int size; }Stack1; bool creatStack(Stack &S) { S.base=new char[MAXSIZE]; if(!S.
数据结构——栈和队列
XSES_yasuoman的博客
08-18 332
考研数据结构——栈和队列
数据结构考试知识点总结——栈和队列
木子 旭的博客
01-08 1461
学会求不可能的的出栈序列。 设计一个判断表达式中左，右括号是否配对出现的算法，采用栈最佳。 用链接方式存储的队列，再进行删除运算时，头尾指针可能都要修改。 递归过程或函数调用时，处理参数及返回地址，要用栈。 将递归算法转换成对应的非递归算法时，通常需要栈来保存中间结果。 假设数组A[m]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素个数为**(rear-front+m)%m** 栈和队列共同点是只允许在端点处插入和删除元素。 栈和队列的主要区别是限定插入和删除的位置不同。 栈.
数据结构——栈：栈的应用：表达式求值
sunshare77的博客
06-12 2882
前缀表达式的计算机求值从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果例如:- × + 3 4 5 61. 从右至左扫描，将6、5、4、3压入堆栈2. 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较）...
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
最新发布
06-09
- **图的邻接矩阵和邻接表存储**：`Project8.1`部分详细解释了图的两种常见存储结构——邻接矩阵和邻接表，并比较了它们各自的优缺点。 - **图的 DFS 和 BFS 遍历算法设计**：`Project8.2`部分介绍了图的深度优先...
2数据结构实验报告二(栈和队列及其应用).docx
07-12
本实验报告主要关注两种基本的数据结构——栈和队列，以及它们在解决实际问题，如迷宫求解中的应用。 栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构。它遵循“先进后出”的原则，类似于日常生活...
利用栈进行表达式求解
all00747的博客
09-19 232
以前A掉的表达式求解统统是递归= =，栈一直不知道怎么搞，今天稍微看了看，写了一个较简单的。 对于一个合法的表达式，只要知道运算符的优先级即可利用栈求解，貌似是将中缀表达式转化为了后缀表达式，这些个名词咳咳= = 顾名思义后缀表达式就是运算符写在后面嘛，对于a+b就是ab+ ,我们就知道要计算ab的和，对于一些更复杂状态的式子，显然需要一些技巧。 先...
【数据结构】（三）栈堆的应用（表达式求解）
qq_51523386的博客
04-01 184
【数据结构】（三）顺序表习题（表达式求解） （1）预习作业： 查表：
算数表达式求解（栈）
m0_52192682的博客
09-23 360
题目： 我们需要使用C语言的栈思想去实现简易四则运算表达式 样例： 输入：3+4*5/5 输出结果：7 实现思路： 我们需要设置两个栈，一个用来存储数字，一个用来存储符号，遇见数字压入数字栈，遇见符号就比较于符号栈栈顶符号的优先级（初始符号栈中栈顶元素是‘#’，我们设定‘#’的优先级最低），若优先级大于符号栈栈顶的符号就压入符号栈中，若优先级小于或者等于符号栈栈顶的符号就取数字栈中的两个元素使用符号栈栈顶的符号进行计算，并将计算结果再次存入数字栈中 注意的点： 我们用户在输入算式的时候不可能在式子最后再加上
数据结构之栈与队列数学表达式的求值
biqigu的博客
09-09 1997
数学表达式的计算     课本上使用c去实现个位数字的加减乘除，于是我将它扩展到了浮点数的四则运算   用了逆波兰表达式，具体怎么算还是百度一下吧，我的表达能力肯定不如百度啦   另外我终于去学习了一下搁置已久的正则表达式，这个东西真的很好用，不会的同学去学习一下吧，给俩中文的msdn链接：   https://msdn.microsoft.com/zh-cn/librar
用栈实现后缀表达式求解问题
xxpresent的博客
11-29 3992
一、问题概述： 人们经常书写的数学表达式属于中缀表达式，今天要解决的是，后缀表达式的求解问题。 如下图分别为举例的中缀表达式和后缀表达式： 二、解决思路 我们用栈存储后缀表达式中的数据部分，当遇到操作符时就取出栈中的栈顶两个元素，检测操作符的类型，并进行相应的计算（这里要注意的是，对于除法运算，栈顶的两个元素的位置得区分）。 如下所示： 三、实现代码
数据结构入门——栈与队列（2）一般算术表达式转换成后缀式
euitbly的博客
03-16 147
栈与队列一：一般算术表达式转换成后缀式 题目描述： Problem Description 对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。 Input 输入一个算术表达式，以‘#’字符作为结束标志。 Output 输出该表达式转换所得到的后缀式。 Sample Input a*b+(c-d/e)*f# Sample Output abcde/-f+ Hint...
数据结构实验——就餐人数最多的时间段
Double___H的博客
08-01 3503
题目描述 学校要举办校庆晚宴，要求学生登记就餐时间，以确定在哪个时间段内就餐的学生数最多，从而调食品的供应量。就餐时间被分为了 N 个时间段，其中 N 可能会非常大，可以假 设 N 为 1 亿，也就是 100000000（这要求程序不能声明长度为 N 的数组或定义 N 个变量）， 若未考虑此情况则不能得分。 要求：排序算法的平均时间复杂度不得大于 O(MlogM)。 先输入两个数字 N，M，表示就...
栈和队列数据结构：链队列的入队操作解析
"链队列的插入入队-数据结构（清华大学版）——栈和队列" 在数据结构中，栈和队列是非常基础且重要的数据结构。本节内容主要涉及链队列的插入操作，以及栈和队列的基本概念、存储结构和操作。 链队列是一种特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值