表达式求值

最新推荐文章于 2022-11-09 12:27:03 发布
最新推荐文章于 2022-11-09 12:27:03 发布
阅读量462 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39722329/article/details/78170426
版权

闲着也是闲着继续更新下

表达式是数据运算的基本形式。人们的书写习惯是中缀式，如：11+22*(7-4)/3。中缀式的计算按运算符的优先级及括号优先的原则，相同级别从左到右进行计算。表达式还有后缀式（如：22 7 4 - * 3 / 11 +）和前缀式（如：+ 11 / * 22 – 7 4 3）。后缀表达式和前缀表达式中没有括号，给计算带来方便。如后缀式计算时按运算符出现的先后进行计算。本设计的主要任务是进行表达式形式的转换及不同形式的表达式计算。
基本要求
 从文件或键盘读入中缀表达式。
 设计操作数为多位整数，操作符为加、减、乘、除、求模的中缀表达式求值算法。
 设计将中缀表达式转换为后缀表达式的算法。
 设计将中缀表达式转换为前缀表达式的算法。
 设计后缀表达式求值算法。
 设计前缀表达式求值算法。
 输出各种形式的表达式。

MD这就有点难度了
主要是刚刚学了一些类还处于一脸懵逼的状态中
不过马马虎虎的呃
写了下
代码如下
类的设计

#ifndef CLASS_H_
#define CLASS_H_
#include<iostream>
#include<cctype>

template<typename t>
class Stck
{
private:
    enum{MAX=20};
    t items[MAX];
    int top;
public:
    Stck();
    bool push(const t &item);
    bool pop();
    bool pop1(t &item);
    char gettop();
    double operat(const char s);
    double operat1(const char s);
    void show(int n);
    void showall();
    void showlla();

};
int Judge(char c1,char c2);
int Judge1(char c1,char c2);
int Judge2(char c1,char c2);

template<typename t>
Stck<t>::Stck()
{
    top=0;
}


template<typename t>
bool Stck<t>::push(const t&item)
{
    if(top<MAX)
    {
        items[top]=item;
        top++;
        return true;
    }
    else
        return false;
}

template<typename t>
bool Stck<t>::pop()
{
    if(top>0)
    {
        top--;
        return true;
    }
    else return false;
}
template<typename t>
bool Stck<t>::pop1(t &item)
{
    if(top>0)
    {
        item=items[top-1];
        top--;
        return true;
    }
    return false;
}

template<typename t>
char Stck<t>::gettop()
{
    return items[top-1];
}
template<typename t>
double Stck<t>::operat(const char s)
{
    if(s=='+')
        return items[top-1]+items[top-2];
    if(s=='-')
        return items[top-2]-items[top-1];
    if(s=='*')
        return items[top-1]*items[top-2];
    if(s=='/')
        return items[top-2]/items[top-1];

}
template<typename t>
double Stck<t>::operat1(const char s)
{
    if(s=='+')
        return items[top-1]+items[top-2];
    if(s=='-')
        return items[top-1]-items[top-2];
    if(s=='*')
        return items[top-1]*items[top-2];
    if(s=='/')
        return items[top-1]/items[top-2];

}
template<typename t>
void Stck<t>::show(int n)
{
    std::cout<<items[n];
}
template<typename t>
void Stck<t>::showall()
{
    for(int i=top-1;i;i--)
    {
        if(items[i]!='#')
        std::cout<<items[i]<<" ";

    }
}
template<typename t>
void Stck<t>::showlla()
{
    for(int i=0;i<top;i++)
    {
        if(items[i]!='#')
        {
           if(isdigit(items[i]))
           {int nn=(int)(items[i]-48);
            std::cout<<nn<<" ";

           }
           std::cout<<items[i]<<" ";
        }


    }
}


int Judge(char c1,char c2)
{
    int a1,a2;
    if('+'==c1||'-'==c1)
        a1 = 3;
    if('*'==c1||'/'==c1)
        a1 = 5;
    if('('==c1)
        a1 = 1;
    if(')'==c1)
        a1 = 7;
    if('#'==c1)
        a1 = 0;

    if('+'==c2||'-'==c2)
        a2 = 2;
    if('*'==c2||'/'==c2)
        a2 = 4;
    if('('==c2)
        a2 = 6;
    if(')'==c2)
        a2 = 1;
    if('#'==c2)
        a2 = 0;
    if(a1>a2) return 1;
    if(a1==a2) return 0;
    if(a1<a2) return -1;
}
int Judge1(char c1,char c2)
{
    int a1,a2;
    if('+'==c1||'-'==c1)
        a1 = 3;
    if('*'==c1||'/'==c1)
        a1 = 5;
    if('('==c1)
        a1 = 1;
    if('#'==c1)
        a1 = 0;

    if('+'==c2||'-'==c2)
        a2 = 2;
    if('*'==c2||'/'==c2)
        a2 = 4;
    if(a1>a2) return 1;
    if(a1==a2) return 0;
    if(a1<a2) return -1;
}
int Judge2(char c1,char c2)
{
    int a1,a2;
    if('+'==c1||'-'==c1)
        a1 = 2;
    if('*'==c1||'/'==c1)
        a1 = 5;
    if(')'==c1)
        a1 = 1;
    if('#'==c1)
        a1 = 0;

    if('+'==c2||'-'==c2)
        a2 = 2;
    if('*'==c2||'/'==c2)
        a2 = 4;
    if(a1>a2) return 1;
    if(a1==a2) return -1;
    if(a1<a2) return -1;
}





#endif // CLASS_H_

就是这样蛮繁琐的呃

主函数

#include<iostream>
#include<string>
#include<cctype>
#include<sstream>
#include<math.h>
#include"class.h"
using namespace std;

void zhongzhui()
{
    int n=0,n1,i11,result=0;
    double cal;
    char oprtop,s;
    string l1;
    string l;
    stringstream ss,ss1;
    Stck<char> opr;
    Stck<int> num;
    int i=0,i1=0,aa=0;
    int nu[4]={0};
    cout<<"请输入中缀表达式\n";
    cin>>l;
    int cc=l.size();
    cin.get();
    cout<<"结果为\n";
    string lc="#";
    lc+=l;
    l.append(1,'#');
    opr.push('#');
    while(opr.gettop()!='#'||l[n]!='#')
{
    if(isdigit(l[n]))
      {

          i=0;
          aa=0;
         while(isdigit(l[n]))
         {

              ss<<l[n];
              ss>>nu[i];
              i++;
              n++;
              ss.clear();
         }
         i11=i;
         for(i1=0;i1<i11;i1++)
         {
             aa=pow(10,i1)*nu[i-1]+aa;
             i--;
         }
         num.push(aa);
      }
    else
       {
          oprtop=opr.gettop();
          result=Judge(oprtop,l[n]);
          switch(result)
         {
           case -1:opr.push(l[n]);n++;break;
           case 0:opr.pop();n++;break;
           case 1: cal=num.operat(oprtop);
               num.pop();num.pop();
               opr.pop();
               num.push(cal);break;

         }
       }


}
   num.show(0);
   cout<<"\n";



   cout<<"换为后缀表达式\n";
    Stck<char>s1;
    char item;
    s1.push('#');
    n=0;

    while(l[n]!='#')
{
    if(isdigit(l[n]))
    {

          i=0;
          aa=0;

         while(isdigit(l[n]))
         {

              ss<<l[n];
              ss>>nu[i];
              i++;
              n++;
              ss.clear();
         }
         i11=i;
         for(i1=0;i1<i11;i1++)
         {
             aa=pow(10,i1)*nu[i-1]+aa;
             i--;
         }
         cout<<aa<<" ";
     }
     else
     {
         if(l[n]=='(')
         {
             s1.push('(');
             n++;
         }
         else if(l[n]==')')
         {
             s1.pop1(item);
             while(item!='(')
             {
               cout<<item<<" ";
               s1.pop1(item);
             }
             n++;
         }
         else
         {
            oprtop=s1.gettop();
            result=Judge1(oprtop,l[n]);
            switch(result)
           {
             case -1:s1.push(l[n]);n++;break;
             case 1:s1.pop1(item);cout<<item<<" ";break;
           }
         }

     }

    }
s1.showall();
cout<<endl;

cout<<"转换为前缀表达式\n";
   Stck<char>s4;
   Stck<int>s3;
   string res,res1,res2,res4;
    char item11,oprtop11;
    s4.push('#');
    n=cc;

    while(lc[n]!='#')
{
    if(isdigit(lc[n]))
    {

          i=0;
          aa=0;

         while(isdigit(lc[n]))
         {

              ss<<lc[n];
              ss>>nu[i];
              i++;
              n--;
              ss.clear();
         }
         i11=i;
         for(i1=0;i1<i11;i1++)
         {
             aa=pow(10,i-1)*nu[i-1]+aa;
             i--;
         }
        ss1<<aa;
        ss1>>res1;
        ss1.clear();
         res+=res1;
         res.append(1,' ');
     }
     else
     {
         if(')'==lc[n])
         {
             s4.push(')');
             n--;
         }
         else if(lc[n]=='(')
         {
             s4.pop1(item11);
             while(item11!=')')
             {
               res2=item11;
               res2.append(1,' ');
               res+=res2;

               s4.pop1(item11);
             }
             n--;
         }
         else
         {
            oprtop11=s4.gettop();
            result=Judge2(oprtop11,lc[n]);
            switch(result)
           {
             case -1:s4.push(lc[n]);n--;break;
             case 1:s4.pop1(item11);res4=item11;res+=res4;res.append(1,' '); break;
           }
         }

     }

    }

s4.showlla();
int size1=res.size();
for(int i=size1-2;i+1;i--)
{
    cout<<res[i];
}

cout<<endl;

}

void houzhui()
{
    int n=0,n1,i11,result=0;
    double cal;
    char oprtop,s;
    string l1;
    string l;
    stringstream ss;
    Stck<char> opr;
    Stck<int> num;
    int i=0,i1=0,aa=0;
    int nu[4]={0};

  cout<<"请输入后缀表达式\n";


  getline(cin,l1);

  n=0;
  double result1;
  Stck<double> num1;
  l1.append(1,'#');
  while(l1[n]!='#')
  {
      if(isdigit(l1[n]))
      {

          i=0;
          aa=0;
         while(l1[n]!=' ')
         {

              ss<<l1[n];
              ss>>nu[i];
              i++;
              n++;
              ss.clear();
         }
         i11=i;
         for(i1=0;i1<i11;i1++)
         {
             aa=pow(10,i1)*nu[i-1]+aa;
             i--;
         }
         num1.push(aa);
     }
     else if(l1[n]==' ')
        n++;
     else
     {
         result1=num1.operat(l1[n]);
         num1.pop();
         num1.pop();
         num1.push(result1);
         n++;

     }




  }

cout<<"结果为  ";

num1.show(0);
cout<<endl;

}

void qianzhui()
{
         int n=0,n1,i11,result=0;
    double cal;
    char oprtop,s;
    string l1;
    string l;
    stringstream ss;
    Stck<char> opr;
    Stck<int> num;
    int i=0,i1=0,aa=0;
    int nu[4]={0};


  cout<<"请输入前缀表达式\n";
  getline(cin,l);
  n=l.size();
   l1="#";
    l1+=l;
    double result1;
  Stck<double> num1;

  while(l1[n]!='#')
  {
      if(isdigit(l1[n]))
      {

          i=0;
          aa=0;
         while(l1[n]!=' ')
         {

              ss<<l1[n];
              ss>>nu[i];
              i++;
              n--;
              ss.clear();
         }
         i11=i;
         for(i1=0;i1<i11;i1++)
         {
             aa=pow(10,i1)*nu[i-1]+aa;
             i--;
         }
         num1.push(aa);
     }
     else if(l1[n]==' ')
        n--;
     else
     {
         result1=num1.operat1(l1[n]);
         num1.pop();
         num1.pop();
         num1.push(result1);
         n--;

     }




  }

cout<<"结果为  ";

num1.show(0);
cout<<endl;

}
int main()
{

  zhongzhui();
  houzhui();
  qianzhui();
}

呃 新手毕竟
写了两三天吧
现学现卖
运行下吧

运行结果

银-TaMa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课设——表达式求值（c++）
秋叶依剑
01-08 2312
文章目录中缀表达式转后缀表达式程序源文件Caculate.hCaculate.cppmain.cpp 完成基本功能： （1） 从文件或者键盘读入中缀表达式。 （2） 设计操作数为多位整数，操作符为加、减、乘、除、求模的中缀表达式求值算法 （3） 设计将中缀表达式转换为后缀表达式的算法 （4） 设计将中缀表达式转换为前缀表达式的算法 （5） 设计后缀表达式的求值算法 （6） 设计前缀表达式的求值算...
【PTA】后缀表达式计算
forever_bryant的博客
03-26 2925
【PTA】后缀表达式计算
PTA 7-3 表达式求值_1
ah23333333的博客
11-09 1041
7-3 表达式求值_1 在一个表达式中，只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，请求出表达式的值。(“/”用整数除法)。 输入格式: 共1 行，为一个算式。 （算式长度
PTA 6-12 简单表达式求值(数据结构)
m0_56680402的博客
10-09 1998
本题要求实现两个整数的运算，运算符仅有四种：+、-、* 、/ ，但是以字符串的形式输入表达式。注意这里的除数结果是整数，即5/4=1。 函数接口定义： int cal( char *a ); 其中a是用户传入的参数，此处为表达式，表达式。 裁判测试程序样例： 在这里给出函数被调用进行测试的例子。例如： #include <stdio.h> int cal( char *s ); int main() { char a[100]; int res; s.
表达式求值源码
05-23
表达式求值程序，希望可以给在学习C语言的童鞋们提供一些帮助。
8.表达式求值_python/表达式求值_
09-29
在Python编程语言中，表达式求值是一项基本且重要的任务，它涉及到将字符串形式的数学或逻辑表达式转换为实际的计算结果。本教程将深入探讨如何使用Python来实现表达式求值，特别是通过五行代码的简洁实现，以及相关...
表达式求值1.cpp
09-27
C语言实现双栈应用解决算术表达式求值问题
表达式求值算法-符号优先原则
10-14
采用符号优先法，设立2个栈，一个数据栈，一个符号栈，另外还有列出，符号优先表，采用直接读取数字的方式。
表达式求值计算(java实现)
11-25
对用+、-、*、/、(、）连接起来的算术表达式求值， 可以智能识别和过滤表达式。
数据结构 表达式求值
12-13
描述 利用栈编写表达式求值程序：输入含有“+”、“-”、“*”、“/”四则运算的表达式，其中负数要用（0-正数）表示，并以=结束。要求输出表达式的值（两运算符号的优先关系见教材表3.1）。此题目可选做。 Input 第一行：一个算术表达式 Output 第一行：算术表达式的值 Sample Input 3*(9-7)= Sample Output 6
数据结构课程设计-表达式求值（C语言编写）
02-22
这是数据结构的课程设计。用于求四则运算表达式的值。具有不错的容错能力。就算输入的表达式不合理，也能识别
表达式求值代码
08-30
在编程领域，表达式求值是计算数学或逻辑表达式以获取结果的过程。在这个场景中，我们关注的是如何使用栈数据结构来实现这个功能。栈是一种后进先出（LIFO）的数据结构，非常适合处理括号匹配和运算符优先级问题，这...
3302. 表达式求值 + 栈实现
qq_45638271的博客
08-14 423
给定一个表达式，其中运算符仅包含 +,-,*,/（加 减 乘 整除），可能包含括号，请你求出表达式的最终值。 注意： 数据保证给定的表达式合法。 题目保证符号 - 只作为减号出现，不会作为负号出现，例如，-1+2,(2+2)*(-(1+1)+2) 之类表达式均不会出现。 题目保证表达式中所有数字均为正整数。 题目保证表达式在中间计算过程以及结果中，均不超过 231−1。 题目中的整除是指向 0 取整，也就是说对于大于 0 的结果向下取整，例如 5/3=1，对于小于 0 的结果向上取整，例如 5/(1−4)=
PTA练习题：表达式求值_1
weixin_45735242的博客
05-16 4413
在一个表达式中，只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，请求出表达式的值。(“/”用整数除法)。 输入格式: 共1 行，为一个算式。 （算式长度<=30 其中所有数据在 0~2^31-1的范围内）。 输出格式: 共一行，为表达式的值。 输入样例: 在这里给出一组输入。例如： 1+(3+2)(7^2+69)/(2) 输出样例: 在这里给出相应的输出。例如： 258 import java.util.Scanner; import java.util.Stack; pub
7-21 求前缀表达式的值 (25分)
姚军
12-06 962
题目描述 算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前，例如2+3*(7-4)+8/4的前缀表达式是：+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。 输入格式: 输入在一行内给出不超过30个字符的前缀表达式，只包含+、-、*、/以及运算数，不同对象（运算数、运算符号）之间以空格分隔。 输出格式: 输出前缀表达式的运算...
python 表达式求值
最新发布
09-05
Python表达式求值是指根据给定的Python表达式计算出结果的过程。它涉及解析表达式，按照运算符的优先级和结合性进行计算，并返回最终的结果。 在上述引用中，提到了一种方法来编程演示如何一步一步地计算Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值