精华内容
下载资源
问答
  • 主要为大家详细介绍了C++利用栈实现中缀表达式转后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 用dev c++写的代码,附有啰里啰嗦的注释和测试样例。太简单了不好意思要分。
  • 主要为大家详细介绍了C++实现中缀表达式转后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 一个算术表达式是由操作数(operand)、运算符(operator)和括号组成的。...用户可选择需要进行的操纵,包括后缀表达式的计算,中缀表达式转为后缀表达式,清屏和退出,界面清晰,操作简便,且有足够的输入合法性检验
  • c++使用堆栈实现中缀表达式转后缀表达式
  • C++ 中缀表达式转后缀表达式

    千次阅读 多人点赞 2019-01-03 23:44:47
    一、思路:和中缀表达式的计算类似,只不过不用计算,把表达式输出即可  1.用字符数组存储整行输入的中缀表达式;  2.接着从字符数组的0位置开始判断字符,如果是数字,那就要判断后面是否是数字,如果是就不断...

    一、思路:和中缀表达式的计算类似,只不过不用计算,把表达式输出即可

          1.用字符数组存储整行输入的中缀表达式;

          2.接着从字符数组的0位置开始判断字符,如果是数字,那就要判断后面是否是数字,如果是就不断扫描组成一个整数

            (暂不考虑负数和小数),最终组成一个整数,然后输出这个数(因为不用计算,所以直接输出即可);

          3.如果是左括号,直接进符号栈;

          4.如果是操作运算符,与符号栈的栈顶元素比较优先级:如果高就压入栈;

                    低,就取出符号栈顶的元素输出;

                    接着,再判断符号栈顶的元素和当前的运算符号继续比较优先级,重复前面步骤,直到栈空或者当前的符号优先级高;

          5.如果是右括号,把符号栈栈顶的元素取出,如果不是左括号,把取出的运算符输出,接着取符号栈栈顶的元素,直到符号栈

             中取出的符号是左括号;

          6.当扫描完字符数组时,判断符号栈是否为空:

                    不为空,把符号栈栈顶的元素取出,输出到窗口,直到符号栈为空。

     

    二、实现程序:

    //  中缀表达式转后缀表达式
    //  操作符:+、-、*、/、%
    //  输入:可以用cin.getline(arr, 250)或者cin.get(ch) && ch != '\n'
    //  测试数据:输入格式:(注意:不能有中文的操作符)
    //           2+(3+4)*5
    //           16+2*30/4
    //      输出格式:
    //          2 3 4 + 5 * +
    //          16 2 30 * 4 / +
    
    #include <iostream>
    #include <stack>
    
    // 判断是否是操作符
    bool isOperator(char ch) {
        if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
            return true;
        return false; // 否则返回false
    }
    
    // 获取优先级
    int getPriority(char ch) {
        int level = 0; // 优先级
        
        switch(ch) {
            case '(':
                level = 1;
                break;
            case '+':
            case '-':
                level = 2;
                break;
            case '*':
            case '/':
                level = 3;
                break;
            default:
                break;
        }
        return level;
    }
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        int num;
        char arr[250]; // 一个一个的读取表达式,直到遇到'\0'
        std::stack<char> op; // 栈op:存储操作符
        
        while(1) {
            std::cin.getline(arr,250);
            int len, i;
            char c; // c存储从栈中取出的操作符
            
            len = (int)strlen(arr); // strlen()输出的是:unsigned long类型,所以要强制转换为int类型
            i = 0;
            while(i < len) {
                if(isdigit(arr[i])) { // 如果是数字
                    num = 0;
                    do {
                        num = num * 10 + (arr[i] - '0'); // ch - 48根据ASCAII码,字符与数字之间的转换关系
                        i++; // 下一个字符
                    }while(isdigit(arr[i]));
                    std::cout << num << " ";
                } else if(arr[i] == '(') { // (:左括号
                    op.push(arr[i]);
                    i++;
                } else if(isOperator(arr[i])) { // 操作符
                    if(op.empty()) {// 如果栈空,直接压入栈
                        op.push(arr[i]);
                        i++;
                    }
                    else {
                        // 比较栈op顶的操作符与ch的优先级
                        // 如果ch的优先级高,则直接压入栈
                        // 否则,推出栈中的操作符,直到操作符小于ch的优先级,或者遇到(,或者栈已空
                        while(!op.empty()) {
                            c = op.top();
                            if(getPriority(arr[i]) <= getPriority(c)) {
                                // 优先级低或等于
                                std::cout << c << " ";
                                op.pop();
                            } else // ch优先级高于栈中操作符
                                break;
                        } // while结束
                        op.push(arr[i]); // 防止不断的推出操作符,最后空栈了;或者ch优先级高了
                        i++;
                    } // else
                } else if(arr[i] == ')') { // 如果是右括号,一直推出栈中操作符,直到遇到左括号(
                    while(op.top() != '(') {
                        std::cout << op.top() << " ";
                        op.pop();
                    }
                    op.pop(); // 把左括号(推出栈
                    i++;
                } else // 如果是空白符,就进行下一个字符的处理
                    i++;
            } // 第二个while结束
            while(!op.empty()) { // 当栈不空,继续输出操作符
                std::cout << op.top() << " ";
                op.pop();
            }
            std::cout << std::endl;
            flush(std::cout);
        } // 第一个while结束
        return 0;
    }

    运行结果:

    展开全文
  • 该程序实现了运算表达式转换为中缀表达式中缀表达式转换为后缀表达式及后缀表达式求值。该程序已实现加减乘除括号运算符及求余、幂指数的求解
  • C++中缀表达式转后缀表达式 最近在看计算器相关的东西,然后想自己实现一下简单的中缀表达式转后缀表达式。 环境Visual Studio 2017->c++控制台项目 1. 栈内外元素优先级 isp栈内元素优先级(in stack ...

    C++中缀表达式转后缀表达式

    最近在看计算器相关的东西,然后想自己实现一下简单的中缀表达式转后缀表达式。
    

    环境Visual Studio 2017->c++控制台项目
    本文仅实现中缀表达式转后缀表达式,(中缀转后缀以及)后缀表达式计算,请点击下面的链接:
    后缀表达式计算

    1. 栈内外元素优先级

    isp栈内元素优先级(in stack priority)
    icp栈外元素优先级(in coming priority)
    在这里插入图片描述

    2.算法思想

    (1)初始化栈,将结束符‘#’入栈,在输入字符串末尾添加’#’。
    (2)若是数字,将获取整个数字串,然后直接输出到队列(string)q中
    否则将栈顶元素s.top()与栈外元素(string)intput[i]的优先级做比较
    ·1·若isp(s.top()) > icp(input[i]),栈内优先级高,则出栈,压入输出队列q。
    此时
    需将栈内所有优先级比栈外元素优先级高的元素出栈,并压入输出队列q中,直到优先等级是<=。再重新执行<或=操作。
    ·2·若isp(s.top()) < icp(input[i]),栈外元素优先级高,则进栈
    ·3·若isp(s.top()) = icp(input[i]),栈内外优先级相等,则出栈。
    (3)直至input中所有元素被读取完,也就是栈内的#与input的#匹配,此时队列q中的元素输出即为所求后缀表达式。

    3.代码实现

    #include <iostream>
    #include<string>
    #include <stack>
    #include <queue>
    using namespace std;
    
    stack<char> s;//存放运算符的栈
    queue<string> q;//输出队列(用于计算后缀表达式)
    stack<double> sum;//用于计算后缀表达式(本文未实现计算后缀表达式)
    string str = "";//读取整个数字串并保存
    
    int isp(char c)//栈内元素优先级判断
    {
     switch (c)
     {
     case '#':
      return 0;
     case '(':
      return 1;
     case '+':
     case '-':
      return 3;
     case '*':
     case '/':
     case '%':
      return 5;
     case ')':
      return 6;
     }
    }
    int icp(char c)//栈外元素优先级判断
    {
     switch (c) {
     case '#':
      return 0;
     case ')':
      return 1;
     case '+':
     case '-':
      return 2;
     case '*':
     case '/':
     case '%':
      return 4;
     case '(':
      return 6;
     }
    }
    void postfix(string input)//中缀表达式转后缀表达式代码
    {
    	s.push('#');//将#压入栈顶
     input += '#';//添加#号作为结束符
     for (int i = 0; i < input.length(); i++)
     {
      if ((input[i] >= '0' && input[i] <= '9') || input[i] == '.')
      {
       str += input[i];
      }
      else
      {
       if (str.length() > 0)//将数放入直接输出到队列中
       {
        q.push(str);
        str = "";
       }
       while (isp(s.top()) > icp(input[i]))
       {
        string a;//因为不能直接在栈和队列间转换字符和字符串类型,所以先将字符转成 字符串再出栈进队列
        a = s.top();
        q.push(a);
        s.pop();
       }
       //判断站外元素优先级决定元素是应该去除(=),还是进栈(<)
       if (isp(s.top()) == icp(input[i]))
       {
        s.pop();
       }
       else
       {
        s.push(input[i]);
       }
      }
     }
    }
    
    
    int main()
    {
     string input;
     string och;
     cin >> input;
     postfix(input);
     while (q.empty() == false)//队列不为空则输出队列元素
     {
      och=q.front();
      cout << och ;
      q.pop();
     }
    }
    

    实验结果

    输入:(5-8*(8-7))*9
    输出:结果没问题,输入的时候不要将括号打成中文。
    在这里插入图片描述

    本文参照
    数据结构:用于面向对象方法与C++语言描述/殷人昆主编。 —2版(第99页)

    寄语

    有什么问题可以评论区交流,写了也不一定回,回了也不一定对,对了也不一定能用,能用了也不一定能对。。。。。。。

    展开全文
  • 中缀表达式转后缀表达式求值

    千次阅读 2019-03-27 17:29:59
    刚开始想一鼓作气把整个过程全部实现,但白费了那几个小时,调试了半天也没做出来,后来我是通过先实现中缀...中缀表达式转后缀表达式: # include <iostream> # include <string> # include <...

    刚开始想一鼓作气把整个过程全部实现,但白费了那几个小时,调试了半天也没做出来,后来我是通过先实现中缀表达式转化为后缀表达式,然后实现后缀表达式的求值,然后将两块代码进行合成,刚才同学还笑着说:模块化编程。。。

     

    直接在代码中解释。

    中缀表达式转后缀表达式:

    # include <iostream>
    # include <string>
    # include <sstream>
    # include <cctype>                //程序中需使用isdigit()函数,目的在于判别字符是否为数字,将符号和数字区别开来
    using namespace std;
    struct sign                      //建立存储符号的结构体
    {
    	char sign;
    	int level;
    	struct sign *next_1;
    };
    class linkstack
    {
    private:
    	struct sign *top;
    public:
    	linkstack() { top = NULL; }   //无参构造函数,top头指针初始化为零
    	char push_out();              //将栈顶元素出栈
    	void push_in(char new_sign);  //给栈中添加新元素
    	char print_top();             //返回栈顶元素中的符号内容
    	int print_level();            //返回栈顶元素符号的优先级
    };
    int compare(char compared_sign)   //给每个符号赋予优先级
    {
    	int level;
    	switch (compared_sign) {
    	case '(':
    		level = -10; break;
    	case ')':
    		level = -10; break;
    	case '+':
    		level = 0; break;
    	case '-':
    		level = 0; break;
    	case '*':
    		level = 1; break;
    	default:                     //default要加上
    		level = 1; break;
    	}
    	return level;
    }
    char linkstack::print_top()
    {
    	char result;
    	result = top->sign;
    	return result;
    }
    int linkstack ::print_level()
    {
    	return top->level;
    }
    char linkstack::push_out()               //删除栈顶元素
    {
    	char char_result;
    	struct sign *p;
    	char_result = top->sign;
    	p = top;
    	top = top->next_1;
    	delete p;
    	return char_result;                  //删除后需要给sting对象b中追加,所以需要返回
    }
    void linkstack::push_in(char new_sign)
    {
    	struct sign *s;
    	s = new struct sign;                 //添加栈顶元素
    	s->sign = new_sign;
    	s->level = compare(new_sign);
    	s->next_1 = top;
    	top = s;
    }
    int main()
    {
    	int count = 0; double m;           //count用来记录符号栈中的个数,用top!=NULL也可以
    	string a,b;
    	cin >> a;                          //string对象a是转化前的,b是转换后的
    	linkstack one;
    	for (auto c = a.begin(); c != a.end(); c++) {          //从a的第一个元素开始扫描
    		if (isdigit(*c)) {
    			b.push_back(*c);  continue;            //如果是数字isdigit(*c)为真,就给b中追加,进行下一个循环
    		}
    		else {
    			if (*c != ')'&&count==0) {            //如果栈为空,直接加入栈顶元素
    				one.push_in(*c);
    				count++;                         //记录栈元素的个数
    				continue;                        //进行下一个循环
    			}
    			if (*c==')') {                      //进行括号中的运算
    				while (one.print_top()!= '(') {             //一直循环到栈顶元素不等于‘(’
    					b.push_back(one.print_top());           //将目前栈顶元素追加给b
    					one.push_out(); count--;                //追加完后,删除栈顶元素,个数减一
    				}
    				one.push_out(); count--;                   //最后记得还要把左括号删除,以避免对下一个运算影响
    				continue;
    			}
    			if (compare(*c) <= one.print_level()) {     //如果当前符号优先级小于栈顶元素的优先级(即上一个运算符)
    				b.push_back(one.print_top());           //将栈顶运算符元素追加给b
    				one.push_out();                         //紧跟着删除刚才的栈顶元素
    				one.push_in(*c);                        //将当前的运算符号压入栈
    				continue;                               //进行下一个循环
    			}
    			if (compare(*c)>one.print_level()) {        //如果当前运算符优先级大于栈顶元素(即前一个运算符)
    				one.push_in(*c); count++;               //直接压入栈,个数加一,并进行下一个循环
    				continue;
    			}
    		}
    	}
    	if (count) {                                        //如果栈不空则还剩余一个符号没有追加给b
    		b.push_back(one.print_top());                   //追加栈中剩余的符号
    		one.push_out();
    	}
    	cout << b << endl;
    	system("pause");
    	return 0;
    }
    

    后缀表达式求值:

    # include <iostream>
    # include <string>
    # include <sstream>                    //下边程序中从string类型到double中要用到,具体的用法在以前的博客中我有详细提及
    using namespace std;
    struct operate         
    {
    	double member;         
    	struct operate *next;
    };
    class new_linkstack
    {
    public:
    	new_linkstack() { top = NULL; }      //初始化,top为NULL;
    	void push_in(double x);              //将数字压入栈
    	double push_out();                   //删除栈顶元素
    	void print_result();                 //打印运算完后的结果,也就是最后的栈顶元素
    private:
    	struct operate *top;
    };
    void new_linkstack::push_in(double in_number)
    {
    	struct operate *s;
    	s = new operate;
    	s->member = in_number;
    	s->next = top;
    	top = s;
    }
    double new_linkstack::push_out()
    {
    	struct operate *p;
    	if (top == NULL)throw"下溢";
    	double out_member;
    	out_member = top->member; p = top;
    	top = top->next;
    	delete p;
    	return out_member;
    }
    void new_linkstack::print_result()
    {
    	cout << top->member << endl;
    }
    int main()
    {
    	double x, y, result,b;
    	string new_a;
    	cin >> new_a;
    	new_linkstack one;
    	for (auto c = new_a.begin(); c != new_a.end(); c++) {   //从头到尾扫描new_a中的元素
    		if (isdigit(*c)) {              //如果当前元素为数字,直接入栈
    			stringstream sstream;
    			sstream << *c;
    			sstream >> b;              //string类型到double类型的转换
    			one.push_in(b);
    			sstream.clear();           //将stringstream流清空
    		}
    		else {                         //如果当前元素为运算符
    			x = one.push_out();        //将前两个栈顶的元素取出 
    			y = one.push_out(); 
    			switch (*c)                //new_a中的运算符不能直接用来做运算
    			{
    			case '+':
    				result = x + y; one.push_in(result); continue;//运算完后,将当前运算结果压入栈,进行下一个循环
    			case '-':
    				result = y - x; one.push_in(result); continue;
    			case '*':
    				result = x * y; one.push_in(result); continue;
    			case '/':
    				result = y / x; one.push_in(result); continue;
    			}
    		}
    	}
    	one.print_result();               //打印最终结果
    	system("pause");
    	return 0;
    }

    这样就将一个大的问题分成了两个小的问题,下边的代码是我合成之后的:

    # include <iostream>
    # include <string>
    # include <cctype>
    # include <sstream>
    using namespace std;
    struct sign
    {
    	char sign;
    	int level;
    	struct sign *next_1;
    };
    struct operate
    {
    	double member;
    	struct operate *next;
    };
    class new_linkstack
    {
    public:
    	new_linkstack() { top = NULL; }
    	void push_in(double x);
    	double push_out();
    	void print_result();
    private:
    	struct operate *top;
    };
    class linkstack
    {
    private:
    	struct sign *top;
    public:
    	linkstack() { top = NULL; }
    	char push_out();
    	void push_in(char new_sign);
    	char print_top();
    	int print_level();
    };
    int compare(char compared_sign)
    {
    	int level;
    	switch (compared_sign) {
    	case '(':
    		level = -10; break;
    	case ')':
    		level = -10; break;
    	case '+':
    		level = 0; break;
    	case '-':
    		level = 0; break;
    	case '*':
    		level = 1; break;
    	default:                         
    		level = 1; break;
    	}
    	return level;
    }
    char linkstack::print_top()
    {
    	char result;
    	result = top->sign;
    	return result;
    }
    int linkstack::print_level()
    {
    	return top->level;
    }
    char linkstack::push_out()
    {
    	char char_result;
    	struct sign *p;
    	char_result = top->sign;
    	p = top;
    	top = top->next_1;
    	delete p;
    	return char_result;
    }
    void linkstack::push_in(char new_sign)
    {
    	struct sign *s;
    	s = new struct sign;
    	s->sign = new_sign;
    	s->level = compare(new_sign);
    	s->next_1 = top;
    	top = s;
    }
    void new_linkstack::push_in(double in_number)
    {
    	struct operate *s;
    	s = new operate;
    	s->member = in_number;
    	s->next = top;
    	top = s;
    }
    double new_linkstack::push_out()
    {
    	struct operate *p;
    	if (top == NULL)throw"下溢";
    	double out_member;
    	out_member = top->member; p = top;
    	top = top->next;
    	delete p;
    	return out_member;
    }
    void new_linkstack::print_result()
    {
    	cout << top->member << endl;
    }
    int main()
    {
    	int count = 0; double m;
    	string a, b;
    	cin >> a;
    	linkstack one;
    	for (auto c = a.begin(); c != a.end(); c++) {
    		if (isdigit(*c)) {
    			b.push_back(*c);  continue;
    		}
    		else {
    			if (*c != ')'&&count == 0) {
    				one.push_in(*c);
    				count++;
    				continue;
    			}
    			if (*c == ')') {
    				while (one.print_top() != '(') {
    					b.push_back(one.print_top());
    					one.push_out(); count--;
    				}
    				one.push_out(); count--;
    				continue;
    			}
    			if (compare(*c) <= one.print_level()) {
    				b.push_back(one.print_top());
    				one.push_out();
    				one.push_in(*c);
    				continue;
    			}
    			if (compare(*c) > one.print_level()) {
    				one.push_in(*c); count++;
    				continue;
    			}
    		}
    	}
    	if (count) {
    		b.push_back(one.print_top());
    		one.push_out();
    	}
    	double x, y, result, new_b;
    	string new_a(b);
    	new_linkstack two;
    	for (auto c = new_a.begin(); c != new_a.end(); c++) {
    		if (isdigit(*c)) {
    			stringstream sstream;
    			sstream << *c;
    			sstream >> new_b;
    			two.push_in(new_b);
    			sstream.clear();
    		}
    		else {
    			x = two.push_out();
    			y = two.push_out();
    			switch (*c)
    			{
    			case '+':
    				result = x + y; two.push_in(result); continue;
    			case '-':
    				result = y - x; two.push_in(result); continue;
    			case '*':
    				result = x * y; two.push_in(result); continue;
    			case '/':
    				result = y / x; two.push_in(result); continue;
    			}
    		}
    	}
    	two.print_result();
    	system("pause");
    	return 0;
    }

    这也算是个人狭义上的第一次模块化的编程吧。。。。。。

    展开全文
  • } //中缀转后缀函数 bool reversePolish(ElemType str[],int length) { SqStack S;//声明符号栈 initStack(S);//符号栈初始化 string polish;//声明后缀表达式字符串 int i;//i是遍历中缀表达式的下标 for(i=0; i; ...
    #include <iostream>
    using namespace std;
    #define MaxSize 50
    typedef char ElemType;
    typedef struct
    {
        ElemType data[MaxSize];
        int top;
    } SqStack;
    
    //栈初始化
    void initStack(SqStack &S)
    {
        S.top = -1;
    }
    //判断栈空
    bool stackEmpty(SqStack S)
    {
        if(S.top == -1)
            return true;
        else
            return false;
    }
    //入栈
    bool push(SqStack &S,ElemType x)
    {
        if(S.top == MaxSize-1)
            return false;
        S.top++;
        S.data[S.top] = x;
        return true;
    }
    //出栈
    bool pop(SqStack &S,ElemType &x)
    {
        if(S.top == -1)
            return false;
        x = S.data[S.top--];
        return true;
    }
    //读栈顶元素
    bool getTop(SqStack S,ElemType &x)
    {
        if(S.top == -1)
            return false;
        x = S.data[S.top];
        return true;
    }
    //中缀转后缀函数
    bool reversePolish(ElemType str[],int length)
    {
        SqStack S;//声明符号栈
        initStack(S);//符号栈初始化
        string polish;//声明后缀表达式字符串
        int i;//i是遍历中缀表达式的下标
        for(i=0; i<length; i++)
        {
            switch(str[i])
            {
            case '(':
                push(S,str[i]);//左括号直接入栈
                break;
            case ')':
                //遇到右括号,不入栈,弹出栈中( 上面的所有符号并加入后缀表达式,最后把左括号弹出
                ElemType topElem,x;
                getTop(S,topElem);//读取栈顶元素
                while(topElem != '(')
                {
                    pop(S,x);
                    polish+=x;
                    if(stackEmpty(S))
                    {
                        //cout<<"栈空!"<<endl;
                        break;
                    }
                    else
                        getTop(S,topElem);
                }
    
                pop(S,x);
                break;
            case '+':
            case '-':
                //先弹出比自己级别高的或者与自己同级的运算符,加入后缀表达式
                //cout<<"是+或者-,入栈"<<endl;
                if(!stackEmpty(S))//如果栈非空
                {
                    ElemType topElem;
                    getTop(S,topElem);//读取栈顶元素
    
                    while(topElem == '+' || topElem == '-' || topElem == '*' || topElem == '/')
                    {
                        ElemType x;
                        pop(S,x);
                        polish+=x;
                        if(stackEmpty(S))
                        {
                            //cout<<"栈空!"<<endl;
                            break;
                        }
                        else
                            getTop(S,topElem);
                    }
                }
                push(S,str[i]);//弹出后自己入栈
                break;
            case '*':
            case '/':
                //先弹出比自己级别高的或者与自己同级的运算符,加入后缀表达式
                //cout<<"是*或者/,入栈"<<endl;
                if(!stackEmpty(S))//如果栈非空
                {
                    ElemType topElem;
                    getTop(S,topElem);//读取栈顶元素
    
                    while(topElem == '*' || topElem == '/')
                    {
                        ElemType x;
                        pop(S,x);
                        polish+=x;
                        if(stackEmpty(S))
                        {
                           // cout<<"栈空!"<<endl;
                            break;
                        }
                        else
                            getTop(S,topElem);
                    }
                }
                push(S,str[i]);//弹出后自己入栈
                break;
            default:
                polish+=str[i];
            }
        }
        while(!stackEmpty(S))
        {
            ElemType x;
            pop(S,x);
            polish+=x;
        }
        cout<<"后缀表达式为:"<<endl;
        cout<<polish;
        return true;
    }
    int main()
    {
        ElemType str[MaxSize];
        int length;
        cout<<"请输入中缀字符串长度:";
        cin>>length;
        cout<<"请输入中缀表达式:"<<endl;
        cin>>str;
        cout<<"您输入的中缀表达式为:";
        cout<<str<<endl;
        reversePolish(str,length);
        return 0;
    }
    
    

    代码有个缺点,输入的时候必须输入要测试的中缀字符串长度,我懒得改了~~其他应该还是没问题的

    展开全文
  • 表达式树的形式进行编码,能够输出结点和右节点,以及右节点的右节点(如果存在)的表达式符号,并且输出计算结果。
  • 本文实例为大家分享了C++中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 1、初始化两个栈:运算符栈s1和储存中间结果的栈s2; 2、从左至右扫描中缀表达式; 3、遇到操作数时,将其压s2; 4、遇到...
  • 中缀表达式转后缀表达式 以及 后缀表达式的计算 一、中缀表达式 后缀表达式 步骤: 1.准备两个空栈S1,S2 2.当遇到数字直接压入S1 3.当遇到操作符号,如果S2为空,或者当前符号的优先级大于S2栈顶操作符优先级,...
  • 原理 流程 照着这个流程写的代码 // // Created by admin on 2020/12/7. // #include "iostream" #include "cstdio" #include "stack" #include "vector" using namespace std; int num(char str){ ...c
  • C++中,所有的代码都是通过标识符(Identifier)、表达式(Expression)和语句(Statement)及一些必要的符号(如大括号等)组成,在此先说明何谓标识符。 标识符 标识符是一个字母序列,由大小写英文字母、下划线及数字组成...
  • problem 给你一个中缀表达式,就是平常的算术式,比如这样的1+4/2*3+4 求计算结果 没有提交,我编几个样例把。 【输入样例】: ...【中缀表达式转后缀:】 1)如果遇到操作数,我们就直接将其输出
  • 算法:中缀表达式转后缀表达式(想看全部代码直接翻到底部) 欢迎大家进入二阳的学习课堂!!希望大家耐心看下去,这样才能有收获。(想看全部代码直接翻到底部) 众所周知,在编程里面,直接用中缀表达式求值是不...
  • 希望代码比较简单 有以下几种数据 这本来是scratch的题,但我觉得大家可能很少用,所以我就来求一下c++代码吧
  • C++数据结构中缀表达式转后缀表达式源码集,把中缀表达式转换为后缀表达式,返回后缀表达式的长度(包括空格),由后缀表达式计算出数值结果,遇到右括号将其对应左括号后的操作符(操作符栈中的)全部写入后缀...
  • } //将中缀表达式转化为后缀表达式: void ChangeToRPN(ElemType str[],int length,ElemType* &str1) //RPN指逆波兰式,也就是后缀表达式 { int j=0; str1=(char*)malloc(sizeof(char)*MaxSize); //str1是字符...
  • 如3+4*5*(2+3)这个中缀表达式; 怎么345*23+*+和34523+**+</p>
  • 中缀转后缀思想: 运算符的优先级: 运算符 级别(数字越大优先级越高) ( 1 +、- 2 *、/ 3 ) 4 扫描字符串,如果字符串是0~9的数字,添加到结果字符串中,如果是运算符,则进行一下判断:...
  • 中缀表达式转后缀表达式(c++

    万次阅读 多人点赞 2018-09-15 21:16:46
    从左至右扫描中缀表达式; 遇到操作数时,将其压s2; 遇到运算符时,比较其与s1栈顶运算符的优先级: 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈; 否则,若优先级比栈顶运算符的高,也将...
  • 中缀表达式,也就是我们常见常用的表达式一般形式: 比如 6+7*(2+3)+10/5 而后缀表达式,则是在中缀表达式基础上,进行一定规则的转换: 1、按运算符优先级对所有运算符和它的运算数加括号,(原本的括号不用加) 2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,871
精华内容 1,148
关键字:

中缀表达式转后缀c++

c++ 订阅