精华内容
下载资源
问答
  • 后缀表达式计算

    2020-11-12 17:40:42
    /后缀表达式计算:中缀表达式为 a-(b+c)(d/e) 后缀表达式为 abc+de/- 后缀表达式储存在数组A[]中,创建栈stack[],从数组中取出字符,遇到数字进栈,遇到运算符就出栈两次,进行计算,计算结果入栈 注意字符类型转换...

    /后缀表达式计算:中缀表达式为 a-(b+c)(d/e) 后缀表达式为 abc+de/-
    中缀表达式储存在数组A[]中,创建栈stack[],从前往后扫,从数组中取出字符,遇到数字进栈,遇到运算符就出栈两次,进行计算,计算结果入栈
    注意字符类型转换
    /

    #include <stdio.h>
    #include <math.h>
    #include <stdlib.h>
    
    #define N 100 
    
    int judge_char(char c)
    {
    	switch(c)
    	{
    		case '+':return 1;
    		case '-':return 1;
    		case '*':return 1;
    		case '/':return 1;
    		default :return 0;
    	} 
    }
    
    double calcu(double a,double b,char c)
    {
    	switch(c)
    	{
    		case'+':return a+b;
    		case'-':return a-b;
    		case'*':return a*b;
    		case'/':return a/b;
    	}
    }
    
    int fun(char A[])
    {
    	int i,tag;
    	double stack[N];
    	int top=-1;
    	double a,b,result;
    	i=0;
    	while(A[i]!='\0')
    	{
    		tag=judge_char(A[i]);
    		if(tag==0)
    		{
    			stack[++top]=A[i]-'0';
    		} 
    		else
    		{
    			a=stack[top--];
    			b=stack[top--];
    			result=calcu(b,a,A[i]);
    			stack[++top]=result;
    		}
    		i++;
    	}
    	return result; 
    } 
    
    int main()
    {
    	char A[]="811+11/*-";
    	double result=fun(A);
    	printf("%f",result);
    	return 0;
    }
    
    展开全文
  • P1449 后缀表达式计算题目描述所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级)。...
    P1449 后缀表达式计算

    题目描述

    所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级)。

    如:3*(5–2)+7对应的后缀表达式为:3.5.2.-*7.+@。’@’为表达式的结束符号。‘.’为操作数的结束符号。

    输入输出格式

    输入格式:

     

    输入:后缀表达式

     

    输出格式:

     

    输出:表达式的值

     

    输入输出样例

    输入样例#1: 复制
    3.5.2.-*7.+@
    输出样例#1: 复制
    16

    说明

    转自

    https://www.cnblogs.com/unixfy/p/3344550.html

    https://www.cnblogs.com/aguncn/p/10656983.html

    字符串长度,1000内。

    #include<stdio.h>
    #include<string.h> 
    int main()
    {   
        int stack[4000];
        int i=0;
        char str;
        int  dig=0;
        while((str=getchar())!='@')
     {
            if(str>='0'&&str<='9') 
         {   
             dig*=10;
          dig+=str-'0'; 
      }    //因为是以字符型输入,不能表示多位数,所以这样 
            else if(str=='.') 
            {
            stack[i++]=dig;
            dig=0;    //权值清0; 
           }
            else if(str=='+')
      {
       stack[i-2]=stack[i-2]+stack[i-1];
       stack[i-1]=0;   //用变0表示出栈
       i--;
      } 
      else if(str=='-')
      {
       stack[i-2]=stack[i-2]-stack[i-1];
       stack[i-1]=0;
       i--;
      } 
      else if(str=='*')
      {
       stack[i-2]=stack[i-2]*stack[i-1];
       stack[i-1]=0;
       i--;
      } 
      else if(str=='/')
      {
       stack[i-2]=stack[i-2]/stack[i-1];
       stack[i-1]=0;
       i--;
      }      
       }
       printf("%d\n",stack[0]);
       return 0;
    }
    
    

     

    展开全文
  • C语言 : 中缀表达式 计算求值、后缀表达式 计算求值、中缀表达式 转 后缀表达式

    代码来源 :
    bilibili网站 :https://www.bilibili.com/video/av91996256?from=search&seid=17449723308302029804

    注意:中缀表达式 转 后缀表达式,函数 有误。

    中缀表达式 计算过程 :
    在这里插入图片描述

    后缀表达式 计算过程 :
    在这里插入图片描述

    中缀表达式 转 后缀表达式 :
    在这里插入图片描述

    /* 前缀:prefix
    ** 中缀:Infix
    ** 后缀:Suffix
    exit为C++的退出函数,声明于stdlib.h中,对于C++其标准的头文件为cstdlib,
    声明为 void exit(int value);
    exit的功能为,退出当前运行的程序,并将参数value返回给主调进程。
    在main中return v;的效果 与exit(v);相同。
    exit(1)和exit(-1)是分别返回1和-1到主调程序。
    exit(0): 返回0,表示程序正常退出,非0表示非正常退出。
    exit(1):表示异常退出。
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    // #include <cstring>
    #include <string.h>
    
    enum boolean
    {
        FALSE,
        TRUE
    };
    
    typedef enum boolean Bool; //枚举方式进行重定义
    typedef int ElementType;
    
    struct stack
    {
        ElementType *element;
        int MaxSize; //大小
        int top;     //线性表:长度; 栈:栈顶指针
    };
    
    typedef struct stack Stack;
    
    //需要的函数
    void InitStack(Stack *S, int sz);   //初始化函数
    void FreeStack(Stack *S);           //释放栈空间(即: 空间无)
    Bool Push(Stack *S, ElementType X); //压栈
    ElementType Pop(Stack *S);          //弹栈(栈顶弹出)
    ElementType GetTop(Stack *S);       // 获取栈顶元素
    void MakeStackEmpty(Stack *S);      //置空(无元素,空间依然存在)
    Bool IsStackEmpty(Stack *S);        //栈是否为空
    Bool IsStackFull(Stack *S);         //栈是否为满
    
    void EvaluteMidPostfix();  //中缀表达式求值
    void EvaluteBackPostfix(); //后缀表达式求值
    void MidToBack();          //中缀转后缀
    
    int main()
    {
        //printf("%d\n", (int)('9' - 48));
    
        //EvaluteMidPostfix();
        EvaluteBackPostfix();
        //MidToBack();
        return 0;
    }
    
    //实现各个功能函数
    
    void InitStack(Stack *S, int sz) //初始化栈(栈为空)
    {
        S->MaxSize = sz;
        S->top = -1; //指向-1; 一个元素:指向0
        S->element = (ElementType *)malloc(sizeof(ElementType) * S->MaxSize);
    }
    
    void FreeStack(Stack *S) //释放栈空间(即: 空间无)
    {
        free(S->element); //释放元素
    }
    
    Bool IsStackFull(Stack *S) //栈是否为满
    {
        // return S->top == S->MaxSize-1;
        if (S->top == S->MaxSize - 1)
            return TRUE;
        return FALSE;
    }
    
    Bool IsStackEmpty(Stack *S) //栈是否为空
    {
        //return S->top == -1;
        if (S->top == -1)
            return TRUE;
        return FALSE;
    }
    
    Bool Push(Stack *S, ElementType x) //压栈
    {
        //先判断 栈满?
        if (IsStackFull(S))
            return FALSE;
        else
        {
            //指针指向新的栈顶
            S->element[++S->top] = x; //top先加一
            return TRUE;
        }
    }
    
    ElementType Pop(Stack *S) //弹栈(栈顶弹出)
    {
        if (IsStackEmpty(S))
        {
            //return FALSE;
            exit(1); //表示异常退出
        }
        else
        {
            //先弹出元素,指针下移
            return S->element[S->top--];
        }
    }
    
    ElementType GetTop(Stack *S) // 获取栈顶元素
    {
        if (IsStackEmpty(S))
        {
            //return FALSE;
            exit(1); //表示异常退出
        }
        else
        {
            //先弹出元素,指针下移
            return S->element[S->top];
        }
    }
    
    void MakeStackEmpty(Stack *S) //置空(无元素,空间依然存在)
    {
        S->top = -1;
    }
    
    //从操作数栈取两个操作数;从操作符栈取一个操作符
    //用操作符对操作数进行运算。将计算结果压入操作数栈。
    void compute(Stack *Sptr, Stack *Spnd) //定义计算过程
    {
        int k;
        switch (Pop(Sptr))
        {
        case '+':
            k = Pop(Spnd) + Pop(Spnd);
            break;
        case '-':
            k = Pop(Spnd);
            k = Pop(Spnd) - k;
            break;
        case '*':
            k = Pop(Spnd) * Pop(Spnd);
            break;
        case '/':
            k = Pop(Spnd);
            k = Pop(Spnd) / k;
            break;
        }
        Push(Spnd, k); //将计算结果压入操作数栈。
    }
    
    void EvaluteMidPostfix() //中缀表达式计算求值
    {
        char buf[80];
        printf("Please input Infix : \n");
        scanf("%s", buf);
    
        //strcpy_s(buf, 80, "8-(3+5-4/2)*2/3");
    
        Stack *Spnd = (Stack *)malloc(sizeof(Stack));
        Stack *Sptr = (Stack *)malloc(sizeof(Stack));
    
        InitStack(Spnd, 80);
        InitStack(Sptr, 80);
    
        int i = 0;
        while (buf[i] != '\0')
        {
            //操作数类型
            if (buf[i] >= '0' && buf[i] <= '9')
                Push(Spnd, (int)(buf[i] - 48)); //printf("%d",(int)('9'-48));
            //操作符类型
            //优先级最高(若无括号&&之后也是*或/,从左到右计算)
            else if (buf[i] == '*' || buf[i] == '/') 
            {
                // if(Sptr->top == -1 || GetTop(Sptr)=='(')//操作符直接入栈的条件
                //     Push(Sptr,buf[i]);
                if (GetTop(Sptr) == '*' || GetTop(Sptr) == '/')
                {
                    compute(Sptr, Spnd);
                }
                Push(Sptr, buf[i]);
            }
            else if (buf[i] == '+' || buf[i] == '-')
            {
                while (Sptr->top != -1 && GetTop(Sptr) != '(') //判断语句不可交换位置。
                {
                    compute(Sptr, Spnd);
                }
                Push(Sptr, buf[i]);
            }
            else if (buf[i] == ')')
            {
                while (GetTop(Sptr) != '(')
                {
                    compute(Sptr, Spnd);
                }
                Pop(Sptr);
            }
            else if (buf[i] == '(')
            {
                Push(Sptr, buf[i]);
            }
            i++;
        }
        while (Sptr->top != -1) //结束条件: 操作符栈为空
            compute(Sptr, Spnd);
        printf("%d", Pop(Spnd));
    }
    
    void EvaluteBackPostfix() //后缀表达式计算求值
    {
        char buf[80];
        printf("Please input Suffix : \n");
        scanf("%s", buf);
        Stack *Spnd = (Stack *)malloc(sizeof(Stack));
        InitStack(Spnd, 80);
    
        int i = 0, k;
        while (buf[i] != '\0')
        {
            switch (buf[i])
            {
            case '+':
                k = Pop(Spnd) + Pop(Spnd);
                Push(Spnd, k);
                break;
            case '-':
                k = Pop(Spnd);
                k = Pop(Spnd) - k;
                Push(Spnd, k);
                break;
            case '*':
                k = Pop(Spnd) * Pop(Spnd);
                Push(Spnd, k);
                break;
            case '/':
                k = Pop(Spnd);
                k = Pop(Spnd) / k;
                Push(Spnd, k);
                break;
            default:
                Push(Spnd, (int)(buf[i] - 48));
            }
            i++;
        }
        printf("%d", Pop(Spnd));
    }
    
    void MidToBack() //中缀转后缀
    {
        char buf[80];
        printf("Infix to suffix : \n");
        scanf("%s", buf); // 读入中缀表达式
    
        //strcpy_s(buf, 80, "8-(3+5-4/2)*2/3");
    
        Stack *Sptr = (Stack *)malloc(sizeof(Stack));
    
        InitStack(Sptr, 80);
    
        int i = 0;
        while (buf[i] != '\0')
        {
            //操作数类型
            if (buf[i] >= '0' && buf[i] <= '9')
                printf("%c", buf[i]);
            //操作符类型
            else if (buf[i] == '*' || buf[i] == '/')
            {
                if (IsStackEmpty(Sptr))
                {
                    Push(Sptr, buf[i]); //栈空,往里放东西
                }
                else if (GetTop(Sptr) == '*' || GetTop(Sptr) == '/')
                {
                    printf("%c", Pop(Sptr));
                    Push(Sptr, buf[i]);
                }
                else
                {
                    Push(Sptr, buf[i]);
                }
            }
            else if (buf[i] == '+' || buf[i] == '-')
            {
                if (IsStackEmpty(Sptr))
                {
                    Push(Sptr, buf[i]); //栈空,往里放东西
                }
            }
            else if (buf[i] == ')')
            {
                while (GetTop(Sptr) != '(')
                {
                    printf("%c", Pop(Sptr));
                }
                Pop(Sptr);
            }
            else if (buf[i] == '(')
            {
                Push(Sptr, buf[i]);
            }
            i++;
        }
        while (Sptr->top != -1) //结束条件: 操作符栈为空
            printf("%c", Pop(Sptr));
    }
    
    // 中缀:8-(3+5-4/2)*2/3 : 4
    // 中缀:7+2*3/(2-3) : 1
    // 后缀:234*+82/- : 10
    // 中后:8-(3+5-4/2)*2/3 : 83542/-+2*3/- : 4
    // 中后:2*(3+4)-8/2 : 234+*82/-
    

    运行截图:
    在这里插入图片描述

    展开全文
  • 思路: ...3.通过后缀表达式计算结果:思路见注释(详细) package stack; import java.util.ArrayList; import java.util.List; import java.util.Stack; public class PolandNotation { p...

    思路:

    1.将中缀表达式转换为list

    2.将中缀表达式的list转换为后缀表达式list

    3.通过后缀表达式计算结果:思路见注释(详细) 

    package stack;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;
    
    public class PolandNotation
    {
    	public static void main(String[] args)
    	{
    		String exception = "1+((2+3)*4)-5";
    		System.out.println("表达式 : " + exception);
    		List<String> infixExpressionList = toInfixExpression(exception);
    		System.out.println("中缀表达式对应的List :" + infixExpressionList);
    		List<String> sufixExpressionList = parseSuffixExpression(infixExpressionList);
    		System.out.println("后缀表达式对应的List :" + sufixExpressionList);
    		
    		int res = calculate(sufixExpressionList);
    		System.out.println("计算结果 : " + res);
    		
    	}
    	
    	//将中缀表达式转成对应的list
    	public static List<String> toInfixExpression(String s)
    	{
    		List<String> list = new ArrayList<>();
    		int i = 0; //指针
    		char c;   //指针时的字符串
    		String str; //多位数的拼接
    		do {
    			//如果是一个非负,则直接进入list
    			if((c=s.charAt(i)) < 48 || (c=s.charAt(i)) > 57)
    			{
    				list.add("" + c);
    				i++; //后移
    			}
    			else 
    			{
    				str = "";
    				while(i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57)
    				{
    					str = str + c; //多位数的话,进行拼接
    					i++;
    				}
    				list.add(str);
    			}
    		}while(i < s.length());
    		return list;
    	}
    	
    	//将得到的中缀表达式对应的List => 后缀表达式的List
    	public static List<String> parseSuffixExpression(List<String> list)
    	{
    		//定义两个栈
    		Stack<String> s1 = new Stack<>();//符号栈
    		//说明:因为S2这个栈,在整个转换过程中,没有pop操作,而且后面需要我们逆序输出
    		//因此比较麻烦,这里我们就不用Stack<String>,直接使用List<String>S2
    		List<String> s2 = new ArrayList<>();  //存储中间结果的List2
    		
    		//遍历List
    		for(String item : list)
    		{
    			//如果是一个数,加入s2
    			if(item.matches("\\d+"))
    			{
    				s2.add(item);
    			}
    			else if(item.equals("("))
    			{
    				s1.push(item);
    			}
    			else if(item.equals(")"))
    			{
    				//如果是右括号,则一次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
    				while(!s1.peek().equals("("))
    				{
    					s2.add(s1.pop());
    				}
    				s1.pop();  //弹出左括号
    			}
    			else
    			{
    				//当item的优先级小于等于s1的栈顶运算符,将s1的栈顶的运算符弹出并加入s2中,再次转到(4.1)与s1中新的运算符相比较
    				while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item))
    				{
    					s2.add(s1.pop());
    				}
    				s1.push(item);
    			}
    		}
    		while(s1.size() != 0)
    		{
    			s2.add(s1.pop());
    		}
    		return s2;
    	}
    	
    	//将一个逆波兰表达式,依次将数据和运算符放入到ArrayList中
    	public static List<String>getListString(String suffixException)
    	{
    		//将suffixException分割
    		String[] split = suffixException.split(" ");
    		List<String>list = new ArrayList<String>();
    		for(String item : split)
    		{
    			list.add(item);
    		}
    		return list;
    	}
    	
    	//计算逆波兰表达式
    	/*
    	 * 1)从左至右扫描,将3、4压入栈中
    	 * 2)遇到+运算符,因此弹出4和3。计算3+4的值,然后将7入栈
    	 * 3)将5入栈
    	 * 4)遇到*运算符,从栈中弹出两个数,7、5,计算5*7,将值35压入栈中
    	 * 5)6入栈
    	 * 7)最后遇到-号运算符,计算35-6,得到29;
    	 */
    	
    	public static int calculate(List<String>ls)
    	{
    		//创建栈
    		Stack<String> stack = new Stack<String>();
    		//遍历ls
    		for(String item : ls)
    		{
    			//这里使用正则表达式来进行取值
    			if(item.matches("\\d+"))  //匹配的是多位数
    			{
    				stack.push(item);
    			}
    			else
    			{
    				int num1 = Integer.parseInt(stack.pop());
    				int num2 = Integer.parseInt(stack.pop());
    				int res = 0;
    				if(item.equals("+"))
    				{
    					res = num2 + num1;
    				}
    				else if(item.equals("-"))
    				{
    					res = num2 - num1;
    				}
    				else if(item.equals("*"))
    				{
    					res = num2 * num1;
    				}
    				else if(item.equals("/"))
    				{
    					res = num2 / num1;
    				}
    				else
    					throw new RuntimeException("运算符异常");
    				
    				
    				//结果入栈
    				stack.push("" + res);
    			}
    		}
    		
    		//最后留在stack里面的最后一个元素就是结果
    		return Integer.parseInt(stack.pop());
    	}
    }
    
    class Operation
    {
    	private static int ADD = 1;
    	private static int SUB = 1;
    	private static int MUL = 2;
    	private static int DIV = 2;
    	
    	//写一个方法,用于返回运算符的优先级
    	public static int getValue(String operation)
    	{
    		int result = 0;
    		switch (operation)
    		{
    			case "+":
    				result = ADD;
    				break;
    			case "-":
    				result = SUB;
    				break;
    			case "*":
    				result = MUL;
    				break;
    			case "/":
    				result = DIV;
    				break;
    			default:
    				System.out.println("转后缀表达式时,运算符异常");
    				break;
    		}
    		return result;
    	}
    }

    计算结果:

    展开全文
  • 首先要知道什么是前缀表达式,什么是中缀表达式,什么是后缀表达式 所谓的中缀表达式就是类似于这种的运算1+((2+3)×4)-5 所谓的前缀表达式就是符号在两个操作数的前面- + 1 × + 2 3 4 5 所谓的后缀表达式就是两...
  • C++后缀表达式计算

    千次阅读 2019-11-19 22:32:17
    C++后缀表达式计算 继续上篇文章,实现计算器简单计算的功能 上篇文章C++中缀表达式转后缀表达式已经将中缀表达式转换成后缀表达式并保存在队列q中 后缀表达式算法思想: 读取队列q顶端元素,并判断元素类型...
  • 练习3.22 中缀表达式转后缀表达式,后缀表达式计算, 多项式计算 polynome.h #pragma once #include #include #include //判断字符类型需要的头文件 #include #include #include class Polynome { ...
  • 后缀表达式则是将操作符放在后面。那么如何将中缀表达式转化成后缀表达式呢?https: //app.yinxiang.com/shard/s64/nl/19478947/bcb42876-1191-4385-a0a8-2ce2151f2614?title =% E5%B0%86% E4%B8%AD%E7...
  • 所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右进行(不用考虑运算符的优先级)。 如:中缀表达式 3*(5–2)+7 对应的后缀...
  • 中缀表达式与后缀表达式的定义在此不再赘述,仅举例说明 序号 中缀表达式 后缀表达式 计算结果 1 23+(34*45)/(5+6+7) 23 34 45 * 5 6 + 7 + / + 108 2 1*(2-(3+4)) 1 2 3 4 + - * -5 3 1+2-3+4-5+6 ...
  • 原理不赘述,随便找个博客看看后缀表达式即其计算 原理简单,实现起来有几个小问题: Q1:A+B*C的后缀变表达式为ABC*+,当ABC为具体的1、2、3时,后缀表达式为123*+, 123怎么理解,1和2和3还是12和3还是1和23... ...
  • LeetCode_p150_逆波兰表达式计算/后缀表达式计算 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。 说明: 整数除法只保留整数部分。 给定逆...
  • 后缀表达式计算
  • 简单的后缀表达式计算 (简单不是指代码简单,而是要计算的表达式简单) 什么是后缀表达式? 百度百科传送门 最简单后缀表达式: a b + 一眼可以看出结果是 a + b,就是先将前面的数字存起来,遇到运算符,取两个...
  • 表达式求值(根据原表达式得到后缀表达式计算) 表达式中只限输入整数
  • 后缀表达式又成为逆波兰表达式,在sicp里面有讲过,简单的加减乘除可以用栈很快写出来,但是要用到括号,幂运算等就要整理出符号的优先级,根据优先级的比较决定是否进行入栈。 ps.先占个坑#include #include #...
  • 逆波兰表达式Reverse Polish Notation,又叫后缀表达式。 习惯上,二元运算符总是置于与之相关的两个运算对象之间,即中缀表达方法。波兰逻辑学家J.Lukasiewicz于1929年提出了运算符都置于其运算对象之后,故称为...

空空如也

空空如也

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

后缀表达式计算