精华内容
下载资源
问答
  • (C++)中缀转后缀表达式计算
    2018-08-08 15:54:31

    一、中缀表达式转后缀表达式遵循以下原则:

    1.遇到操作数,直接输出; 
    2.栈为空时,遇到运算符,入栈; 
    3.遇到左括号,将其入栈; 
    4.遇到右括号,执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出; 
    5.遇到其他运算符’+”-”*”/’时,弹出所有优先级大于或等于该运算符的栈顶元素,然后将该运算符入栈; 
    6.最终将栈中的元素依次出栈,输出。 
    经过上面的步骤,得到的输出既是转换得到的后缀表达式。 
    举例:a+b*c+(d*e+f)g ———> abc+de*f+g*+

    二、扫描后缀表达式

    ①如果是数字,则让其进栈 
    ②若为操作符,则从栈中取出两个操作数,先取出的作为右操作数,后取出的作为左操作数,然后进行该操作符的运算,并使其结果入栈。 
    ③重复上述过程,直至表达式扫描完成。 
       最终栈中只留一个元素—–>即就是结果。 

    #include <iostream>
    #include <stack>
    #include <cctype> 
    #include <cmath>
    using namespace std;
    
    void InPut(char*& str)//接收输入的中缀表达式的函数,并简单判断是否合法
    {
        cout << "输入一个中缀表达式:" << endl;
        while (1)
        {
            cin >> str;
    
            if (isdigit(str[0]))//中缀表达式的第一个必定是数字,如果不是,则非法
            {
                break; 
            }
            else
            {
                cout << "INPUT ERROR !!!";
                delete[] str;
            }
        }
    }
    
    int GetPriority(char sy)//设置各个操作符的优先级
    {
        switch (sy)
        {
        case '#':
            return 0;
        case '(':
            return 1;
        case '+':
        case '-':
            return 3;
        case '*':
        case '/':
            return 5;
        case ')':
            return 6;
        default:
            return -1;
        }
    }
    
    
    void AddSpace(char*& arr)    //给转成的后缀表达式的数字和符号添加空格,区分每个字符
    {
        *arr = ' ';
        arr++;
    }
    
    char* GetBack()                   //获取后缀表达式的函数
    {
        char* middle = new char[30];
        char* back = new char[30];
        char* backend = back;
        InPut(middle);
        stack<char> s;
        s.push('#');
        while (*middle)
        {
            if (isdigit(*middle) || *middle == '.')   //如果是数字或者小数的话,直接输出
            {
                *back = *middle;
                back++, middle++;
            }
            else
            {
                if (isdigit(*(back - 1)))//只有他的上一个时数字的话,才继续给空格
                                        //否则遇到多个操作符,则输出域会存在多个空格
                {
                    //*back = ' ';
                    //back++;
                    AddSpace(back);
                }
                if (*middle == ')')    //如果右括号的话,输出所有操作符直到遇到左括号,并抛弃相对应的一堆括号
                {
                    while (s.top() != '(')
                    {
                        *back = s.top();
                        s.pop();
                        back++;
                        AddSpace(back);
                    }
                    middle++;
                    s.pop();//抛弃左括号
                }
                else if (*middle == '(')//遇到左括号,则进入栈
                {
                    s.push(*middle); middle++;
                }
                else if (GetPriority(*middle) > GetPriority(s.top()))//如果栈内的操作符优先级高于栈外的优先级,则入栈
                {
                    s.push(*middle); middle++;
                }
                else if (GetPriority(*middle) <= GetPriority(s.top()))
                                                         //如果栈内的操作符优先级低于或等于栈外的优先级,输出栈内的符号,并入栈栈外的符号
                {
                    *back = s.top();
                    s.pop(); 
                    s.push(*middle);
                    back++; middle++;
                    AddSpace(back);
                }
            }
        }
        while (s.top() != '#')//中缀表达式遍历完成,但是栈中还有符号存在,一一出栈输出
        {
            AddSpace(back);
            *back = s.top();
            s.pop(); back++;
        }
        *back = '\0';
        cout << "后缀表达式是: " << backend << endl;
        return backend;
    }
    
    double GetNumber(char*& arr)
    {
        //因为输出为char*,所以可能两位数以上的数字被拆开,此函数为正确得到数字
        double sum[10] = { 0 }; int i = 0; double result = 0;
        while (*arr != ' ')
        {
            sum[i] = *arr-48;
            i++;
            arr++;
        }
        int k = i - 1;
        for (int j = 0; j < i; j++,k--)
        {
            result += (sum[j] * pow(10, k));
        }
        return result;
    }
    
    double Cauculate(char ch, double left, double right)//各个操作符对应的操作
    {
        switch (ch)
        {
        case '+':
            return left + right;
        case '-':
            return left - right;
        case '*':
            return left * right;
        case '/':
            return left / right;
        default:
            return 0;
            break;
        }
    }
    
    double CountBack(char* back)
    {
        stack<double> s;
        while (*back)
        {
            if (isdigit(*back))//遇到数字
            {
                s.push(GetNumber(back));//将正确的数字入栈
            }
            else if (*back == ' ')
            {
                back++;//遇到空格跳过
            }
            else
            {
                double a = s.top();
                s.pop();
                double b = s.top();
                s.pop();
                s.push(Cauculate(*back, b, a));//遇到符号时,取栈顶的第二个数和第一个数求解,并入栈
                back++;
            }
        }
        while (s.size() >= 2)//最终栈内存在的数大于2时,继续计算,直到只剩下一个数
        {
            double a = s.top();
            s.pop();
            double b = s.top();
            s.pop();
            s.push(Cauculate(*back, b, a));
        }
        //返回这个数字,既是最终结果
        return s.top();
    }
    
    void FunTest()
    {
        cout << "表达式值为: " <<CountBack(GetBack()) << endl;
    }
    
    int main()
    {
        FunTest();
        system("pause");
        return 0;
    }

     

    更多相关内容
  • 本文实例为大家分享了C++实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 一、思路:和中缀表达式的计算类似,只不过不用计算,把表达式输出即可 1.用字符数组存储整行输入的中缀表达式; 2.接着从...
  • #include<stdio.h> #include<stdlib.h> #include<math.h> #define MAX 100 /* 表达式最大长度 */ #define true 1 #define false 0 /* 定义数据栈 */ typedef struct LinkStack1 { float data struct LinkStack1 *...
  • 文章目录前缀表达式(波兰表达式)前缀表达式分析与介绍思路分析中缀表达式中缀表达式分析与介绍后缀表达式(逆波兰表达式)后缀表达式分析与介绍思路分析逆波兰计算器代码实现逆波兰计算器中缀表达式转换为后缀...
  • 中缀表达式转换为后缀表达式(oj题库) 中缀表达式转换为后缀表达式(oj题库) 题目描述 中缀表达式是一个通用的算术或逻辑公式表示方法,操作符是以中缀形式处于操作数的中间(例:3 + 4),中缀表达式是人们常用的...
  • 表达式2*(9+6/3-5)+4,称为中缀表达式,表示成2 9 6 3 / + 5 - * 4 +称为后缀表达式,表示成+ * 2 - + 9 / 6 3 5 4称为前缀表达式。 ·基本要求 将中缀表达式,转换为后缀表达式和前缀表达式,再分别计算转换后的...
  • NULL 博文链接:https://128kj.iteye.com/blog/1623312
  • (1) 从键盘或文件读入一个合法的算术表达式,输出相应的后缀表达式后缀表达式中,数据与数据之间加分隔符; (2) 输出正确的计算结果,保留两位小数点; (3) 考虑算法的健壮性,当表达式错误时,要给出错误...
  • 中缀表达式转后缀表达式算法

    千次阅读 2020-10-31 12:49:44
    判断条件都是我经过多次测试出来的,每次都加上一点,也是耗时比较长的,在这里我并不想借鉴别人的代码,因为我觉得一个算法题每一次的测试每一次的修改不仅仅时加强了我对这个算法题的了解,更提高了我的耐心和心态...

    判断条件都是我经过多次测试出来的,每次都加上一点,也是耗时比较长的,在这里我并不想借鉴别人的代码,因为我觉得一个算法题每一次的测试每一次的修改不仅仅时加强了我对这个算法题的了解,更提高了我的耐心和心态,使我可以静下心来去思考,不会因为长时间没有看到成效而去放弃,我有时候感觉我真的很笨,但我觉得这并不是天生的,这跟我以前沉迷于游戏,只会去接受别人的东西有很大的关系,失去了独立思考的能力,再好的工具如果不经常使用终将会坏掉。言归正传,来分享一下今天我做出来的这个算法题吧!
    在这里插入图片描述

    #include<iostream>
    #include<string.h>
    using namespace std;
    #define MaxSize 500
    typedef struct{
    	char *data;
    	int len,top;
    }list;
    int js(char a); 
    void ints(list &q);
    bool stacke(list q);
    bool push(list &q,char x);
    bool pop(list &q,char  &x);
    bool get_top(list q,char &x);
    void siz();
    int js(char a){
    	if(a=='*'||a=='/') return 3;
    		else if(a=='+'||a=='-') return 2;
    			else if(a!='('&&a!=')')return 0;//如果是非运算符则返回0 
    }
    void ints(list &q){
    	q.top=-1;	//初始化栈顶指针 
    }
    bool stacke(list q){
    	if(q.top==-1)return true;	//判断栈是否为空 
    	else return false;
    }
    bool push(list &q,char x){	//栈满报错,入栈操作 
    	if(q.top==MaxSize-1)return false;
    	q.data[++q.top]=x;
    	return true;
    }
    bool pop(list &q){	//栈空报错,出栈操作 
    	if(q.top==-1)return false;
    	q.top--;
    	return true; 
    }
    bool get_top(list q,char &x){	//读取栈顶元素,传入变量记录栈顶元素 
    	if(q.top==-1)return false;
    	x=q.data[q.top];
    	return true; 
    }
    

    既然要用栈来实现算法,首先得做好准备工作,这里是栈的一些基本的操作,名字不是很规范,在数据结构试题中可以直接使用这些方法,名字尽量规范,并用注释写清楚每个方法的作用,这样就算名字不规范,批卷老师也不会给你判错的。

    int js(char a){
    	if(a=='*'||a=='/') return 3;
    		else if(a=='+'||a=='-') return 2;
    			else if(a!='('&&a!=')')return 0;//如果是非运算符则返回0 
    }
    

    在这里我们使用一个辅助算法用来比较优先级,数字可以任意定义,但要保证优先级高的运算符数字一定要比低的大,这样方便我们后面进行比较。

    void siz(){
    	char o,a[MaxSize];
    	list t;
    	t.data=new char[MaxSize];
    	cin>>a;
    	int l=strlen(a);
    	ints(t);
    	for(int i=0;i<l-1;i++){
    		if(js(a[i])==0)cout<<a[i];		//如果扫描到不是运算符直接输出 
    		else if(stacke(t))push(t,a[i]);	//如果栈为空则直接入栈 
    			else if(a[i]=='(')push(t,a[i]);//如果扫描到左括号直接入栈 
    				else if(a[i]==')'){
    					while(1){
    						get_top(t,o);	//如果扫描到右括号,依次出栈输出直到遇到左括号停止输出,出栈左括号 
    						if(o=='('){
    							pop(t);
    							break;
    						}
    						cout<<o;
    						pop(t);
    						
    					}
    						}
    						else {
    						get_top(t,o);
    						if(o=='('){push(t,a[i]);	//如果栈顶元素为左括号,直接入栈 
    						}
    						else if(js(o)>=js(a[i])){	//如果扫描到的运算符优先级高于除’(‘外栈顶运算符时,直接入栈,否则从栈顶开始,依次弹出比当前运算符优先级高或相等的运算符,直到遇到比它优先级低的或左括号或栈空为止。
    						while(1){	
    							get_top(t,o);
    							cout<<o;
    							pop(t);
    							get_top(t,o);
    							if(t.data[t.top]=='('||stacke(t)||js(o)<js(a[i])){
    							push(t,a[i]);
    							break;}}
    						}
    						else push(t,a[i]);}		//否则直接入栈 
    						
    	
    }						while(!stacke(t)){	
    							get_top(t,o);
    							cout<<o;	//依次弹出栈内元素,栈空为止 
    							pop(t);}
    	}
    int main(){
    	siz();
    }
    

    这是主要代码的实现,每个判断条件的作用已经注释,相信也比较容易理解吧!
    中缀表达式转后缀表达式规则总结了一下大约是这么几条:

    1. 如果扫描到非运算符类型,直接输出,不需要入栈
    2. 如果扫描到左括号,也是直接入栈
    3. 如果扫描到右括号,右括号不进行入栈也不输出,要对栈内元素依次出栈输出,直到遇到左括号停止输出,并将左括号出栈(如果有中括号和大括号,原理一样,再每次匹配到更高级的右括号时,里面的低级括号是执行完毕的,只需要加适当的判断条件即可)
    4. 剩下的肯定是加减乘除运算符了,在这里就用到了以上定义的辅助方法了,如果扫描到的运算符优先级高于除’(‘外栈顶运算符时,直接入栈,否则从栈顶开始,依次弹出比当前运算符优先级高或相等的运算符,直到遇到比它优先级低的或左括号或栈空为止。
    5. 最后把栈内元素全部弹出就好了。
    6. 在这里插入图片描述
      在这里插入图片描述
      这里进行了测试,结果是没有问题的,但因为时间有限,不能测试更多的表达式,大家感兴趣的话欢迎测试,如果出现问题,欢迎来投稿评论,此代码是我从头到尾敲下来的,所以我并不敢保证没有问题,但是我还是希望可以帮助大家去理解这个算法。
    展开全文
  • 中缀表达式转后缀表达式

    万次阅读 多人点赞 2019-04-12 17:55:21
    因为中缀表达式便于人们的理解与计算,但是后缀表达式更方便计算机的运算(如二叉树、堆栈的方法计算),因此在读取一个中缀表达式后,我们得办法将他转化为后缀表达式。 转化方式有三种: 首先假设我们需要转化.....

    自从找完工作人就废了,幡然醒悟不行不行,得把忘记的都记下来。。。。。。

    中缀表达式就是我们正常使用的那种,例如:a+b*c

    后缀表达式就是abc*+;

    为什么要有中缀表达式和后缀表达式呢?

    因为中缀表达式便于人们的理解与计算,但是后缀表达式更方便计算机的运算(如二叉树、堆栈的方法计算),因此在读取一个中缀表达式后,我们得办法将他转化为后缀表达式。

    转化方式有三种:

    首先假设我们需要转化的中缀表达式为:

    a + b * c + ( d * e + f ) * g

    第一种:基于堆栈的算法

    1. 从左到右扫描每一个字符。如果扫描到的字符是操作数(如a、b等),就直接输出这些操作数。

      c++堆栈的应用:中缀表达式转化为后缀表达式

    2. 如果扫描到的字符是一个操作符,分三种情况:

      (1)如果堆栈是空的,直接将操作符存储到堆栈中(push it)

      (2)如果该操作符的优先级大于堆栈出口的操作符,就直接将操作符存储到堆栈中(push it)

      (3)如果该操作符的优先级低于堆栈出口的操作符,就将堆栈出口的操作符导出(pop it), 直到该操作符的优先级大于堆栈顶端的操作符。将扫描到的操作符导入到堆栈中(push)。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    3. 如果遇到的操作符是左括号"(”,就直接将该操作符输出到堆栈当中。该操作符只有在遇到右括号“)”的时候移除。这是一个特殊符号该特殊处理。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    4. 如果扫描到的操作符是右括号“)”,将堆栈中的操作符导出(pop)到output中输出,直到遇见左括号“(”。将堆栈中的左括号移出堆栈(pop )。继续扫描下一个字符

      c++堆栈的应用:中缀表达式转化为后缀表达式

    5. 如果输入的中缀表达式已经扫描完了,但是堆栈中仍然存在操作符的时候,我们应该讲堆栈中的操作符导出并输入到output 当中。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    第二种:括号法,这种真的很简单啊,好记又简单

          1:按照运算符的优先级对所有的运算单位加括号~

          式子变成拉:((a+(b*c))+(((d*e+f)*g))

           2:转换前缀与后缀表达式

          前缀:把运算符号移动到对应的括号前面

          则变成拉:++(a*(bc))*(+(*(de)f)g)

          把括号去掉:++a*bc*+*defg 前缀式子出现

          后缀:把运算符号移动到对应的括号后面

          则变成拉:((a(bc)*)+(((de)*f)+g)*)+

          把括号去掉:abc*+de*f+g *+后缀式子出现

    第三种:利用语法树

          1、将式子转化为二叉树,如下所示,图做的有点丑,懒得画了,不要介意。。。。。。

          2、通过后序遍历将其写出来,即可得到结果:abc*+de*f+g *+

    在这里补充一点,如何将表达式变成二叉树:

    表达式生成树的特点为:

        a. 叶子节点都是操作数;

        b. 非叶子节点都是运算符;

        c. 树根的运算符优先级低;

    步骤如下

    找到表达式中优先级最低的运算符作为树根(注意括号会提升内部的优先级),并将原表达式分解成左右两个表达式;

    分别对左右表达式做步骤1, 左边生成的树为树根的左子树,右边生成的树为树根的右子树;

    重复步骤1,2, 直到分解的表达式里没有运算符(只剩下数字)为止;

    注意一点:在遇到像本式中a后面的+号和c后面的+的优先级问题,在正常计算时a后面的+会先使用所以他的优先级比c后面的+优先级高。所以能得到上面的二叉树。

    后序遍历的问题看我其他的文章中有介绍。

    展开全文
  • 中缀转后缀表达式计算实现源码(C++、Java)
  • 08.中缀表达式转换后缀表达式算法.ppt
  • 中缀转后缀表达式并计算

    注:本博客是基于《数据结构》这门课,主要是为了自己考研,准备专业课
    图解转自:中缀转后缀算法

    中缀转后缀算法

    中缀表达式转后缀表达式遵循以下原则:

    1. 遇到操作数,直接输出
    2. 当栈为空时,若遇到运算符,则入栈
    3. 当遇到左括号 “(” 时,则将其入栈
    4. 当遇到右括号 “)” 时,执行出栈操作,将栈顶的元素输出,直到栈顶元素是左括号时弹出并停止,左括号不输出
    5. 当遇到其他运算符如“+”、“-”、“ * ” 、“ / ”时,弹出栈中所有优先级大于或等于该运算符的栈顶元素,然后将该运算符入栈
    6. 最后,再将栈中的元素依次出栈,输出
    7. 经过上面的步骤,得到的输出既是转换得到的后缀表达式

    ⚠️ 运算符优先级: { *,/ } > { +,— } > { ( }

    举例:a+b * c+(d * e+f) * g ——> abc * +de * f+g * +

    图示上述过程:

    遇到a,直接输出:

    在这里插入图片描述
    遇到+,此时栈为空,入栈:

    这里写图片描述
    遇到b,直接输出:

    这里写图片描述
    遇到*,此时其优先级大于栈顶符号+的优先级,则入栈:
    遇到c,输出:

    这里写图片描述

    遇到+,目前站内的* 、+优先级都大于或等于它,因此将栈内的* 、+依次弹出并且输出,并且将这个+入栈:

    这里写图片描述

    遇到(,将其入栈:

    在这里插入图片描述
    遇到d,直接输出:

    在这里插入图片描述

    遇到*,由于其优先级高于处在栈顶的(,因此直接入栈:

    在这里插入图片描述

    遇到e,直接输出:

    在这里插入图片描述
    遇到+,此时栈顶的*优先级高于+,但是栈内的( 优先级低于 +,故将 * 出栈输出,+入栈:

    在这里插入图片描述
    遇到f,直接输出:

    在这里插入图片描述
    遇到 ),弹出栈顶元素并且输出,直到遇到( 才结束,在这里也就是弹出+输出,弹出(不输出:

    在这里插入图片描述
    遇到*,优先级高于栈顶+,将*入栈

    在这里插入图片描述

    遇到g,直接输出:

    在这里插入图片描述
    此时中缀表达式已全部处理完成,故依次将栈中元素出栈并输出,直到栈为空:

    在这里插入图片描述
    代码部分:

    //中缀表达式转后缀表达式
    #include<iostream>
    #include<string>
    #include<stack>
    
    using namespace std;
    
    int prio(char op) {                 //给运算符优先级排序
    	int priority=0;
    	if (op == '*' || op == '/')
    		priority = 2;
    	if (op == '+' || op == '-')
    		priority = 1;
    	if (op == '(')
    		priority = 0;
    	return priority;
    }
    
    bool Trans(string& str1, string& str2) {   //引用传递
    	stack<char> s;                   //定义一个char类型的栈s
    	int i;
    	for (i = 0; i < str1.size(); i++) 
    	{
    		if (str1[i] >= '0' && str1[i] <= '9') {    //如果是数字,直接入栈
    			str2 += str1[i];
    		}
    		else		//否则不是数字
    		{                       
    			if (s.empty())            //栈空则入站
    				s.push(str1[i]);
    			else if (str1[i] == '(')   //左括号入栈
    				s.push(str1[i]);
    			else if (str1[i] == ')') {  //如果是右括号,只要栈顶不是左括号,就弹出并输出
    				while (s.top() != '(') {
    					str2 += s.top();
    					s.pop();
    				}
    				s.pop();                 //弹出左括号,但不输出
    			}
    			else {		//当栈顶非空时
    				while (prio(str1[i]) <= prio(s.top())) { //当栈顶优先级大于等于当前运算符,输出
    					str2 += s.top();
    					s.pop();
    					if (s.empty())      //栈为空,停止
    						break;
    				}
    				s.push(str1[i]);   //把当前运算符入栈
    			}
    		}
    	}
    	while (!s.empty()) {      //最后,如果栈不空,则弹出所有元素并输出
    		str2 += s.top();
    		s.pop();
    	}
    	return true;
    }
    
    int main() {                //主程序
    	string infix;	//保存输入的中缀表达式
    	string postfix;		
    	cout << "请输入中缀表达式:" << infix << endl;
    	cin >> infix;
    	Trans(infix, postfix);
    	cout << "后缀表达式为:" << postfix << endl;
    	system("pause");
    	return 0;
    }
    
    

    后缀表达式计算思路:

    从左往右依次扫描后缀表达式,遇到操作数入栈,遇到运算符、则弹出两个操作数、计算结果并将结果入栈( 注:先弹出的为右操作数,后弹出的为左操作数),循环以上过程,直到扫描完后缀表达式,此时栈中的数即为运算结果。
    图解:

    实例:

    输入: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
    输出: 22
    解释: 
    ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
    = ((10 * (6 / (12 * -11))) + 17) + 5
    = ((10 * (6 / -132)) + 17) + 5
    = ((10 * 0) + 17) + 5
    = (0 + 17) + 5
    = 17 + 5
    = 22
    

    具体实现:

    class Solution {
    public:
         int evalRPN(vector<string>& tokens) {
            stack<int> numbers;
            for(int i = 0 ; i < tokens.size() ;i++){
                //若为运算符,则弹出两个栈顶元素,进行运算并将结果放回栈
                if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
                    int res;
                    int n2 = numbers.top();
                    numbers.pop();
                    int n1 = numbers.top();
                    numbers.pop();
                    
                    if(tokens[i] == "+")
                       res = n1 + n2;
                    else if(tokens[i] == "-")
                       res = n1 - n2;
                    else if(tokens[i] == "/")
                       res = n1 / n2;
                    else
                       res = n1 * n2;
                    numbers.push(res);
                }else{
                    //若为运算数,则直接入栈
                    numbers.push(tokens[i]);
                } 
            }
            return numbers.top();
        }
    };
    
    展开全文
  • 后缀表达式(逆波兰表达式):机器熟悉的算术表达式,如:3 4 + 5 * 6 - 8 + 1. 中缀转前缀语言描述:从右向左遍历中缀表达式,如果是数字就压入数字栈,如果是符号就压入符号栈,如果当前符号比符号栈栈顶符号...
  • 表达式树的形式进行编码,能够输出结点和右节点,以及右节点的右节点(如果存在)的表达式符号,并且输出计算结果。
  • 中缀表达式转后缀表达式算法思想

    千次阅读 2019-03-13 13:38:29
    中缀表达式转后缀表达式的方法: 1.遇到操作数:直接输出(添加到后缀表达式中) 2.栈为空时,遇到运算符,直接入栈 3.遇到左括号:将其入栈 4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左...
  • 后缀表达式是计算机容易运算的表达式,运算符在运算数后面,从左到右进行运算,无需考虑优先级,运算呈线性结构. 先举个简单的转换例子 2+9/3-5 (前缀)-> 2 9 3 / + 5 - (后缀) 先进行乘除再进行加减 运算规律,.....
  • 实现效果 源码 #include<stdio.h> #include<string.h> //创建栈 typedef struct node { char s[1000]; int top; }Stack; //判断符号的函数 int weight(char ch, int flag) ...fla
  • 本次复盘包含有中缀表达式转化为后缀表达式的全部思路。从分析两种表达式的特点开始,思考选用的数据结构,推演运算过程。然后根据运算过程,设计不同运算符优先级的高低。在难度上,从没有括号的四则运算开始,逐步...
  • 算法中缀表达式转后缀表达式(想看全部代码直接翻到底部) 欢迎大家进入二阳的学习课堂!!希望大家耐心看下去,这样才能有收获。(想看全部代码直接翻到底部) 众所周知,在编程里面,直接用中缀表达式求值是不...
  • c++使用堆栈实现中缀表达式转后缀表达式
  • 中缀表达式转后缀表达式的思路步骤分析 1)初始化两个栈:运算符栈s1和储存中间结果的栈s2; 2)从左至右扫描中缀表达式; 3)遇到操作数时,将其压s2; 4)遇到运算符时,比较其与s1栈顶运算符的优先级: 1.如果s1为空,或...
  • 中缀表达式转后缀表达式参考的文章就是直接给出了算法,但是算法如何推导出来的还没有弄明白,简单记录下我自己的理解,强行解释一下。后缀表达式就是操作符再操作数的后面,并且计算机能够根据简单的优先级就能进行...
  • 中缀表达式转化为后缀表达式算法后缀表达式算法的实现.doc
  • 中缀表达式 后缀表达式思路代码实现 思路 代码实现 import java.util.*; public class PolandNotation { public static void main(String[] args) { //完成将一个 中缀表达式 转换成 后缀表达式 的功能 //...
  • 第二步: 中缀表达式转后缀表达式的基本过程为:从头到尾读取中缀表达式的每个对象,对不同的对象按照不同的情况处理,分为以下六种情况: 如果是空格,认为是分割符,不处理 如果是运算数,直接输出 如果是左括号...
  • 数据结构的中缀表达式转后缀表达式,通过C++语言实现。使用堆栈方法进行转换,能正确运算包含括号、加、减、乘、除复合运算,如(1+2)*3-1.8*(18/(7+2)) = 8.2。
  • 中缀表达式转后缀表达式 后缀表达式 后缀表达式又称逆波兰表达式,明显的特点是:逆波兰表达式中没有括号,计算时将操作符之前的第一个数作为右操作数,第二个数作为左操作数,进行计算,得到的值继续放入逆波兰...
  • 中缀转化为前缀和后缀 前缀:把运算符移动到对应括号的前面,然后去掉括号即可 +(+(a*(bc)) * (+(*(de) f)g)) ++a * bc * + * defg 后缀:把运算符移到对应的括号后面,然后去掉括号即可 (((a(bc) *) + (((de) * f...
  • C++中缀表达式转后缀表达式

    千次阅读 2019-11-11 23:06:03
    C++中缀表达式转后缀表达式 最近在看计算器相关的东西,然后想自己实现一下简单的中缀表达式转后缀表达式。 环境Visual Studio 2017->c++控制台项目 1. 栈内外元素优先级 isp栈内元素优先级(in stack ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,285
精华内容 3,314
关键字:

中缀转后缀表达式算法