精华内容
下载资源
问答
  • 08.中缀表达式转换后缀表达式算法.ppt
  • 堆栈实现后缀表达式算法,在winform基础上实现后缀表达式计算器
  • 中缀表达式表达直观,但是计算机不能直接计算,通常转换为前缀和后缀表达式,前缀表达式遵循“从右往左”的计算准则,而后缀表达式遵循从左往右的计算准则,后缀表达式更符合平常的计算习惯,所以通常将中缀表达式...

    中缀表达式转化为后缀表达式算法

    一.使用后缀表达式的原因

      中缀表达式表达直观,但是计算机不能直接计算,通常转换为前缀和后缀表达式,前缀表达式遵循“从右往左”的计算准则,而后缀表达式遵循从左往右的计算准则,后缀表达式更符合平常的计算习惯,所以通常将中缀表达式转化为后缀表达式。(在展示的时候,括号是省略的)
    

    二.具体实施过程

    1.创建一个代表后缀表达式的字符串A1和一个存储运算符的栈A2
    2. 从左往右遍历中缀表达式,当遇到数字时,将其加在A1的尾部;当遇到运算符时:
    1.1 如果A2为空或者A2内只有左括号,直接将当前运算符压入A2中
    1.2 否则判断当前运算符与栈顶运算符的优先级
    1.2.1 如果当前运算符的优先级不大于A2栈顶运算符的优先级,则弹出A2栈顶元素并将其加在A1的尾部;
    1.2.2 如果当前运算符的优先级大于A2栈顶运算符的优先级,则直接将当前运算符压入A2中;

    **括号处理:**在遍历的过程中,如果遇到左括号,直接将其压入A2中,如果遇到右括号,将A2内左括号以上的栈顶运算符全部弹出,此时这对括号丢弃。

    例如:中缀表达式为 5×(3+2)-8
    转化为后缀表达式为 5 3 2 × 8 -
    很多人会错误的写成 5 3 × 2 8 - 这种错误就是没有好好理解括号和1.1的规则。

    三、具体代码

    中缀转后缀

    #include<iostream>
    #include <stack>
    #include<map>
    #include<string>
    using namespace std;
    
    //中缀转后缀函数
    string mid_rear(string mid)
    {
    	stack<char>  stack1;//用来储存运算符的栈
    	char current_char;//当前的字符
    	string rear;//用来储存后缀表达式的字符串
    	//设置运算符的优先级
    	map<char, int> priority;
    	priority['+'] = 0;
    	priority['-'] = 0;
    	priority['*'] = 1;
    	priority['/'] = 1;
    	priority['^'] = 2;
    	//遍历中缀表达式
    	for (int i = 0; i < mid.length(); i++)
    	{
    		current_char = mid[i];
    		//判断当前字符是否为数字字符
    		if (isdigit(current_char))
    		{
    			rear.push_back(current_char);
    			continue;
    		}
    		switch (current_char)//当前为加减乘除运算符
    		{
    		case '+':
    		case '-':
    		case '*':
    		case '/':
    		case '^':
    			if (i > 0)//如果运算符的前一项不是右括号,则说明前一个数字输入完毕
    				//用#标识前面几个字符组成一个数字
    			{
    				if (mid[i - 1] != ')')
    					rear.push_back('#');
    			}
    			else
    				rear.push_back('#');
    			if (!stack1.empty())//判断当前栈是否为空
    			{
    				char stack_top = stack1.top();//栈顶字符
    				while (stack_top != '(' && priority[current_char] <= priority[stack_top])
    					//判断栈顶字符是否为“(”,以及当前字符和栈顶字符优先级
    				{
    					stack1.pop();//弹出栈顶字符
    					rear.push_back(stack_top);//将弹出的栈顶字符加到后缀表达式
    					if (stack1.empty())//如果栈为空,中止程序
    						break;
    					stack_top = stack1.top();//继续下一个字符操作
    				}
    			}
    			stack1.push(current_char);
    			break;
    			//当前运算符为“."
    		case '.':
    			rear.push_back(current_char);
    			break;
    			//当前运算符为“("
    		case '(':
    			stack1.push(current_char);
    			break;
    			//当前运算符为“)"
    			
    		case ')':
    			rear.push_back('#');//用”#“作为标记
    			char stack_top = stack1.top();
    			while (stack_top != '(')//将”(“之后的元素全部弹出
    				{
    					stack1.pop();
    					rear.push_back(stack_top);
    					stack_top = stack1.top();
    				}
    			stack1.pop();//去除”(“
    			break;
    			
    		}
    	}
    	if (mid[mid.size() - 1] != ')')//隔离每一个数字
    	{
    		if (isdigit(mid[mid.size() - 1]))
    			rear.push_back('#');
    	}
    	//将剩余栈内运算符依次加在后缀表达式尾部
    	while (!stack1.empty())
    	{
    		char stack_top = stack1.top();
    		rear.push_back(stack_top);
    		stack1.pop();
    	}
    	return rear;
    }
    
    int main()
    {
    	string mid;
    	cout << "please input the pression of mid " << endl;
    	cin >> mid;
    	cout << "the rear expression is:" << mid_rear(mid)<<endl;
    	system("pause");
    	return 0;
    }
    

    后缀计算

    #include<iostream>
    #include<string>
    #include<stack>
    
    using namespace std;
    //后缀表达式的计算函数
    double rear_calculation(string rear)
    {
       stack<double> stack2;//储存字符的栈
       string str;//临时储存数字字符
       double current;//储存临时数字
       double num1;
       double num2;
    
       //遍历后缀表达式
       for (std::string::iterator p = rear.begin(); p != rear.end(); p++)
       {
       	//判断字符是否为数字
       	if (isdigit(*p))
       	{
       		str.push_back(*p);
       		continue;
       	}
       	//判断字符是哪种运算符
       	switch (*p)
       	{
       	case '+':
       		num1 = stack2.top();
       		stack2.pop();
       		num2 = stack2.top();
       		stack2.pop();
       		stack2.push(num1 + num2);
       		break;
       	case '-':
       		num1 = stack2.top();
       		stack2.pop();
       		num2 = stack2.top();
       		stack2.pop();
       		stack2.push(num2 - num1);
       		break;
       	case '*':
       		num1 = stack2.top();
       		stack2.pop();
       		num2 = stack2.top();
       		stack2.pop();
       		stack2.push(num1 * num2);
       		break;
       	case '/':
       		num1 = stack2.top();
       		stack2.pop();
       		num2 = stack2.top();
       		stack2.pop();
       		stack2.push(num2 / num1);
       		break;
       	case '^':
       		num1 = stack2.top();
       		stack2.pop();
       		num2 = stack2.top();
       		stack2.pop();
       		stack2.push(pow(num2,num1));//求次方
       		break;
       	case '.':
       		str.push_back(*p);
       		break;
       	case '#':
       		current = atof(str.c_str());//将字符转换为浮点数
       		str.clear();
       		stack2.push(current);
       		break;
       	}
       	
       		
       }
       current = stack2.top();
       return current;
    
    }
    
    int main()
    {
       string rear;
       cout << "please input the expression of rear:" << endl;
       cin >> rear;
       cout << "the result of rear is: " << rear_calculation(rear) << endl;
       system("pause");
       return 0;
    }
    
    展开全文
  • 中缀表达式转后缀表达式的方法: 1.遇到操作数:直接输出(添加到后缀表达式中) 2.栈为空时,遇到运算符,直接入栈 3.遇到左括号:将其入栈 4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左...

    算法:
    中缀表达式转后缀表达式的方法:
    1.遇到操作数:直接输出(添加到后缀表达式中)
    2.栈为空时,遇到运算符,直接入栈
    3.遇到左括号:将其入栈
    4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。
    5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
    6.最终将栈中的元素依次出栈,输出。
    例如
    a+bc+(de+f)g ----> abc+def+g+
    遇到a:直接输出:
    后缀表达式:a
    堆栈:空
    遇到+:堆栈:空,所以+入栈
    后缀表达式:a
    堆栈:+
    遇到b: 直接输出
    后缀表达式:ab
    堆栈:+
    遇到*:堆栈非空,但是+的优先级不高于*,所以入栈
    后缀表达式: ab
    堆栈:
    +
    遇到c:直接输出
    后缀表达式:abc
    堆栈:+
    遇到+:堆栈非空,堆栈中的
    优先级大于+,输出并出栈,堆栈中的+优先级等于+,输出并出栈,然后再将该运算符(+)入栈
    后缀表达式:abc*+
    堆栈:+
    遇到(:直接入栈
    后缀表达式:abc*+
    堆栈:(+
    遇到d:输出
    后缀表达式:abc*+d
    堆栈:(+
    遇到*:堆栈非空,堆栈中的(优先级小于*,所以不出栈
    后缀表达式:abc*+d
    堆栈:(+
    遇到e:输出
    后缀表达式:abc
    +de
    堆栈:(+
    遇到+:由于
    的优先级大于+,输出并出栈,但是(的优先级低于+,所以将出栈,+入栈
    后缀表达式:abc
    +de*
    堆栈:+(+
    遇到f:输出
    后缀表达式:abc*+def
    堆栈:+(+
    遇到):执行出栈并输出元素,直到弹出左括号,所括号不输出
    后缀表达式:abc
    +def+
    堆栈:+
    遇到
    :堆栈为空,入栈
    后缀表达式: abc*+def+
    堆栈:
    +
    遇到g:输出
    后缀表达式:abc*+def+g
    堆栈:
    +
    遇到中缀表达式结束:弹出所有的运算符并输出
    后缀表达式:abc*+def+g+
    堆栈:空

    展开全文
  • 中缀表达式转后缀表达式算法

    千次阅读 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. 在这里插入图片描述
      在这里插入图片描述
      这里进行了测试,结果是没有问题的,但因为时间有限,不能测试更多的表达式,大家感兴趣的话欢迎测试,如果出现问题,欢迎来投稿评论,此代码是我从头到尾敲下来的,所以我并不敢保证没有问题,但是我还是希望可以帮助大家去理解这个算法。
    展开全文
  • (七)中缀表达式转换后缀表达式算法

    千次阅读 2014-01-19 15:34:30
    后缀表达式:不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:21 + 3 * 前缀表达式:同后缀表达式一样,不包含括号,运算符放在两个...

    表达式的三种形式

    中缀表达式:运算符放在两个运算对象中间,如:(2+1)*3
    后缀表达式:不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:21 + 3 *
    前缀表达式:同后缀表达式一样,不包含括号,运算符放在两个运算对象的前面,如:*+ 2 1 3 
    表达式的转换
    将中缀表达式转换为后缀表达式:

    (1)当读到数字直接送至输出队列中;

    (2)当读到运算符t时:

        a.将栈中所有优先级高于或等于t的运算符弹出,送到输出队列中;

      这句话不好理解,可以说成这样,从栈顶开始,依次弹出比当前处理的运算符优先级高的运算符,直到一个比它优先级低的或者遇到了一个左括号就停止。

        b.t进栈;

    (3)读到左括号时总是将它压入栈中;

    (4)读到右括号时,将靠近栈顶的第一个左括号上面的运算符全部依次弹出,送至输出队列后,再丢弃左括号;

    (5)中缀表达式全部读完后,若栈中仍有运算符,将其送到输出队列中。

    中缀表达式:3+(2-5)*6/3转换为后缀表达式的过程:

    后缀表达式              栈

    3

    3                        +

    3                        +(

    32                       +(

    32                       +(-

    325                      +(-

    325-                     +

    325-                     +*

    325-6                    +*

    325-6*                   +/

    325-6*3                  +/

    325-6*3/+

    最终后缀表达式为:325-6*3/+

    运用后缀表达式进行计算:

     (1)建立一个栈S;

     (2)从左到右读后缀表达式,读到数字就将它转换为数值压入栈S中,读到运算符则从栈中依次弹出两个数分别到Y和X,然后以“X 运算符Y”的形式计算机出结果,再压加栈S中;

     (3)如果后缀表达式未读完,就重复上面过程,最后输出栈顶的数值则为结束。

    3+(2-5)*6/3=-3,其后缀表达式为:325-6*3/+
    运算过程如下:

    栈            运算

    3 2 5                          325入栈

    3               2-5=-3

    3 -3                           运算结果进栈

    3 -3 6

    3               -3*6=-18

    3 -18 3         -18/3=-6     

    3 -6            3+(-6)=-3 

    -3


    import java.util.Stack;
    import java.util.regex.*;
    
    public class StringToArithmetic {
    	
    	private StringToArithmetic() {
    	}
    
    	/**
    	 * 给出一个算术表达式,返回结果。 例如 (5+8+10)*1,返回23
    	 * 
    	 * @param string
    	 */
    	public static double stringToArithmetic(String string) {
    		return suffixToArithmetic(infixToSuffix(string));
    	}
    
    	/**
    	 * 中缀表达式转后缀表达式 只处理了+,-,*,/和括号,没有处理负号及其它运算符,也没对前缀表达式验证。
    	 * 如要处理负号,可对表达式进行预转义处理,当下面条件成立时,将负号换成单目运算符"!" infix.charAt[i]=='-'&&(
    	 * i==0||infix.charAt[i-1]=='(')
    	 * 3*6/4+3                    
    	 * 3+6-4           3 6 + 4 -
    	 * 3+(6-4/2)*5    3 6 4 2 / - 5 * +
    	 */
    	public static String infixToSuffix(String infix) {
    		Stack<Character> stack = new Stack<Character>();
    		String suffix = "";
    		int length = infix.length();
    		for (int i = 0; i < length; i++) {
    			Character temp;
    			char c = infix.charAt(i);
    			switch (c) {
    			// 忽略空格
    			case ' ':
    				break;
    			// 碰到'(',push到栈
    			case '(':
    				stack.push(c);
    				break;
    			// 碰到'+''-',将栈中所有运算符弹出,送到输出队列中
    			case '+':
    			case '-':
    				while (stack.size() != 0) {
    					temp = stack.pop();
    					if (temp == '(') {
    						stack.push('(');
    						break;
    					}
    					suffix += " " + temp;
    				}
    				stack.push(c);
    				suffix += " ";
    				break;
    			// 碰到'*''/',将栈中所有乘除运算符弹出,送到输出队列中
    			case '*':
    			case '/':
    				while (stack.size() != 0) {
    					temp = stack.pop();
    					if (temp == '(' || temp == '+' || temp == '-') {
    						stack.push(temp);
    						break;
    					} else {
    						suffix += " " + temp;
    					}
    				}
    				stack.push(c);
    				suffix += " ";
    				break;
    			// 碰到右括号,将靠近栈顶的第一个左括号上面的运算符全部依次弹出,送至输出队列后,再丢弃左括号
    			case ')':
    				while (stack.size() != 0) {
    					temp = stack.pop();
    					if (temp == '(')
    						break;
    					else
    						suffix += " " + temp;
    				}
    				// suffix += " ";
    				break;
    			 //如果是数字,直接送至输出序列
    			 default:
    				suffix += c;
    			}
    		}
    		
    		//如果栈不为空,把剩余的运算符依次弹出,送至输出序列。
    		while (stack.size() != 0)
    		{
    			suffix += " " + stack.pop();
    		}
    		return suffix;
    	}
    
    	
    
    	/**
    	 * 通过后缀表达式求出算术结果
    	 * 
    	 * @param String
    	 * postfix
    	 * @return double
    	 */
    	public static double suffixToArithmetic(String postfix) {
    		
    		Pattern pattern = Pattern.compile("\\d+||(\\d+\\.\\d+)"); //使用正则表达式 匹配数字
    		String strings[] = postfix.split(" ");
    		for (int i = 0; i < strings.length; i++)
    			strings[i].trim();
    		Stack<Double> stack = new Stack<Double>();
    	
    		for (int i = 0; i < strings.length; i++) {
    
    			if (strings[i].equals(""))
    				continue;
    			
    			//如果是数字,则进栈
    			if ((pattern.matcher(strings[i])).matches()) {
    
    				stack.push(Double.parseDouble(strings[i]));
    			} else {  
                    //如果是运算符,弹出运算数,计算结果。
    				double y = stack.pop();
    				double x = stack.pop();
    				stack.push(caculate(x, y, strings[i])); //将运算结果重新压入栈。
    			}
    		}
    		return stack.pop(); //弹出栈顶元素就是运算最终结果。
    
    	}
    
    	private static double caculate(double x, double y, String simble) {
    		if (simble.trim().equals("+"))
    			return x + y;
    		if (simble.trim().equals("-"))
    			return x - y;
    		if (simble.trim().equals("*"))
    			return x * y;
    		if (simble.trim().equals("/"))
    			return x / y;
    		return 0;
    	}
    }



    展开全文
  • #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 *...
  • 中缀表达式转为后缀表达式是实现逆波兰计算器的核心算法,其使用栈(stack) 这一数据结构实现。本文转化算法(java版本)支持 整数和括号的计算表达式转换。
  • 后缀表达式:不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:2 1 + 3 * 前缀表达式:同后缀表达式一样,不包含括号,运算符放在两个...
  • 后缀表达式算法例子

    2015-06-10 10:49:27
    // 把中缀表达式转换为后缀表达式,返回后缀表达式的长度(包括空格) void postfix(char pre[] ,char post[],int &n) {  int i = 0 ,j=0;  MyStack<char> stack;  stack.init(); // 初始化存储操作...
  • 计算机在计算并且处理这种表达式时,需要将中缀表达式转换成后缀表达式,然后再进行计算。 中缀表达式:0.3/(5*2+1) 的等价后缀表达式是:0.3 5 2 * 1 + /  中缀表达式转后缀表达式遵循以下原则:  1.遇到...
  • printf("请输入您要转换为后缀表达式的中缀表达式,支持± /()及0-9数值的输入以#为结束标志:\n"); input=getchar(); while(input!=’#’) { if(input>=‘0’&&input‘9’) { push(temp,input); }else { //...
  • 因为要用到四则混合运算,写了一个工具类,是基于后缀表达式的实现   package com.eden.door.util; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; import java.util....
  • 中缀表达式转换为后缀表达式算法

    千次阅读 2008-06-07 21:23:00
    由中缀表达式转换为后缀表达式的规则可知:转换前后,表达式中的数值项的次序不变,而运算符的次序发生了变化,由处在两个运算对象的中间变为处在两个运算对象的后面,同时去掉了所有的括号。为了使转换正确,必须...
  • 把中缀表达式转换为后缀表达式,返回后缀表达式的长度(包括空格) void postfix( char pre[] , char post[], int &n) { int i = 0 ,j= 0 ; MyStack< char > stack; stack.init(); // 初始化存储...
  • 由中缀表达式转换为后缀表达式的规则可知:转换前后,表达式中的数值项的次序不变,而运算符的次序发生了变化,由处在两个运算对象的中间变为处在两个运算对象的后面,同时去掉了所有的括号。为了使转换正确,必须...
  • ... 设以’@’字符作为结束符的中缀算术表达式已经保存在...由中缀表达式转换为后缀表达式的规则可知:转换前后,表达式中的数值项的次序不变,而运算符的次序发生了变化,由处在两个运算对象的中间变为处在两个运...
  • #include #include #include using namespace std; void main() { stack S; string m; cout cin >> m; int l = m.length(); for (int i = 0; i { switch (m[i]) ...{double a = S.to
  • 今天又看了中缀转后缀表达式算法,才知道这个有名字交调度场算法(Shunting-yard algorithm,因过程类似火车编组场而得名),居然是Dijstra发明的,原来的贡献遍布CS各个角落。。。 之前知道Shortest path,银行家,...
  • General Infix-to-Postfix...中缀转后缀算法 We need todevelop an algorithm to convert any infix expression to a postfix expression.To do this we will look closer at the conversion process. 现在我们要开发
  • 理论: (这部分很重要,看明白了,可以写出实现算法) 表达式的表示形式有中缀、前缀和后缀3中形式。... 后缀表达式中只有操作数和操作符。操作符在两个操作数之后。它的计算规则非常简单,严格按照
  • 用数组实现的类似栈功能的C语言后缀表达式算法
  • (1) 从键盘或文件读入一个合法的算术表达式,输出相应的后缀表达式后缀表达式中,数据与数据之间加分隔符; (2) 输出正确的计算结果,保留两位小数点; (3) 考虑算法的健壮性,当表达式错误时,要给出错误...
  • 中缀表达式,即运算符在操作数中间。 计算中缀表达式时,逐个扫描表达式。 扫描时存入两个栈,操作数栈,和运算符栈。 例如 3*2^(4+2*2-1*3)-5  扫描表达式。 操作数栈以 栈$表示,运算符栈以 栈¥表示。 扫描...
  • 计算后缀表达式算法
  • 中缀表达式转换为后缀表达式算法

空空如也

空空如也

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

后缀表达式算法