精华内容
下载资源
问答
  • 计算后缀表达式
    千次阅读
    2019-09-25 09:14:52

    题目描述

    我们经常遇到的数学计算表达式如:(2+1)*3,成为中缀表达式,这种表达式对于我们来说很容易理解,但是计算机容易理解的形式却是后缀表达式,即,将运算符写在两个运算符的后面,如上述中缀表达式的后缀表达式为:21+3*。计算机计算后缀表达式的过程为,从左到右,遍历表达式,如果当前位是数字,那么先将其暂存,继续往后遍历;如果碰到运算符,那么就取出最近暂存的两个数字,并计算出值,然后将该值继续暂存,直到遍历结束,此时输出暂存区的数字即可。

    说明:其中后缀表达式的开头存储在栈顶,后缀表达式的最后一位存储在栈底。

    Java代码如下

    /**
     * Main_HouZui
     * 中缀表达式为 (2+3)*5/25
     * 计算后缀表达式的值,23+5*25/
     */
    import java.util.Stack;
    public class Main_HouZui 
    {
    
        public static int calculate (int first, int second, String operator)
        {
            int result = 0;
            switch(operator)
            {
                case "+":
                    result = first + second;
                    break;
                case "-":
                    result = first - second;
                    break;
                case "*":
                    result = first * second;
                    break;
                case "/":
                    result = first/second;
                    break;
            }
            return result;
        }
        //stack栈中存放的是后缀表达式 23+5*25/
        public static int function(Stack<String> stack)
        {
            // 碰到运算符,那么就取出最近暂存的两个数字,并计算出值,然后将该值继续暂存到result
            Stack<Integer> result = new Stack<Integer>();
            while(!stack.isEmpty())
            {
                String element = stack.pop();//取栈顶元素
                try
                {
                    //将String 的 1 转为 Integer,遇到 String "+"则有异常了,转到catch语句
                    result.push(Integer.valueOf(element));
                }
                catch(Exception e)
                {
                    int b = result.pop();
                    int a = result.pop();
                    result.push(calculate(a, b, element));
                }
            }
            return result.pop();
        }
        public static void main(String[] args) 
        {
            Stack<String> s = new Stack<>();
            s.push("/");
            s.push("25");
            s.push("*");
            s.push("5");
            s.push("+");
            s.push("3");
            s.push("2");
    
            System.out.println(function(s));
        }
    }

     

    更多相关内容
  • 输入一表达式,将其用表达式树表示,并用表达式计算表达式
  • ////数字与运算符直接要有空格 //#include //#include //#include //#include //using namespace std; //char s[10000]; //stack<int> p; //long long x,y; //int main(){ ...// y=p.t
  • 该程序实现了运算表达式转换为中缀表达式、中缀表达式转换为后缀表达式后缀表达式。该程序已实现加减乘除括号运算符及求余、幂指数的求解
  • 本文实例为大家分享了C语言实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 中缀表达式转换为后缀表达式(思路) 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一:遇到左...
  • 本文实例为大家分享了C++实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 题目:现有中缀表达式如:1+(2-3)*4+10/5 请用栈的特性编写一个程序,使得程序输出后缀表达式 分析如下: STEP1: 1+(2-3)...
  • 后缀表达式:就是将运算符挪到操作数后面,但这样的挪动是有规则的,例如上式转换后缀表达式后是这样的:"9 3 1-4*+10 2/+" 中缀转后缀表达式规则: 从左到右遍历中缀表达式中的每一个·数字和符号: 1.如果是...

     中缀表达式:也就是一般的算术表达式,如"9+(3-1)*3+10/2这样的

    后缀表达式:就是将运算符挪到操作数后面,但这样的挪动是有规则的,例如上式转换后缀表达式后是这样的:"9 3 1-4*+10 2/+"

    中缀转后缀表达式规则:

    从左到右遍历中缀表达式中的每一个·数字和符号:

    1.如果是操作数就输出,成为后缀表达式的一部分

    2.如果是运算符,先判定它与栈顶元素的优先级,如果栈顶元素优先级低比它低或相等,则入栈;

      如果优先级高于它,则出栈当前栈顶元素到后缀表达式中,直到栈顶元素优先级比它高(即便两者优先级相等,也出栈)

     然后在将此运算符进栈(如果出栈过程中遇到‘(’,停止出栈,将 此运算符进栈);

    3.如果是‘(',直接进栈;

    4.如果是‘)',将栈中元素出栈,放入后缀表达式中,直到遇到‘('为止,并且‘('也要被出栈,但不可以放入后缀表达式中,直接丢弃;


    代码实现:

    俺是先用一个字符串数组接收输入的中缀表达式,但是不能直接对这个字符数组直接转后缀 表达式,如果直接转,会发生多个操作数连在一起

    无法区分的情况,例如这样"931-4*+10 2/+",9,3,1三个不同操作数连在一起成了一个操作数了, 为了避免这种状况,俺使用了一个指针数组,

    将每个操作数从字符串数组中分离出来,并放在指针数组所指向的动态内存中,以此来将每个操作数区分开来,在将经过转换的表达式转换成

    后缀表达式。

    将字符串数组中的中缀表达式进行转换,防止操作数连在一起:

    void checkInputConvert(char * infix, char ** opNum)
    {
    	int index1 = 0;
    	int length = strlen(infix);
    	for (int i = 0; i < length;)
    	{
    		char ch = infix[i];
    		int index2 = 0;
    		int charNum = 0;
    		if (isNumber(ch))//判断是否是数字
    		{
    			
    			charNum++;
    			opNum[index1] = (char*)calloc(charNum + 1,sizeof(char));
    			opNum[index1][index2++] = ch;
    			while (isNumber(infix[i + charNum]))
    			{
    				charNum++;//统计单个操作数所包含的字符个数
    				opNum[index1] = (char*)realloc(opNum[index1], sizeof(char)*(charNum + 1));
    				opNum[index1][index2++] = infix[i + charNum - 1];
    			}
     			i += charNum;
    			opNum[index1++][index2] = '\0';//设置字符串结束符
    			continue;//单个操作数已找完,跳出此次循环
    		}
    
    		if (isOperator(ch))//判断是否是操作符
    		{
    			opNum[index1] = (char*)calloc(2, sizeof(char));
    			opNum[index1++][index2] = ch;
    			i++;
    			continue;
    		}
    
    		if (ch == '(' || ch == ')')
    		{
    			opNum[index1] = (char*)calloc(2, sizeof(char));
    			opNum[index1++][index2] = ch;
    			i++;
    			continue;
    		}
    		printf("输入的数据有误,请重新输入!\n");
    		exit(1);
    	}
    这其中还要用到其他判断函数,如下:

    int isOperator(char ch)//判断是否是运算符
    {
    	char op[5] = "+-*/";
    	for (int i = 0; i < 5; i++)
    	{
    		if (ch == op[i])
    			return 1;
    	}
    	return 0;
    }
    int isNumber(char ch)
    {
    	if ((ch - '0') >= 0 && (ch - '0') <= 9)
    		return 1;
    	else
    		return 0;
    }
    
    //比较优先级,ch未中缀表达式中的运算符,op为栈中的运算符或‘(’
    //当op1的优先级小于op2的优先级时返回-1,大于时返回1,等于时返回0
    int comparePrior(char op1, char op2)
    {
    	if (op1 == '+' || op1 == '-')
    	{
    		if (op2 == '*' || op2 == '/')
    			return -1;
    		if (op2 == '+' || op2 == '-')
    			return 0;
    	}
    
    	if (op1 == '*' || op1 == '/')
    	{
    		if (op2 == '*' || op2 == '/')
    			return 0;
    		if (op2 == '+' || op2 == '-')
    			return 1;
    	}
    	if (op2 == '(')
    		return 1;
    }

    再将将转换后的中缀表达式,转换为后缀表达式:

    void infixToPrefix(char ** infix,char** prefix )//中缀表达式转后缀
    {
    	stack<char> LS;
    	int index1 = 0;//指向infix中的下标
    	int index2 = 0;//指向prefix中的下标
    	while (infix[index1] != NULL)
    	{
    			char ch = infix[index1][0];
    			if (ch == '(')//左括号入栈
    			{
    				LS.push(ch);
    				index1++;//指向下一个字符串
    				continue;
    			}
    			if (isNumber(ch))//数字输出到temp中
    			{
    				int length = strlen(infix[index1]);
    				prefix[index2] = (char*)calloc(length + 1, sizeof(char));//测定该操作数所包含字符个数,并分配空间
    				prefix[index2][length] = '\0';
    				strcpy(prefix[index2++], infix[index1++]);//将字符串拷贝过来
    
    				continue;
    			}
    			if (isOperator(ch))//判断是不是操作符
    			{
    				if (LS.empty())//栈空不比较,直接入栈
    				{
    					LS.push(ch);
    					index1++;
    				}
    				else
    				{
    					if (comparePrior(ch, LS.top()) >= 0)//优先级高直接入栈
    					{
    						LS.push(ch);
    					}
    					else//优先级低需要将栈中优先级比ch高或等于的全部出栈
    					{//如果有多个操作符出栈,将会把这些操作符存在同同一指针指向的字符数组中
    						int num = 0;//记录要出栈的操作符的个数
    						char temp[100] = { 0 };//用来暂存出栈的存操作符
    						temp[num++] = LS.top();
    						LS.pop();
    						while (!LS.empty() && comparePrior(ch, LS.top()) <= 0)
    						{
    							temp[num++] = LS.top();
    							LS.pop();
    						}
    						LS.push(ch);//所有比ch优先级大于等于的操作符已经出栈完成,将ch入栈
    						prefix[index2] = (char *)calloc(++num, sizeof(char));
    						prefix[index2][--num] = '\0';
    						strcpy(prefix[index2++], temp);
    					}
    					index1++;
    				}
    				continue;
    			}
    			if (ch == ')')
    			{
    				int num = 0;//记录要出栈的操作符的个数
    				char temp[100] = { 0 };//用来暂存出栈的存操作符
    				while (LS.top() != '(')
    				{
    					temp[num++] = LS.top();
    					LS.pop();
    				}
    				LS.pop();//将‘(’出栈
    				prefix[index2] = (char *)calloc(++num, sizeof(char));
    				prefix[index2][--num] = '\0';
    				strcpy(prefix[index2++], temp);
    				index1++;
    				continue;
    			}
    		}
    		if (!LS.empty())
    		{
    			int num = 0;//记录要出栈的操作符的个数
    			char temp[100] = { 0 };//用来暂存出栈的存操作符
    			while (!LS.empty())//此时中缀表达式已扫完,若栈中有剩余操作符,全部弹出,追加到prefix中
    			{
    				temp[num++] = LS.top();
    				LS.pop();
    			}
    			prefix[index2] = (char *)calloc(++num, sizeof(char));
    			strcpy(prefix[index2], temp);
    
    		}
    }

    此时中缀表达式已转换未后缀表达式,计算后缀表达式的值:

    算法过程自己百度......

    int calcPrefix(char ** prefix)//计算后缀表达式求值
    {
    	stack<double> LS;
    	int index1 = 0;
    	while (prefix[index1] != NULL)
    	{
    		int index2 = 0;
    		char ch;
    		if (isNumber(ch = prefix[index1][index2]))
    		{
    			double opNum = ch - '0';
    			while ((ch = prefix[index1][++index2]) != '\0')
    				opNum = opNum * 10 + (ch - '0');
    			LS.push(opNum);
    			index1++;
    			continue;
    		}
    
    		flag:
    		if (isOperator(ch = prefix[index1][index2]))
    		{
    
    			switch (ch)
    			{
    				case '+':
    					{
    						double opNum1 = LS.top();
    						LS.pop();
    						double opNum2 = LS.top();
    						LS.pop();
    						LS.push(opNum1 + opNum2);
    						while ((ch = prefix[index1][++index2]) != '\0')
    							goto flag;
    						index1++;
    						break;
    					}
    				case '-':
    					{
    						double opNum1 = LS.top();
    						LS.pop();
    						double opNum2 = LS.top();
    						LS.pop();
    						LS.push(opNum2 - opNum1);
    						while ((ch = prefix[index1][++index2]) != '\0')
    							goto flag;
    						index1++;
    						break;
    					}
    			case '*':
    					{
    						double opNum1 = LS.top();
    						LS.pop();
    						double opNum2 = LS.top();
    						LS.pop();
    						LS.push(opNum2 * opNum1);
    						while ((ch = prefix[index1][++index2]) != '\0')
    							goto flag;
    						index1++;
    						break;
    					}
    			case '/':
    					{
    						double opNum1 = LS.top();
    						LS.pop();
    						double opNum2 = LS.top();
    						LS.pop();
    						LS.push(opNum2 / opNum1);
    						while ((ch = prefix[index1][++index2]) != '\0')
    							goto flag;
    						index1++;
    						break;
    					}
    			}
    			continue;
    		}
    	}
    	return (LS.top());
    }

    最后就是主函数了:

    #define  _CRT_SECURE_NO_WARNINGS
    #include<stack>
    #include<string.h>
    #include<stdio.h>
    using namespace::std;
    int isOperator(char ch);//判断是否是运算符
    int comparePrior(char op1,char op2);//比较优先级
    int isNumber(char ch);
    void infixToPrefix(char ** infix, char ** prefix);//中缀表达式转后缀
    int calcPrefix(char ** prefix);//计算后缀表达式求值
    void checkInputConvert(char * ch,char ** infix);//将输入的字符串转换为合理的中缀表达式
    int main()
    {
    	
    	while (1)
    	{
    		char ch[100] = "12+33-5*65/10+((343+34)*2)*3/4+34";
    		char * infix[100] = { 0 };
    		char * prefix[100] = { 0 };
    		//printf("请输入要计算的表达式:\n");
    		//scanf("%s", ch);
    		printf("输入的中缀表达式为:%s\n", ch);
    		checkInputConvert(ch, infix);
    		char** p = infix;
    		while (*p != NULL)
    		{
    			printf("%s", *p);
    			p++;
    		}
    		infixToPrefix(infix, prefix);
    
    		printf("\n%d\n",calcPrefix(prefix));
    		system("pause");
    
    	}
    	return 0;
    }

    写的不好。。。。。


    展开全文
  • 计算后缀表达式 一道很经典的题目。建议做一下
  • 后缀表达式不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 *。利用栈结构,将中缀表达式转换为后缀表达式。...
  • C语言计算后缀表达式,从控制台输入,以空格为分割输入,支持多位数和负数运算,支持加、减、乘、除、阶乘操作,支持表达式错误检测异常。 input: 3 1 -2 * 1 10 - 6 + 3 1 - ! Output: -2 -3 2 #include<...

    C语言计算后缀表达式,从控制台输入,以空格为分割输入,支持多位数和负数运算,支持加、减、乘、除、阶乘操作,支持表达式错误检测异常。

    input:
    3
    1 -2 *
    1 10 - 6 +
    3 1 - !
    Output:
    -2
    -3
    2

    #include<stdio.h>
    #include <ctype.h>
    #include<string.h>
    #include<stdlib.h>
    #define MAX 1000
    #define NUMMAX 100
    typedef struct stack
    {
    	int data[MAX];
    	int top;
    }stack;
    
    int func(int op);
    void init(stack*);
    int empty(stack*);
    int full(stack*);
    int pop(stack*);
    void push(stack*, int);
    int evaluate(char x, int op1, int op2);
    
    int main()
    {
    	stack s;
    	char x;
    	int op1, op2, val, num;
    	int flag = 0;
    	init(&s);
    	scanf_s("%d", &num);
    	getchar();
    	int result[1000];
    
    	char str[1000][1024];
    	for (int i = 0; i < num; ++i)
    	{
    		gets_s(str[i]);
    	}
    	
    	for (int i = 0; i < num; ++i)
    	{
    		int j = 0;
    		while(j < strlen(str[i]))
    		{
    			x = str[i][j];
    			int digitNum = 0 , sign = 0;
    			char* digitnum = (char*)malloc(1024*sizeof(char));
    			//char* digitnum = new char(100 * sizeof(char));
    			if (isdigit(x))
    			{
    				while (str[i][j] != ' ' && str[i][j] != '\0')
    				{
    					digitnum[sign] = str[i][j];
    					j++;
    					sign++;
    				}
    				digitNum = atoi(digitnum);
    				if (flag == 0) push(&s, digitNum);
    				if (flag == -1)
    				{
    					push(&s, digitNum * flag);
    					flag = 0;
    				}
    			}
    			if (x == ' ')
    			{
    				j++;
    				continue;
    			}
    			if (x == '-' && str[i][j+1] != ' ')
    			{
    				flag = -1;
    				j++;
    				continue;
    			}
    			if(x == '+' || x == '-' || x == '*' || x == '/' || x == '!')
    			{
    				if (x == '!')
    				{
    					op2 = pop(&s);
    					op1 = 1;
    				}
    				else
    				{
    					op2 = pop(&s);
    					op1 = pop(&s);
    				}
    				
    				val = evaluate(x, op1, op2);
    				if (val == -9999 || val == -1111)
    				{
    					push(&s, val);
    					break;
    				}
    				else {
    					push(&s, val);
    				}
    			}
    			j++;
    			free(digitnum);
    		}
    		val =  pop(&s);
    		result[i] = val;
    		
    		init(&s);
    	}
    	for (int j = 0; j < num; ++j)
    	{
    		if(result[j] == -9999)
    		{
    			printf("division by zero\n");
    
    		}
    		else if (result[j] == -1111)
    		{
    			printf("factorial of an negative number\n");
    		}
    		else
    		{
    			printf("%d\n", result[j]);
    		}
    
    	}
    	return 0;
    }
    
    int evaluate(char x, int op1, int op2)
    {
    	if (x == '+')
    		return(op1 + op2);
    	if (x == '-')
    		return(op1 - op2);
    	if (x == '*')
    		return(op1 * op2);
    	if (x == '/')
    	{
    		if (op2 == 0)
    		{
    			return -9999;
    		}
    		else
    		{
    			return(op1 / op2);
    		}
    	}
    			
    	if (x == '!')
    	{
    		if ( op2 >= 0)
    		{
    			return func(op2);
    		}
    		if(op2 < 0)
    		{
    			return -1111;
    		}
    	}
    		
    }
    
    int func(int n)
    {
    	int sum = 1;
    	for (int i = 1; i <= n; ++i)
    	{
    		sum = sum * i;
    	}
    	
    	return sum;
    }
    
    void init(stack* s)
    {
    	s->top = -1;
    }
    
    int empty(stack* s)
    {
    	if (s->top == -1)
    		return(1);
    
    	return(0);
    }
    
    int full(stack* s)
    {
    	if (s->top == MAX - 1)
    		return(1);
    
    	return(0);
    }
    
    void push(stack* s, int x)
    {
    	s->top = s->top + 1;
    	s->data[s->top] = x;
    }
    
    int pop(stack* s)
    {
    	int x;
    	if (s->top == -1)
    	{
    		return 8888;
    	}
    	else
    	{
    		x = s->data[s->top];
    		s->top = s->top - 1;
    	}
    	
    
    	return(x);
    }
    
    展开全文
  • java使用后缀表达式实现计算器,其中有将一般数学运算式(7-9+5/5-5*6)转换成后缀表达式的方法,以及后缀表达式的求解方法
  • 【数据结构】计算后缀表达式

    千次阅读 2019-01-20 17:33:46
    我们平常使用的计算表达式都是中缀表达式,而输入计算机后会转换为后缀表达式,即计算机只能计算后缀表达式,那么如何将一个中缀表达式转换为一个后缀表达式? 算法 1)从左到右扫描后缀表达式字符串 2)初始化一...

    如何实现栈

    如何利用栈将中缀表达式转换为后缀表达式

    题目

    我们平常使用的计算表达式都是中缀表达式,而输入计算机后会转换为后缀表达式,即计算机只能计算后缀表达式,那么如何计算机是如何计算后缀表达式的值的呢?

    算法

    1)从左到右扫描后缀表达式字符串
    2)初始化一个空栈
    3)如果扫描到数字,那么就直接入栈
    4)如果被扫描的字符是一个二元运算符,那么就连续出栈两次,获得两个字符,元素出栈后,应用运算符进行计算,并将结果压栈
    5)重复3)和4)的操作,直至扫描完字符串
    6)扫描完所有字符串之后,栈中只剩一个元素,该元素就是最终结果,将其出栈并返回。

    Java版本实现

    	
    	//计算后缀表达式算法
        static Double calculator(String curString) {
            LLStack<Double> stack = new LLStack<>();
            for(int i = 0; i < curString.length(); i++) {
                String t = curString.substring(i , i + 1 );
                if(t.charAt(0) >= '0' && t.charAt(0) <= '9' ) {
                    //数字直接入栈
                    stack.push(Double.parseDouble(t));
                }else {
                    double a , b = 0;
                    a =(Double) stack.pop();
                    b =(Double) stack.pop();
                    switch(t){
                        case "*" : stack.push(b * a);System.out.println(t+":" + b * a);break;
                        case "/" : stack.push(b / a);System.out.println(t+":" + b / a);break;
                        case "+" : stack.push(b + a);System.out.println(t+":" + (double)(b + a));break;
                        case "-" : stack.push(b - a);break;
                        case "%" : stack.push(b % a);break;
                    }
                }
            }
            return stack.pop() ;
        }
    
    栈的实现
    class LLNode<T>{
        private T data;
        private LLNode next = null;
    
        public LLNode(T d){
            data = d;
        }
        public T getData() {
            return data;
        }
        public void setData(T data) {
            this.data = data;
        }
        public LLNode getNext() {
            return next;
        }
        public void setNext(LLNode next) {
            this.next = next;
        }
    
    
    }
    public class LLStack<T> {
        private LLNode<T>  head;
    
        boolean isEmpty() {
            return head == null;
        }
    
        int size() {
            int count = 1;
            LLNode cur = head;
            if(isEmpty())  return 0;
            while(cur.getNext() !=null ) {
                cur = cur.getNext();
                count++;
            }
            return count;
        }
    
        T top() {
            if(isEmpty())
                new Exception("栈空");
            return head.getData();
        }
    
        void push(T d) {
            if(isEmpty()) {
                head =new LLNode(d);
            }else {
                LLNode node = new LLNode(d);
                node.setNext(head);
                head = node;
            }
        }
    
        T pop() {
            if(isEmpty())
                new Exception("栈空");
            LLNode<T> del = head;
            head = head.getNext();
            return del.getData();
        }
        void display() {
            if(isEmpty()) {
                System.out.println("栈空");
            }else {
                LLNode cur = head;
                System.out.print("栈内元素:");
                while(cur != null) {
                    System.out.print(cur.getData() + "->");
                    cur = cur.getNext();
                }
                System.out.println();
            }
        }
    
        void deleteStack() {
            head  = null;
        }
    
    
    
        public static void main(String[] args) {
            LLStack<Character> ls = new LLStack<>();
            ls.push('2');
            ls.push('3');
            System.out.println("栈顶元素:" + ls.top());
            ls.display();
            System.out.println("移除栈顶元素:" + ls.pop());
            ls.push('5');
            System.out.println("删除整个栈");
            ls.deleteStack();
            ls.display();
    
        }
    
    }
    
    
    
    

    完整测试代码

    
    import java.util.Scanner;
    
    public class StackApplication {
        //括号匹配算法
        static boolean isMatch(String curString) {
            LLStack<Character> stack = new LLStack<>();
            //字符处理
            for(int i = 0; i < curString.length(); i++) {
                char ch = curString.charAt(i);
                switch(ch) {
                    case '(' :
                        stack.push(ch);
                        break;
                    case '[' :
                        stack.push(ch);
                        break;
                    case '{' :
                        stack.push(ch);
                        break;
                    case ')' :
                        if(stack.isEmpty() || stack.top().equals('c')) {
                            System.out.println("括号匹配失败");
                            return false;
                        }else {
                            stack.pop();
                        }
                        break;
                    case ']' :
                        if(stack.isEmpty() || stack.top().equals('[') ) {
                            System.out.println("括号匹配失败");
                            return false;
                        }else {
                            stack.pop();
                        }
                        break;
                    case '}' :
                        if(stack.isEmpty() || stack.top().equals('{') ) {
                            System.out.println("括号匹配失败");
                            return false;
                        }else {
                            stack.pop();
                        }
                        break;
                }
            }
            //字符处理后栈非空
            if(!stack.isEmpty()) {
                System.out.println("括号匹配失败");
                return false;
            }
            //System.out.println("括号匹配成功");
            return true;
        }
        //算术符号优先级算法
        static boolean isPriority(char top, char t) {
            /*if(a == '(' || a == '[' || a == '{') return true;
            if(b == '(' || b == '[' || b == '{' ) return true;
    
            if(b == '*' || b == '/' || b == '%')
                return false;
            else if(a == '*' || a == '/' || a == '%')
                return true;
            else if(b == '+' || b == '-' )
                return false;
            else return true;
    */
            if((t == '+' || t == '-') && (top == '*' || top == '/'))
                return true;
            return false;
    
        }
    
        static boolean isNumber(char t){
            //这里为了测试一下字母,所以把字母也加进来了
            if (t >= '0' && t <= '9' || t >= 'a' && t <= 'z' || t >= 'A' && t <= 'Z' )
                return  true;
            return false;
        }
        //中缀转后缀算法
        static String MinddleTurnToBack(String curString) {
            LLStack<Character> stack = new LLStack<>();
            String result = "" ;
            System.out.print("中缀表达式转换为后缀表达式:");
            for(int i = 0; i < curString.length(); i++) {
                char t = curString.charAt(i);
                if(isNumber(t)) {
                    //数字直接输出
                    System.out.print(t);
                    result = result + t;
                }else if((t == ')' || t == ']' || t == '}')) {
                    //当栈顶不是‘(’时,出栈并输出
                    while(!stack.isEmpty() && stack.top() != '(' && stack.top() != '[' && stack.top()!= '{'){
                        result += stack.top();
                        System.out.print((char)stack.pop());
    
                    }
                    //直到栈顶是‘(’
                    if (!stack.isEmpty())
                        stack.pop();
    
                }else {//操作符或‘(’
                    //当栈非空且t的优先级不大于栈顶元素时,出栈并输出然后t入栈
                    while(!stack.isEmpty() && isPriority((char)stack.top(), t)) {
                        result += stack.top();
                        System.out.print((char)stack.pop());
                    }
                    stack.push(t);
                }
            }
            while(!stack.isEmpty()) {
                result += stack.top();
                System.out.print((char)stack.pop());
            }
            System.out.println();
            return result;
        }
        //计算后缀表达式算法
        static Double calculator(String curString) {
            LLStack<Double> stack = new LLStack<>();
            for(int i = 0; i < curString.length(); i++) {
                String t = curString.substring(i , i + 1 );
                if(t.charAt(0) >= '0' && t.charAt(0) <= '9' ) {
                    //数字直接入栈
                    stack.push(Double.parseDouble(t));
                }else {
                    double a , b = 0;
                    a =(Double) stack.pop();
                    b =(Double) stack.pop();
                    switch(t){
                        case "*" : stack.push(b * a);System.out.println(t+":" + b * a);break;
                        case "/" : stack.push(b / a);System.out.println(t+":" + b / a);break;
                        case "+" : stack.push(b + a);System.out.println(t+":" + (double)(b + a));break;
                        case "-" : stack.push(b - a);break;
                        case "%" : stack.push(b % a);break;
                    }
                }
            }
            return stack.pop() ;
        }
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String curString = null;
            while(true) {
                System.out.print("请输入中缀表达式:");
                curString = scanner.next();
                if(isMatch(curString))
                    System.out.println("计算出后缀表达式的结果为:" + calculator(MinddleTurnToBack(curString)));
                //MinddleTurnToBack(curString);
                System.out.println();
            }
        }
    }
    
    
    
    展开全文
  • } /** * 根据后缀表达式计算结果 * @param array 后缀表达式的数组 */ private static double calculate(ArrayList array) { Stack numStack = new Stack(); //正序遍历后缀表达式数组 for (String item : array) {...
  • printf("输入后缀表达式:"); while(c1!='#') { c1=getchar(); if(!operate(c1)) { push(s,(float) (c1-48)); } else { b=top(s); pop(s); a=top(s); pop(s); result=cal(a,b,c1); push(s,result); } } printf("%f\...
  • 1.简介 问题: 我们平常使用的数学表达式大多数是“中缀表达式”例如:9+(3...2.图解后缀表达式计算方式 规则:遍历后缀表达式的每个元素, 1.遇到数字就进栈, 2.遇到符号就将栈顶的2个元素出栈,然后将计算结果进栈
  • 数据结构课程实验,实现了终端输入输出的中缀表达式求后缀表达式,中缀表达式转化后缀表达式,以及文件流的中缀表达式求后缀表达式,中缀表达式转化后缀表达式,可操作整数,小数,浮点数,实现运算...
  • 自定义栈,中缀表达式转换为后缀表达式并求,三个抽象数据类型定义(1.class stack 2.class Middle_expressionToPost_expression 3.class Post_expression_value)
  • 使用堆栈计算后缀表达式

    千次阅读 2019-01-29 16:01:18
    使用堆栈计算后缀表达式 一、实现栈结构 根据栈的先进后出的特点,很容易设置栈结构的接口:入栈、出栈、判空、size()等。可以用线性表的方法来实现一个栈结构,其实也就两种,用链表或数组实现栈。 但是,在C++...
  • C/C++ 实现利用栈计算后缀表达式
  • 后缀表达式,指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则)。 实现代码: <?php class Stack{ public $stack; public $...
  • 表达式树的形式进行编码,能够输出结点和右节点,以及右节点的右节点(如果存在)的表达式符号,并且输出计算结果。
  • 表达式求(根据原表达式得到后缀表达式计算) 表达式中只限输入整数
  • 计算后缀表达式

    千次阅读 2018-08-15 20:02:24
    一、通过栈把中缀表达式转换为后缀表达式的步骤: 从左至右扫描中缀表达式, if(遇到数字){  加入后缀表达式 }else if(遇到 ‘(’ ){  入栈 }else if(遇到 ‘)’ ){  依次将栈中元素出栈并加入到后缀...
  • 四川大学计算机学院-数据结构与算法分析高分实验报告-利用后缀表达式计算中缀表达式的.rar 都是自己非常认真完成的,每一个要点都实现到位,还额外实现了创新内容。 最后得到的分数也很好
  • 后缀表达式(c语言)

    千次阅读 2019-03-24 22:10:23
    我们平时数学上用的算术表达式(中缀表达式)转换为后缀表达式后,它主要是字符串形式(如果不会,建议先学习中转后的操作)。 要实现对其的求,有如下几个步骤: (对整个字符串进行遍历) 将字符串型的数字转换...
  • 将中缀表达式转换为二叉树、后序遍历二叉树转为后缀表达式、计算后缀表达式
  • 后缀表达式计算

    2022-01-12 15:01:52
    后缀表达式计算
  • 一个算术表达式是由操作数(operand)、运算符(operator)和括号组成的。...用户可选择需要进行的操纵,包括后缀表达式计算,中缀表达式转为后缀表达式,清屏和退出,界面清晰,操作简便,且有足够的输入合法性检验
  • 在上一篇我们已经说过如何计算中缀表达式了,那么这一篇就来说一下如何来计算后缀表达式。 后缀表达式呢,要比中缀表达式的计算要容易得多。 和上一次一样,我们先来分析一下过程应该是什么样子呢? 我这里有一...
  • 本关任务要求通过实现函数double ComputePostfix(char* s)来计算后缀表达式。 相关知识 和中缀表达式的计算一样,后缀表达式的计算也需要用到栈。关于链接存储的栈,其中已实现了如下操作: 创建栈:创建一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,829
精华内容 25,531
关键字:

计算后缀表达式的值