使用栈实现表达式求值

最新推荐文章于 2024-08-10 16:43:58 发布
最新推荐文章于 2024-08-10 16:43:58 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 栈 文章标签： 使用栈实现表达式求值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42211587/article/details/90731519
版权

/*
    使用栈实现表达式求值
*/

#include <iostream>
#include <string>
#include <cmath>
using namespace std;

#define MAX_SIZE 7
#define MAX  1000

char rule[][7]={
                {'>', '>', '<', '<', '<', '>', '>'},
                {'>', '>', '<', '<', '<', '>', '>'},
                {'>', '>', '>', '>', '<', '>', '>'},
                {'>', '>', '>', '>', '<', '>', '>'},
                {'<', '<', '<', '<', '<', '=', '0'},
                {'>', '>', '>', '>', '0', '>', '>'},
                {'<', '<', '<', '<', '<', '0', '='}
};
char c_data[] = {'+','-','*','/','(',')','#'};

typedef struct node_pn{
    double value;
    struct node_pn* pNext;
}NODEPN;
typedef struct pn{
    int pnCount ;
    NODEPN* pnTop;
}STACKPN;

typedef struct node_pd{
    char value;
    struct node_pd* pNext;
}NODEPD;
typedef struct pd{
    int pdCount;
    NODEPD* pdTop;
}STACKPD;

void InitStackPD(STACKPD* &ptr_pd)
{
    ptr_pd = new STACKPD;
    ptr_pd->pdTop = NULL;
    ptr_pd->pdCount = 0;
}
void push_pd(STACKPD* &stackpd,NODEPD* ptr_pd)
{
    if(ptr_pd == NULL)  return ;
    if(stackpd->pdTop != NULL){
        ptr_pd->pNext = stackpd->pdTop;
    }
    stackpd->pdTop = ptr_pd;
    stackpd->pdCount++;
}
void top_pd(STACKPD* stackpd,NODEPD* &ptr_pd)
{
    if(stackpd== NULL || stackpd->pdTop == NULL) return ;
    ptr_pd = stackpd->pdTop;
}
void pop_pd(STACKPD* &stackpd)
{
    if(stackpd == NULL || stackpd->pdTop == NULL)  return ;
    NODEPD *ptr_pd = stackpd->pdTop;
    stackpd->pdTop = ptr_pd->pNext;
    stackpd->pdCount--;
    delete ptr_pd;
    ptr_pd = NULL;

}

void InitStackPN(STACKPN* &ptr_pn)
{
    ptr_pn = new STACKPN;
    ptr_pn->pnTop = NULL;
    ptr_pn->pnCount = 0;
}
void push_pn(STACKPN* &stackpn,NODEPN* ptr_pn)
{
    if(ptr_pn == NULL)  return ;
    if(stackpn->pnTop != NULL){
        ptr_pn->pNext = stackpn->pnTop;
    }
    stackpn->pnTop = ptr_pn;
    stackpn->pnCount++;
}
void top_pn(STACKPN* stackpn,NODEPN* &ptr_pn)
{
    if(stackpn== NULL || stackpn->pnTop == NULL) return ;
    ptr_pn = stackpn->pnTop;
}
void pop_pn(STACKPN* &stackpn)
{
    if(stackpn == NULL || stackpn->pnTop == NULL)  return ;
    NODEPN *ptr_pn = stackpn->pnTop;
    stackpn->pnTop = ptr_pn->pNext;
    stackpn->pnCount--;
    delete ptr_pn;
    ptr_pn = NULL;
}

int Find_Location(char c,char a[])
{
    for(int i=0;i<MAX_SIZE;i++){
        if(c == a[i]){
            return i;
        }
    }
    return -1;
}
char GetRel(char c_a,char c_b,char a[], char rule[][MAX_SIZE])
{
    if( Find_Location(c_a,a) == -1 || Find_Location(c_b,a) == -1)  return ' ';
    return rule[Find_Location(c_a,a)][Find_Location(c_b,a)];
}
void Deal(double a,char c,double b,double &Result)
{
    switch (c)
    {
        case '+':
            Result = a+b;
            break;
        case '-':
            Result = a-b;
            break;
        case '*':
            Result = a*b;
            break;
        case '/':
            Result = a/b;
            break;
        case '^':
            Result = pow(a,b);
            break;
        default:
            break;
    }
}

void GetResult(char str[],int length,double &Result)
{
    Result = 0;
    if( str == NULL || length<=0)  return ;
    STACKPD* stackpd = NULL;
    STACKPN* stackpn = NULL;
    NODEPN* value_b = NULL;
    NODEPN* value_a = NULL;
    NODEPD* value_c = NULL;
    NODEPN* insertnodepn = NULL;
    NODEPD *insertnodepd = NULL;
    InitStackPD(stackpd);
    InitStackPN(stackpn);
    int i=0;
    int sum ;
    int j;
    int k;
    double b;
    double a;
    char c;
    while(i<length){
        /*当是字符数字的时候 经过求值处理后直接进入栈中*/
        if(str[i]<='9' && str[i]>='0'){
            k=i;
            sum =0;
            j=0;
            /*处理含有小数的情况*/
            while(k<length && str[k]<='9' && str[k]>='0'){
                sum = sum*10+(str[k]-'0');
                if(str[k+1] == '.'){
                    j = k+1;
                    k += 2;
                }
                else{
                    k++;
                }
            }
            i=k;
            insertnodepn = new NODEPN;
            if(j!=0){
                insertnodepn->value = (double)(sum/(pow(10,k-j-1)));
            }else{
                insertnodepn->value = (double)(sum);
            }
            insertnodepn->pNext = NULL;
            push_pn(stackpn,insertnodepn);
        }
        else{
            /*判定算符的栈是否为空
                空的时候 直接将相应的算符入栈  
                不空的时候 
                    1：比较栈顶的元素与当前算符的优先级关系 当栈顶元素优先级<新的算符的时候  将新的算符直接入栈
                    2：当栈顶算符的优先级>新的算符的优先级的时候 取出相应的两个算数进行计算 讲结果入栈 同时需要判刑新的元素核心的栈顶的算符的优先级关系 并进行相应的处理
            */
            if(stackpd->pdTop){
                NODEPD* stackpdtop = NULL;
                top_pd(stackpd,stackpdtop);
                char c_rule = GetRel(stackpdtop->value,str[i],c_data,rule);
                if(c_rule != ' '){
                    switch(c_rule){
                        case '>':
                            top_pn(stackpn,value_b);
                            b = value_b->value;
                            pop_pn(stackpn);
    
                            top_pn(stackpn,value_a);
                            a = value_a->value;
                            pop_pn(stackpn);
    
                            top_pd(stackpd,value_c);
                            c = value_c->value;
                            pop_pd(stackpd);
                            Deal(a,c,b,Result);

                            insertnodepn = new NODEPN;
                            insertnodepn->value = Result;
                            insertnodepn->pNext = NULL;
                            push_pn(stackpn,insertnodepn);

                            if( stackpd->pdCount > 0 ){
                                top_pd(stackpd,value_c);
                                c = value_c->value;
                                int flag =0;
                                c_rule = GetRel(c,str[i],c_data,rule);
                                switch(c_rule){
                                case '>':
                                    top_pn(stackpn,value_b);
                                    b = value_b->value;
                                    pop_pn(stackpn);
    
                                    top_pn(stackpn,value_a);
                                    a = value_a->value;
                                    pop_pn(stackpn);
    
                                    top_pd(stackpd,value_c);
                                    c = value_c->value;
                                    pop_pd(stackpd);
                                    Deal(a,c,b,Result);
        
                                    insertnodepn = new NODEPN;
                                    insertnodepn->value = Result;
                                    insertnodepn->pNext = NULL;
                                    push_pn(stackpn,insertnodepn);

                                    insertnodepd = new NODEPD;
                                    insertnodepd->value = str[i];
                                    insertnodepd->pNext = NULL;
                                    push_pd(stackpd,insertnodepd);

                                    break;
                                case '<':
                                    flag = 1;
                                    insertnodepd = new NODEPD;
                                    insertnodepd->value = str[i];
                                    insertnodepd->pNext = NULL;
                                    push_pd(stackpd,insertnodepd);
                                    break;
                                case '=':
                                    pop_pd(stackpd);
                                    break;
                                }
                                if(flag == 1){
                                    break;
                                }
                            }
                            else{
                                insertnodepd = new NODEPD;
                                insertnodepd->value = str[i];
                                insertnodepd->pNext = NULL;
                                push_pd(stackpd,insertnodepd);
                            }
                            break;
                        case '<':
                            insertnodepd = new NODEPD;
                            insertnodepd->value = str[i];
                            insertnodepd->pNext = NULL;
                            push_pd(stackpd,insertnodepd);
                            break;
                        case '=':
                            pop_pd(stackpd);
                            break;
                    }
                }
            }
            else{
                insertnodepd = new NODEPD;
                insertnodepd->value = str[i];
                insertnodepd->pNext = NULL;
                push_pd(stackpd,insertnodepd);
            }
            i++;
        }
    }
    top_pn(stackpn,value_b);
    b = value_b->value;
    pop_pn(stackpn);
    
    top_pn(stackpn,value_a);
    a = value_a->value;
    pop_pn(stackpn);
    
    top_pd(stackpd,value_c);
    c = value_c->value;
    pop_pd(stackpd);
    Deal(a,c,b,Result);
}

int main()
{
    char str[100]={0};
    cin>>str;
    double Result;
    GetResult(str,strlen(str),Result);
    cout<<Result<<endl;
    system("pause");
    return 0;
}

抱着键盘入土
关注
专栏目录
表达式求值（采用栈实现）
10-15
利用栈实现算术表达式的求值，表达式中可包含加+、减（负） -、乘*、除/、 乘方^、括号( )运算符，操作数可以为浮点数。 可采用直接求中缀表达式的方法， 也可采用先转换成后缀表达式后再求值的方法（参看课件） 。 实现时需注意如下： （ 1）带小数点的数值生成 （ 理解整数数值的生成，小数部分的处理与之类似）。 （ 2）考虑负号的情况。负号与减号形式上一样，如何区分？ • 输入的表达式串中第 1 个字符是’-’ – 可断定此’-’是负号 • 其余的’-’ – 若紧接在’(’之后的’-’可断定是负号 （ 3）负号的处理 • 方法 1：若已断定是负号，可先压入数值 0 进入操作数栈，如此，可 将负号看作减号。 • 方法 2： 若已断定是负号，则紧接其后的数字字符转换成数值后，要 将其对应的相反数(负数)压入操作数栈
C语言数据结构用栈实现表达式求值
10-26
C语言数据结构用栈实现表达式求值，全部工程代码。实现visual2010下运行
【数据结构】用栈解决表达式求值问题
weixin_33713707的博客
09-28 193
题目：求4+4/2-9*3的值； 思路： 　　①：用一个字符型数组存放了表达式《4+4/2-9*3》； 1 char val[9] = {'4','+','4','/','2','-','9','*','3'}; 　　②：定义两个栈，一个存放数字，一个存放符号； 1 //定义存储整型的栈 2 typedef struct node 3 { 4 int d...
【数据结构与算法】栈的应用——表达式求值
最新发布
qq_74047911的博客
08-10 1308
我想了一下,我主要写博客的目标还是说为了自己,自己容易忘记,相当于自己来过一遍,所以这是写给我自己的,当然如果你也遇到了相同的问题,那么不防我们可以一起探讨一下.
表达式求值——栈实现
jasonLee的博客
10-27 1294
要点总结 分成两个栈，一个操作数栈，一个运算符栈 judge（c）：判断读入的字符是操作数还是运算符，便于压栈 precede（a,b）：判断读入的运算符和运算符栈的栈顶元素的优先级大小；如果大于栈顶元素的优先级，则将它压栈；否则，就把栈顶元素弹出来，再把操作数栈中的两个操作数弹出来，与该运算符做相应的运算。 Operate（）:上文提到的，进行相应的运算的函数实现
栈实现表达式求值（C语言）
热门推荐
2Know的博客
10-28 1万+
刚刚学习C语言的时候很多人就写过计算器，但是当时写的计算器只能进行一步四则运算；对于一次输入(1+2)*3+4这样的运算则没有办法计算。 本篇博文利用栈这种数据结构实现了支持带括号的表达式求值计算器；栈有栈底和栈顶指针，元素是先进后出；对于栈的操作最主要的是创建、压栈、弹栈；在实现计算器时，我们输入的表达式叫做中缀表达式，我们需要将其转为后缀表达式；然后利用后缀表达式求取表达式的值；
C++用栈实现表达式求值
04-15
C++用栈实现表达式求值，经过验收的，可以运行，没有问题
数据结构课程设计-用栈实现表达式求值的方法详解
01-01
利用算符优先关系，实现对算术四则混合运算表达式的求值。（1）输入的形式：表达式，例如2*(3+4) 包含的运算符只能有’+’ 、’-‘ 、’*’ 、’/’ 、'(‘、 ‘)’；（2）输出的形式：运算结果，例如2*(3+4)=14；...
表达式求值(C语言栈实现)
11-07
表达式求值(C语言栈实现).已测试，没有任何错误和警告
栈表达式求值程序
iu_81的专栏
03-22 2159
#include #include #include #include typedef int Status;#define STACK_INIT_SIZE 100  //初始分配量#define STACKINCREMENT 10    //存储空间的分配增量typedef char ElemType;     typedef ElemType OperandType;   //操作
栈实现表达式求值
12-27
栈实现表达式求值
栈操作实现表达式求值
mygod2093725_wht的博客
06-05 1016
算法思路：首先应该想怎样将操作数和操作符分开放入两个栈，此时可以用asc码的大小来区分，区分开以后通过fgetc()从文件中读取字符，读取到的字符再通过入栈操作push()入栈。然后再想入栈和出栈的规则，操作数栈需要实现的功能是把每一个遇到的操作数对应的字符串，转化为数值，可以用库函数atof()来实现。而整体的实现需要考虑操作符栈的栈顶元素和即将入栈元素c的优先级，具体算法：1.c&gt;栈顶（...
利用栈对表达式求值
Eric_sun8868的博客
11-03 195
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <scr...
栈 表达式求值
helloworld123000的博客
03-17 83
把运算的处理专门放在一个函数里，然后通过优先级的判断去调用函数，注意那个’（'还是放在else if里面吧，不要和运算混在一起了 #include<bits/stdc++.h> using namespace std; const int N=1e5+10; stack<int> s1; stack<char> s2; int flag=0; //处理+-*/四个 map<char,int> cmp={ {'+',1}, {'-',1} , {'*',
栈的表达式求值
xiaoxiaojinglinger的博客
02-06 274
栈的表达式求值 版权声明：本文为CSDN博主「lijgcn」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/lijgcn/article/details/70166432 #include <stdio.h> #include <stdlib.h> #define OK 2 #...
栈——表达式求值
那些你很冒险的梦
10-15 1016
//题目描述：（表达式求值）输入一行正确的表达式，每个数在1-9之间，且算符只能为“+、-、*、/、(、)”， //表达式以'#'结束，例如“2+3*4-6/3#”或“(3*(4-2)+1)*3+5#”等较简单的表达式。 //顺序栈 #include #include #define STACK_CHAR_SIZE 100 #define STACKINCREMENT 10
栈-表达式求值
辣条不爱辣的博客
10-04 1091
表达式求值是程序设计语言编译中的一个最基本问题。它的实现是栈应用的有一个典型例子。 这里使用算符优先法。 输入:一个表达式. 输出：输出其后缀表达式并且进行表达式的求值。 运行结果： 算法思想： 拿当前扫描的运算符号与上一个比较优先级，当前扫描符号低或相等则进行上一个运算，需取最近的两个数。否则扫下个。 设操作符栈与操作数栈，运算符栈最初压如‘#’，逐个扫描符号。遇操作数则直接入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值