精华内容
下载资源
问答
  • 中缀表达式转后缀表达式,用于计算机计算功能,代码安全可靠
  • 中缀转后缀

    2015-10-11 11:34:15
    中缀转后缀java实现,并实现去处分隔符的功能
  • 在输入界面直接输入计算的表达式,本代码可将其转化成后缀形式并计算(可计算多位数,小数),另有一个方法可判断括号是否匹配。
  • 中缀转后缀表达式计算实现源码(C++、Java)
  • 表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀C++代码表达式中缀转后缀...
  • C#使用栈实现中缀转后缀表达式并计算结果。
  • 用java实现将中缀转后缀,并计算出后缀表达式的结果
  • 一个编译原理中缀转后缀表达式(递归下降翻译成AST,后序遍历得到后缀)的 Java 程序,读取文件中的中缀表达式(每个表达式以分号结束,文件中可以有多个表达式)并转换为等价的后缀表达式后输出到屏幕上, 表达式中...
  • 纯手工敲出的代码,在VC6中测试通过,可方便移植到Turbo C中,供C语言学习者使用,方便学习者改动。
  • C++基于栈的建议计算器,支持+、-、*、/ 的基本运算。输入中缀表达式,转化成后缀表达式后再输出计算结果。自动检查括号不匹配、除数为0等异常。
  • 将用户在终端输入的中缀表达式转换成后缀表达式,并对输入格式进行检查
  • 1. 中缀转前缀语言描述:从右向左遍历中缀表达式,如果是数字就压入数字栈,如果是符号就压入符号栈,如果当前符号比符号栈栈顶符号优先级小则弹出栈顶符号并压入数字栈,如果当前符号比符号栈的栈顶符号优先级大...

    中缀表达式:我们熟悉的算术表达式,如:(3+4)*5-6+8

    前缀表达式(波兰表达式):机器熟悉的算术表达式,如:+ - * + 3 4 5 6 8

    后缀表达式(逆波兰表达式):机器熟悉的算术表达式,如:3 4 + 5 * 6 - 8 +

     

    1. 中缀转前缀语言描述:从右向左遍历中缀表达式,如果是数字就压入数字栈,如果是符号就压入符号栈,如果当前符号比符号栈栈顶符号优先级小则弹出栈顶符号并压入数字栈,如果当前符号比符号栈的栈顶符号优先级大或者相等则压入符号栈,如果有括号,在遍历完括号执行完上述操作以后,括号的符号要依次弹出。依次执行,直到中缀表达式的最后一个元素。然后将符号栈的元素依次弹出压入数字栈,最后依次pop数字栈的元素,取出的结果即为前缀表达式。

    2. 中缀转前缀图解描述:

    1)

    2)

    3)

    4)

    5)

    6)

    3. 前缀表达式的计算方式文字描述:从右向左遍历表达式遇到数字入栈,遇到符号取出栈顶和次顶数字计算,计算完后再放入栈中。注意栈顶数字为被减数或者被除数

    4. 前缀表达式的计算方式画图描述:

    1)

    2)

    3)

    4)

    5)

    5. 中缀转后缀语言描述:从左向右遍历中缀表达式,如果是数字就压入数字栈,如果是符号就压入符号栈,如果当前符号比符号栈栈顶符号优先级小或者相等则弹出栈顶符号并压入数字栈,如果当前符号比符号栈的栈顶符号优先级大则压入符号栈,如果有括号,在遍历完括号执行完上述操作以后,括号的符号要依次弹出。依次执行,直到中缀表达式的最后一个元素。然后将符号栈的元素依次弹出压入数字栈,最后依次pop数字栈的元素,取出的结果即为前缀表达式。

    6. 感觉文字描述好啰嗦,直接上图:

    1)

    2)

    3)

    4)

    5)

    6)

    7. 后缀表达式计算方式文字描述:从左向右遍历表达式遇到数字入栈,遇到符号取出栈顶和次顶数字计算,计算完后再放入栈中。注意次顶数字为被减数或者被除数

    8. 后缀表达式计算方式图片描述:

    1)

    2)

    3)

    3)

    最后,前缀和中缀表达式的区别:除了遍历顺序不一致之外,符号弹出的条件也不一样,前缀表达式如果当前符号的优先级小于栈顶符号优先级则弹出栈顶符号,而后缀表达式是如果当前符号的优先级小于等于栈顶符号的优先级则弹出栈顶符号,千万不能搞混

    展开全文
  • 很好的哦~ 表达式的计算(中缀转后缀再计算) 表达式的计算(中缀转后缀再计算)
  • 分别写了中缀转后缀,用后缀进行计算的两个源文件,后来想着干脆把它们连起来做个计算器吧。两个栈的声明完全可以合成一个类模板,不过既然复制粘贴很方便,就没去修改。而且这样一个是数组栈,而另一个是链表栈,也...

    分别写了中缀转后缀,用后缀进行计算的两个源文件,后来想着干脆把它们连起来做个计算器吧。两个栈的声明完全可以合成一个类模板,不过既然复制粘贴很方便,就没去修改。而且这样一个是数组栈,而另一个是链表栈,也挺好的。
    写中缀转换栈的函数时遇到了些问题,主要是在左括号的处理上。不妨写几个中缀表达式做测试,这样可以更好地理解原理。
    简单来说,两个模块可以归成以下的思路。(参考了洛谷的题解)
    在这里插入图片描述

    #include<iostream>
    #include<string>
    #define MAX_N 10000
    using namespace std;
    class node{
    	public:
    		int data;
    		node *next;
    };
    
    //中缀转换栈 
    class Stack1{
    	public:
    		Stack1(){
    			top=-1;
    			ope= new char[MAX_N];
    		}
    		
    		~Stack1(){
    			delete ope;
    		}
    		
    		void Push(int data){
    			top= top+1;
    			ope[top]= data;
    		}
    		
    		char Pop(){
    			int temp= top;
    			top= top-1;
    			return ope[temp];
    		}
    		
    		char Top(){
    			return ope[top];
    		}
    		
    		bool isEmpty(){
    			return top==-1;
    		}
    		
    		
    	private:
    		int top;
    		char *ope;
    	
    }; 
    //后缀计算栈 
    
    class Stack2{
    	public:
    		Stack2(){
    			top= NULL;
    		}
    		
    		~Stack2(){
    			while(top!=NULL){
    				node *ptr= top;
    				top= top->next;
    				delete ptr;
    			}
    		}
    		
    		void Push(int data){
    			node *ptr= new node;
    			ptr->next= top;
    			ptr->data= data;
    			top= ptr;
    		}
    		
    		int Pop(){
    			if(isEmpty()){
    				cout <<"Error Pop:STACK EMPTY" << endl; 
    				return -1;
    			}
    			else{
    				int tempdata= top->data;
    				node *ptr= top;
    				top= top->next;
    				delete ptr;
    				return tempdata;
    		}
    		
    			}	
    		
    		int Top(){
    			if(isEmpty()){
    				cout <<"Error Top:STACK EMPTY" << endl; 
    				return -1;
    			}
    			else
    			return top->data;
    		}
    		
    		bool isEmpty(){
    			return top== NULL;
    		}
    			
    	private:
    		node *top;
    		
    }; 
    
    //优先级判断函数 
    int judge(char temp){
    	if(temp=='+'||temp=='-'){
    		return 1;
    	}
    	
    	if(temp=='*'||temp=='/'){
    		return 2;
    	}
    	
    	if(temp=='(') return 0; 
    }
    //中缀转后缀函数
    string midfixToPostfix(string midfix){
    	string postfix;
    	Stack1 stk;
    	char curr;
    
    	for(int i=0; i<midfix.length(); i++){
    		curr= midfix[i]; 
    		//数字直接输出 
    		if(curr>='0'&&curr<='9'){
    			postfix= postfix+ curr;
    		}
    		
    		//左括号直接入栈 
    		if(curr=='(') {
    			stk.Push('('); 
    		}
    		//右括号弹出元素至左括号
    		if(curr==')'){
    			while(stk.Top()!='('){
    				postfix= postfix+ stk.Pop();
    			} 
    			stk.Pop();
    		} 
    		//其他符号比较栈顶优先级 
    		if((curr<'0'||curr>'9')&&curr!='(' &&curr!=')'){
    			while(!stk.isEmpty()&&judge(curr)<=judge(stk.Top())){
    			 	postfix= postfix+ stk.Pop();
    			}
    			stk.Push(curr);
    		} 
    	}
    	
    	while(!stk.isEmpty()){
    		postfix= postfix+ stk.Pop();
    	}
    	
    	return postfix;
    }
    //后缀计算函数
    int calPostfix(string postfix){
    	Stack2 sta;
    
    	int i=0;
    	while(i<postfix.length()){
    		char curr=postfix[i]; 
    		
    		if(curr>='0'&& curr<='9'){
    			sta.Push(curr-'0');
    		}
    		
    		if(curr<'0'||curr>'9'){
    			int result= 0;
    			int numA= sta.Pop();
    			int numB= sta.Pop();
    			switch(curr){
    				case '+':  
    					result= numA+numB;
    					break;
    				case '-':  
    					result= numB-numA;
    					break;
    				case '*':  
    					result= numA*numB;
    					break;
    				case '/':  
    					result= numB/numA;
    					break;
    				default:
    					break;
    				}
    			sta.Push(result);	
    		}
    		i=i+1;
    	}
    	return sta.Top();
    
    } 
    
    
    //函数接口
    int calculate(string midfix){
    	string postfix;
    	int result;
    	postfix= midfixToPostfix(midfix);
    	result= calPostfix(postfix);
    	
    	return result;
    }
    
    
    
    string input;
    
    int main(){
    	cin >> input;
    	//cout << midfixToPostfix(input)<< endl;
    	cout << calculate(input)<< endl;
    	return 0;
    } 
    
    
    
    
    展开全文
  • 中缀表达式转后缀表达式,自己写的,编译一下就能用。 【请注意】: 1.支持小数、不支持负数 2.不支持取负(其实严格的中缀表达式也没有整体取负这一说)
  • 中缀表达式转后缀表达式 一.后缀表达式 中缀表达式就是我们平常所用的标准四则运算表达式 例如 " 9 +(3 - 1)× 3 + 10 ÷ 2 " 所有的符号都在运算数字的后面出现就叫做后缀表达式。例如 " 9 3 1 -3*+10 2 / + " 二...

    中缀表达式转后缀表达式

    一.后缀表达式
    中缀表达式就是我们平常所用的标准四则运算表达式
    例如 " 9 +(3 - 1)× 3 + 10 ÷ 2 "
    所有的符号都在运算数字的后面出现就叫做后缀表达式。例如 " 9 3 1 -3*+10 2 / + "
    二.将中缀表达式转后缀表达式
    1.规则:
    从左到右依次遍历表达式的每个数字和符号
    (1).若是数字就输出,即成为后缀表达式的一部分。
    (2).若是符号,则判断其与栈顶符号的优先级,是右括号或优先级低于栈顶符号则栈顶元素依次出栈并输出,并将当前符号进栈,一直到最终输出后缀表达式为止。
    三.代码实现

    static void ClearStack(Stack *st)
    {
    	while(!Empty(st))
    	{
    		ElemType value;
    		Top(st, &value);
    		printf("%c ", value);
    		Pop(st);
    	}
    
    	printf("\n");
    }
    
    static void DealRightPare(Stack *st)
    {
    	int flag = 0;
    	while(!Empty(st))
    	{
    		ElemType value;
    		Top(st, &value);
    		Pop(st);
    
    		if(value == '(') 
    		{
    			flag = 1;
    			break;
    		}
    
    		printf("%c ", value);
    	}
    
    	if(!flag)
    	{
    		printf("Pare is Error\n");
    	}
    }
    
    static void DealAddSub(Stack *st, char ch)
    {
    	while(!Empty(st))
    	{
    		ElemType value;
    		Top(st, &value);
    		if(value == '(') break;
    		Pop(st);
    		printf("%c ", value);
    	}
    
    	Push(st, ch);
    }
    
    static void DealMultiDiv(Stack *st, char ch)
    {
    	while(!Empty(st))
    	{
    		ElemType value;
    		Top(st, &value);
    		if(value == '(' || 
    				value == '+' || 
    				value == '-')  break;
    		Pop(st);
    		printf("%c ", value);
    	}
    
    	Push(st, ch);
    }
    
    void InfixToSuffix(char *infix_str)
    {
    	if(infix_str == NULL)  return;
    	Stack st;
    	InitStack(&st, 10);
    
    	// 遍历infix_str字符串
    	int  index = 0;
    	while(infix_str[index] != '\0')
    	{
    		if(infix_str[index] == ' ')
    		{
    			index++;
    			continue;
    		}
    
    		if(isdigit(infix_str[index])) // 判断是数字的情况
    		{
    			printf("%c", infix_str[index]);
    			if(!isdigit(infix_str[index+1]))
    			{
    				printf(" ");
    			}
    		}
    		else if(infix_str[index] == '(')  //  左括号的情况
    		{
    			Push(&st, infix_str[index]);
    		}
    		else if(infix_str[index] == ')')  //  右括号的情况
    		{
    			DealRightPare(&st);
    		}
    		else if(infix_str[index] == '+' || infix_str[index] == '-') // + - 符号的情况
    		{
    			DealAddSub(&st, infix_str[index]);
    		}
    		else if(infix_str[index] == '*' || infix_str[index] == '/') // * /符号的情况
    		{
    			DealMultiDiv(&st, infix_str[index]);
    		}
    		else
    		{
    			printf("Infix String is Error\n");
    			return;
    		}
    
    		index++;
    	}
    
    	ClearStack(&st);
    
    	DestroyStack(&st);
    }
    
    展开全文
  • 但是该表达式计算机处理起来较为麻烦,会将其写成后缀表达式,后缀表达式也叫逆波兰表达式,后缀表达式的特点是每个运算符都置于两个运算对象之后。 那么中缀表达式如何转为后缀表达式呢? 将中缀表达式:“2*(9...

            中缀表达式就是我们平时运算表达式,其特点是运算符总是处于两个运算对象之间。但是该表达式计算机处理起来较为麻烦,会将其转写成后缀表达式(具体如何通过后缀表达式求解见:C++栈的应用——后缀表达式求解),后缀表达式也叫逆波兰表达式,后缀表达式的特点是每个运算符都置于两个运算对象之后

    那么中缀表达式如何转为后缀表达式呢?

            将中缀表达式:“2*(9+6/3-5)+4”从左往右逐个字符进行遍历获得操作符,同时建立一个空栈stack。

    一、当操作符为数字时,直接打印输出

    二、当操作符为左括号时,将其存储到栈stack中成为元素符

    三、当操作符为右括号为,从栈stack中弹出栈顶元素符,并输出,直到匹配到左括号为止

    四、当操作符为运算符时,需要将其与栈顶元素符优先级做一个比较

            1、当操作符优先级大于栈顶元素符优先级的时候,直接入栈

            2、当操作符优先级小于或等于栈顶元素优先级的时候,弹出栈顶元素符并打印,并继续与下 一个栈顶元素符做比较,直到操作符优先级大于栈顶元素优先级或栈为空为止,这时操作符入栈。

    运算符优先级:

    优先级最高优先级其次优先级最低
    *     /+      -(     )

            中缀转后缀的理论就介绍到这儿,那它如何通过代码实现的呢?这里栈选用链式存储的栈,具体介绍可见C++实现栈的顺序存储与链式存储

    1、首先提供栈的基本操作函数

    /有关栈的基本操作
    //节点
    class linknode
    {
    public:
    	linknode* next;
    };
    //自定义数据
    class my_data
    {
    public:
    	linknode* node;
    	char c;
    };
    //链式栈
    class linkstack
    {
    public:
    	linknode head;
    	int size;
    };
    //初始化栈
    linkstack* init_linkstack()
    {
    	linkstack* stack=new linkstack;
    	stack->head.next=NULL;
    	stack->size=0;
    	return stack;
    }
    //入栈
    void push_linkstack(linkstack* stack,linknode* data)
    {
    	data->next=stack->head.next;
    	stack->head.next=data;
    	stack->size++;
    }
    //出栈
    void pop_linkstack(linkstack* stack)
    {
    	stack->head.next=stack->head.next->next;
    	stack->size--;
    }
    //返回栈顶元素
    linknode* top_linkstack(linkstack* stack)
    {
    	return stack->head.next;
    }

    2、一些判断函数

    //判断字符是否为数字
    int isnumber(char c)
    {
    	return c>='0' && c<='9';
    }
    //判断是否为左括号
    int isleft(char c)
    {
    	return c=='(';
    }
    //判断是否为右括号
    int isright(char c)
    {
    	return c==')';
    }
    //判断是否为运算赋
    int isoperator(char c)
    {
    	return c=='+' || c=='-' || c=='*' || c=='/';
    }
    //判断运算符优先级
    int getpriority(char c)
    {
    	if (c=='*' || c=='/')
    	{
    		return 2;
    	}
    	if (c=='+' || c=='-')
    	{
    		return 1;
    	}
    	if (c=='(' || c==')')
    	{
    		return 0;
    	}
    	return -1;
    }

    3、按转换规则的实现代码

    int main()
    {
    	linkstack* stack=init_linkstack();
    	char str[]="2*(9+6/3-5)+4";
    	for (int i = 0; i < sizeof(str)/sizeof(char); i++) //逐字符遍历str获得操作符;
    	{
    		my_data* data=new my_data;
    		data->node=NULL;
    		data->c=str[i];
    		if (isnumber(str[i])) //如果操作符为数字,直接输出
    		{
    			cout<<str[i]<<"\t";
    		}
    		if (isleft(str[i]))  //如果操作符为左括号,直接进栈
    		{
    			push_linkstack(stack,(linknode*)data);
    		}
    		if (isright(str[i])) //如果操作符为右括号从栈里往外弹元素直到弹出左括号为止
    		{
    			while (stack->size>0)
    			{
    				char* c=&((my_data*)top_linkstack(stack))->c;
    				if (isleft(*c))		//匹配到左括号弹出
    				{
    					pop_linkstack(stack);
    					break;
    				}
    				//匹配到运算符,打印运算符并弹出运算符
    				cout<<*c<<"\t";
    				pop_linkstack(stack);
    			}
    		}
    		//如果操作符是运算符
    		if (isoperator(str[i]))
    		{
    			if (stack->size==0)	//如果栈为空,操作符直接入栈
    			{
    				push_linkstack(stack,(linknode*)data);
    			}
    			else  //不是空栈则需要进行优先级比较
    			{
    				while (stack->size>0)  //操作符与栈中元素符号优先级比较
    				{
    					char* c=&((my_data*)top_linkstack(stack))->c; //栈顶元素符号
    					if (getpriority(data->c)>getpriority(*c)) //操作符符优先级高于栈中top元素符号,操作符入栈
    					{
    						push_linkstack(stack,(linknode*)data);
    						break;
    					}
    					if (getpriority(data->c)<=getpriority(*c)) //操作符优先级低于或等于栈中top元素符号,并打印并弹出栈中top元素
    					{
    						cout<<((my_data*)top_linkstack(stack))->c<<"\t";
    						pop_linkstack(stack);
    						if (stack->size==0)  //弹出top元素后栈为空,操作符直接入栈
    						{
    							push_linkstack(stack,(linknode*)data);
    							break;
    						}
    					}
    				}
    			}
    
    		}
    	}
    	//如果str遍历完了,但栈中还有元素符号,将其逐个输出,直到栈空为止
    	while (stack->size>0)
    	{
    		cout<<((my_data*)top_linkstack(stack))->c<<"\t";
    		pop_linkstack(stack);
    	}
    	cout<<endl;
    	system("pause");
    	return 0;
    }

    4、结果

    展开全文
  • 用栈实现表达式中缀转后缀 栈的特点是先进后出,可以用来将中缀表达式转换成后缀表达式,在本程序中对表达式进行了限制,数字0-9,运算符只有±*/(),缩小了问题规模。 转换思路:将表达式输入,全部数据以char型...
  • 实现了 有理数(可以负数,可以小数点)之间的加减法(允许包含括号的加减...本代码算法为本人独立实现,利用List保存后缀表达式,任何中缀表达式都可以无异常的输入输出,算法过程,每一行都注释解释清晰,保证高质量
  • 输入正常的中缀表达式,通过程序实现转化成后缀表达式,并且输出结果。 二、思路分析: 1. 输入:三个示例 2+4x6-8/2+5 2+(3x4)-5+1 3+(11)*2-6 2. 分析: 2.1 从左边开始读取,读到数字直接输出不入栈,读到...
  • 中缀转后缀表达式并计算
  • 主要为大家详细介绍了C++利用栈实现中缀表达式转后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 一、中缀转后缀表达式思路示意图 二、中缀转后缀表达式代码示例 示例需求:中缀表达式:1+((2+3)×4)-5 转换成后缀表达式:1 2 3 + 4 × + 5 – 1、代码 package ...
  • 源代码 博文链接:https://leon-a.iteye.com/blog/186104
  • 栈实现中缀转后缀

    2019-10-07 14:57:04
    这是堆栈那一节的选作实验,如下: 算法的核心规则 【显然,我们也可用树来实现这一过程】 c++实现转化代码如下 #include"pch.h" #include <iostream> #include <...using...
  • 实现效果 源码 #include<stdio.h> #include<string.h> //创建栈 typedef struct node { char s[1000]; int top; }Stack; //判断符号的函数 int weight(char ch, int flag) ...fla

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,703
精华内容 7,081
关键字:

中缀转后缀