精华内容
下载资源
问答
  • 请用的特性编写一个程序,使得程序输出后缀表达式 分析如下: STEP1: 1+(2-3)*4+10/5 首先遇到第一个输入是数字1,数字在后缀表达式中都是直接输出,接着是符号“+”,入栈: STEP2: 1+(2-3)*4+10/5 第三个字符...
  • 后缀表达式的概念 后缀表达式又称作逆波兰式,操作符在运算数的后面,所以叫做后缀表达式。例如 1 + 2 * 3的后缀表达式是 1 2 3 * + 。可以 2 3 *看作一个运算数a, 1 a * 也...读取玩后缀表达式后,中只有一个元...

    后缀表达式的概念

    后缀表达式又称作逆波兰式,操作符在运算数的后面,所以叫做后缀表达式。例如 1 + 2 * 3的后缀表达式是 1 2 3 * + 。可以 2 3 *看作一个运算数a, 1 a * 也符合运算数 运算数 操作符的格式。

    怎么利用栈计算

    • 当遇到运算数,进栈
    • 遇到操作符 $,从栈中弹出两个运算数a 、b, 计算 b $ a 的结果,结果进栈
    • 读取玩后缀表达式后,栈中只有一个元素,这个元素即为结果

    代码

    代码的特殊处理:
    因为要处理大于9的数,所以要在每个数和操作符后加上空格,将相邻的数分隔开。
    后缀表达式以字符串的形式存在,所以要将字符形式的数字转化为数值类型。
    我只处理了加减乘除四则运算,只能使用正整数。

    #include<stdio.h>
    #include<stack>
    
    int CalPostfix(char expre[]){
        int num;	//储存运算数
        int num1;	//储存栈中弹出的第一个数
        int num2;	//储存弹出的第二个数
    
        std::stack<int> s;
    
        int i = 0;
        while(expre[i] != '\0'){
            num  = 0;
            if(expre[i] == ' ')
                i ++;
            else if(expre[i] >= '0' && expre[i] <= '9'){
            //以空格为结束符,计算数值的大小
                while(expre[i] != ' '){
                    num = num * 10 + (expre[i] - '0');
                    i ++;
                }
                s.push(num);
            }else{
                num1 = s.top();
                s.pop();
                num2 = s.top();
                s.pop();
                switch(expre[i]){
                    case '+':
                        num = num1 + num2;
                        break;
                    case '-':
                        num = num2 - num1;
                        break;
                    case '*':
                        num = num2 * num1;
                        break;
                    case '/':
                        num = num2 / num1;
                        break;
                    default:
                        break;
                }
                s.push(num);
                i ++;
            }
        }
        return s.top();
    }
    
    int main(){
        char expre[] = "1 2 *";
        int result = CalPostfix(expre);
        printf("%d",result);
    
        return 0;
    }
    
    
    
    展开全文
  • 例如:(3+5)*5-6对应的后缀表达式为3 5 + 5 * 6 -,其值步骤如下: 1.从左到右扫描,遇见数字直接入栈,3和5入栈; 2.遇见操作符+,从中弹出两个数3和5,根据操作符计算结果为8,并将结果8入栈; 3.将5入栈; ...

    一、需求分析

    1、输入一个逆波兰表达式,利用栈计算其结果;
    2、支持小括号和多位数整数;

    二、思路分析

    例如:(3+5)*5-6对应的后缀表达式为3 5 + 5 * 6 -,其求值步骤如下:
    1.从左到右扫描,遇见数字直接入栈,3和5入栈;
    2.遇见操作符+,从栈中弹出两个数3和5,根据操作符计算结果为8,并将结果8入栈;
    3.将5入栈;
    4.遇见操作符*,弹出两个操作符5和8,计算结果为5*8=40,将40入栈;
    5.将6入栈;
    6.遇见操作符-,弹出两个数字6和40,计算结果为40-6=34,将34入栈;
    7.字符串扫描完毕,栈中剩余数字34就是最终答案。

    三、代码

    package com.stack;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;
    
    /**
     * 例如:(3+5)\*5-6对应的后缀表达式为3 5 + 5 \* 6 -,其求值步骤如下: 
     * 1.从左到右扫描,遇见数字直接入栈,3和5入栈;
     * 2.遇见操作符+,从栈中弹出两个数3和5,根据操作符计算结果为8,并将结果8入栈; 
     * 3.将5入栈;
     * 4.遇见操作符*,弹出两个操作符5和8,计算结果为5*8=40,将40入栈; 
     * 5.将6入栈;
     * 6.遇见操作符-,弹出两个数字6和40,计算结果为40-6=34,将34入栈; 
     * 7.字符串扫描完毕,栈中剩余数字34就是最终答案。
     * 
     * @author chaixf
     *
     */
    public class PolandNotation {
    	public static void main(String[] args) {
    		// 定义逆波兰表达式
    		String suffixExpression = "3 5 + 5 * 6 -";
    		// 思路
    		// 1、先将"3 5 + 5 * 6 -" => ArrayList中
    		// 2、将ArrayList传给一个方法,结算结果
    		List<String> list = getListString(suffixExpression);
    		// 计算结果
    		int res = calculate(list);
    		System.out.printf("3 5 + 5 * 6 -的计算结果为:%d",res);
    	}
    
    	public static List<String> getListString(String suffixExpression){
    		// 将suffixExpression进行分割
    		String[] split = suffixExpression.split(" ");
    		// 将split放进ArrayList中
    		ArrayList<String> arrayList = new ArrayList<String>();
    		for(String item:split) {
    			arrayList.add(item);
    		}
    		return arrayList;
    	}
    	
    	public static int calculate(List<String> list) {
    		// 创建一个栈
    		Stack<Integer> stack = new Stack<Integer>();
    		for(String item:list) {
    			if(item.matches("\\d+")) {// 匹配到的是数字
    				stack.push(Integer.parseInt(item));
    			}else {// 匹配到的是操作符
    				// 弹出两个数并计算结果
    				int num2 = stack.pop();
    				int num1 = stack.pop();
    				int result = 0;
    				switch (item) {
    				case "+":
    					result = num1 + num2;
    					break;
    				case "-":
    					result = num1 - num2;
    					break;
    				case "*":
    					result = num1 * num2;
    					break;
    				case "/":
    					result = num1 / num2;
    					break;
    				default:
    					throw new RuntimeException("操作符错误!");
    				}
    				// 将结果入栈
    				stack.push(result);
    			}
    		}
    		// 返回栈中的最后一个数据
    		return stack.pop();
    	}
    }
    
    
    展开全文
  • 顺序栈求后缀表达式

    2020-08-05 17:49:17
    利用顺序的记忆性质求后缀表达式的值

    顺序栈求后缀表达式

    代码如下:

    #include <iostream>
    using namespace std;
    
    typedef struct sqstack                   //顺序栈定义
    {
    	int data[10];
    	int top;
    }Sqstack;
    
    void initstack(struct sqstack &Sqstack) //初始化栈
    {
    	Sqstack.top=-1;
    }
    
    int isempty(struct sqstack &Sqstack)    //判断栈是否空
    {
    	if(Sqstack.top==-1)
    	{
    		cout<<" 顺序栈为空 "<<endl;
    		return 1;
    	}
    	else
    	{
    		cout<<" 顺序栈不为空 "<<endl;
    	}
    		return 0;
    }
    
    int push(struct sqstack &Sqstack,int x)  //插入元素x作为新的栈顶元素
    {
    	if(Sqstack.top==9)
    	{
    		cout<<" 错误 "<<endl;
    		return 0;
    	}
    	Sqstack.top=Sqstack.top+1;
    	Sqstack.data[Sqstack.top]=x;
    	return 1;
    }
    
    int gettop(struct sqstack Sqstack,int &e)//得到栈顶元素的值
    {
    	if(Sqstack.top==-1)
    	{
    		cout<<" NULL(空表) "<<endl;
    		return 0;
    	}
    
    	e=Sqstack.data[Sqstack.top];
    	return 1;
    
    }
    
    int pop(struct sqstack &Sqstack,int &x)//删除栈顶元素并用x返回它
    {
    	if(Sqstack.top==-1)
    	{
    		return 0;
    	}
    	x=Sqstack.data[Sqstack.top];
    	Sqstack.top=Sqstack.top-1;
    	return 1;
    }
    
    int operat(int a,char Operator,int b)//运算函数 a Operator b
    {
      if(Operator=='+')
      {return a+b;}
      if(Operator=='-')
      {return a-b;}
      if(Operator=='*')
      {return a*b;}
      if(Operator=='/')
      {
        if(b==0)//除数为零报错
        {
          cout<<"ERROR"<<endl;
          return 0;
        }
        else
        return a/b;
      }
    }
    
    int stackcalculate(char exp[])//计算后缀式:先让数字进栈,一遇到运算符就出栈两次,得到两个数字,
    //让这两个数字与遇到的运算符运算,再将结果压入栈中,重复此步骤直到字符串尾'\0',此时栈中元素即为运算结果
    {
      int i,a,b,c,x;
      struct sqstack stack;//结构体栈创建实例
      initstack(stack);//初始化
      char Operator;
      for(i=0;exp[i]!='\0';i++)//在C语言中字符串以'\0'作为结尾,这里使用它作为循环截至条件
      {//从左到右检索字符数组exp
        if(exp[i]>='0'&&exp[i]<='9')//若字符数组元素为从0到9的数字则将它压进栈
        push(stack,exp[i]-'0');// “ exp[i]-'0' ”这里使用了C语言中从字符型到整型的转换,整型=字符型-'0'
        else//若字符数组元素不为数字,那它就是运算符
        {
          Operator=exp[i];//取运算符
          pop(stack,x);//出栈,把出栈元素赋给b
    	    b=x;//先出栈的是第二个运算数
          pop(stack,x);//再出栈
          a=x;//第一个运算数
          c=operat(a,Operator,b);//运算
          push(stack,c);//将运算结果压进栈中
        }
      }
      int e;
      gettop(stack,e);//取栈元素即为结果
      return e;
    }
    
    int main()
    {
      int m;
      m=stackcalculate("1234*++5/");//在C语言中字符串可以直接赋值给字符数组,所以这里可以直接用字符串做函数参数
      cout<<" (1+2+3*4)/5=";
      cout<<m;
      return 0;
    }
    

    运行结果如下:运行结果

    展开全文
  • 主要为大家详细介绍了C语言利用栈实现对后缀表达式的求解,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 利用栈求解后缀表达式及其值
    #include <stdio.h>
    #include <stdlib.h>
    #define MaxSize 25
    typedef struct
    {
    	char data[MaxSize];
    	int top;
    }SqType;
    typedef struct
    {
    	double data[MaxSize];
    	int top;
    }SqType1;
    void InitStack(SqType*& s) {
    	s = (SqType*)malloc(sizeof(SqType));
    	s->top = -1;
    }
    void DestroyStack(SqType*& s) {
    	free(s);
    }
    bool StackEmpty(SqType* s) {
    	return s->top == -1;
    }
    bool Push(SqType*& s, char e) {
    	if (s->top == MaxSize - 1) {
    		return false;//满
    	}
    	s->top++;
    	s->data[s->top] = e;
    	return true;
    }
    bool Pop(SqType*& s, char& e) {
    	if (s->top == -1) {
    		return false;//栈空
    	}
    	e = s->data[s->top];
    	s->top--;
    	return true;
    }
    bool GetTop(SqType* s, char& e) {
    	if (s->top == -1) {
    		return false;
    	}
    	e = s->data[s->top];
    	return true;
    }
    void InitStack(SqType1*& s) {
    	s = (SqType1*)malloc(sizeof(SqType1));
    	s->top = -1;
    }
    void DestroyStack(SqType1*& s) {
    	free(s);
    }
    bool StackEmpty(SqType1* s) {
    	return s->top == -1;
    }
    bool Push(SqType1*& s, double e) {
    	if (s->top == MaxSize - 1) {
    		return false;//满
    	}
    	s->top++;
    	s->data[s->top] = e;
    	return true;
    }
    bool Pop(SqType1*& s, double& e) {
    	if (s->top == -1) {
    		return false;//栈空
    	}
    	e = s->data[s->top];
    	s->top--;
    	return true;
    }
    bool GetTop(SqType1* s, double& e) {
    	if (s->top == -1) {
    		return false;
    	}
    	e = s->data[s->top];
    	return true;
    }
    //中缀表达式转换为后缀表达式
    //exp中缀表达式   postexp后缀表达式
    bool trans(char* exp, char postexp[]) {
    	char e;
    	SqType* sq;
    	InitStack(sq);
    	int i = 0;
    	while (*exp != '\0') {
    		switch (*exp) {
    		case '(': {
    			Push(sq, '(');
    			exp++;
    			break;
    		}
    		case ')': 
    		{
    			Pop(sq, e); //从栈中出一个元素并赋值给e
    			while (e != '(') {
    				postexp[i++] = e;
    				Pop(sq, e);
    			}
    			exp++; 
    			break; 
    		}
    		case '+':
    		case '-':
    		{
    			while (!StackEmpty(sq)) {
    				GetTop(sq, e);
    				if (e != '(') {
    					postexp[i++] = e;
    					Pop(sq, e);
    				}
    				else {
    					break;
    				}
    			}
    			Push(sq, *exp);
    			exp++;
    			break;
    		}
    		case '*':
    		case '/':
    		{
    			while (!StackEmpty(sq)) {
    				GetTop(sq, e);
    				if (e == '*' || e == '/') {
    					postexp[i++] = e;
    					Pop(sq, e);
    				}
    				else {
    					break;
    				}
    			}
    			Push(sq, *exp);
    			exp++;
    			break;
    		}
    		default:
    		{
    			while (*exp >= '0' && *exp <= '9') {
    				postexp[i++] = *exp;
    				exp++;
    			}
    			postexp[i++] = '#';  //表示一个数字串的结束
    		}
    		}
    	}
    	while (!StackEmpty(sq)) {
    		Pop(sq, e);
    		postexp[i++] = e;
    	}
    	postexp[i] = '\0';
    	DestroyStack(sq);
    	return true;
    }
    //计算后缀表达式的值
    double compvalue(char* postexp) {
    	double a, b, c, d, e;
    	SqType1* sq;
    	InitStack(sq);
    	while (*postexp != '\0') {
    		switch (*postexp) {
    		case '+':
    		{
    			Pop(sq, a);
    			Pop(sq, b);
    			c = b + a;
    			Push(sq, c);
    			break;
    		}
    		case '-':
    		{
    			Pop(sq, a);
    			Pop(sq, b);
    			c = b - a;
    			Push(sq, c);
    			break;
    		}
    		case '*':
    		{
    			Pop(sq, a);
    			Pop(sq, b);
    			c = b * a;
    			Push(sq, c);
    			break;
    		}
    		case '/':
    		{
    			Pop(sq, a);
    			Pop(sq, b);
    			if (a != 0) {
    				c = b / a;
    				Push(sq, c);
    				break;
    			}
    			else {
    				printf("除零错误\n");
    				exit(0);
    			}
    			break;
    		}
    		default:
    		{
    			d = 0;
    			while (*postexp >= '0' && *postexp) {
    				d = 10 * d + *postexp - '0';
    				postexp++;
    			}
    			Push(sq, d);
    			break;
    		}
    		}
    		postexp++;
    	}
    	GetTop(sq, e);
    	DestroyStack(sq);
    	return e;
    }
    int main() {
    	char exp[] = "(74-20)/(4+2)";
    	char postexp[MaxSize];
    	trans(exp, postexp);
    	printf("中缀表达式:%s\n", exp);
    	printf("后缀表达式:%s\n", postexp);
    	printf("表达式的值:%g\n", compvalue(postexp));
    	return 1;
    }
    
    展开全文
  • 利用栈完成后缀表达式的计算

    千次阅读 2018-04-17 16:38:52
    利用栈结构,将后缀表达式的结果计算出来。输入后缀表达式。以#号作为表达式结束标志。为了简单,处理的数据为0-9的整数。输出计算结果。样例输入3 6 6 2 / - 3 * +#样例输出12#include&lt;stdi...
  • 本文实例讲述了PHP实现基于后缀表达式求值功能。分享给大家供大家参考,具体如下: 后缀表达式概述 后缀表达式,指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右...
  • 后缀表达式也叫逆波兰表达式,是在计算机中用于值的一种方式,其值过程可以用到来辅助存储。 在通常的表达式中,二元运算符总是置于与之相关的两个运算对象之间,这种表示法也称为中缀表示,如1...
  • 后缀表达式? 正常地计算表达式 <操作数> <操作符> <操作数>. 9+2 结果 11 后缀表达式 <操作数> <操作数> <操作符> 9 2 + 结果 11 复杂一点地后缀表达式 3 4 * 2 5 + - 4 * 2 /...
  • C/C++ 实现利用栈计算后缀表达式的值
  • 的应用——表达式求解,内容主要有 中缀表达式转换成后缀表达式以及求解过程,需要可自行下载
  • C++语言,利用堆栈实现波兰表达式实现后缀表达式计算。
  • 与前缀表达式(例:+ 3 4)或后缀表达式(例:3 4 +)相比,中缀表达式不容易被电脑解析,但仍被许多程序语言使用,因为它符合人们的普遍用法。逆波兰表示法(Reverse Polish notation,RPN,或逆波兰记法),是一种...
  • 利用栈结构,将后缀表达式的结果计算出来。 输入 后缀表达式。以#号作为表达式结束标志。为了简单,处理的数据为0-9的整数。 输出 计算结果。 样例输入 3 6 6 2 / - 3 * +# 样例输出 12 #include<stdio.h> #...
  • 我这里有一个后缀表达式,一个,还有分析过程,我们就拿这个表达式来做一下演示。 我们从左到右扫描,34都是数字直接入栈。 然后遇到运算符+, 我们弹出的两个数并运算,结果入栈。 然后下一个是5,直接入栈。...
  • 后缀表达式求

    2013-03-08 22:15:54
    用数据结构实现后缀表达式求值的问题 输入一个后缀表达式 可计算出它的值
  • 事实上,要实现四则运算值,需要把中缀表达式转化为后缀表达式,再把后缀表达式进行运算得出结果。 一、中缀表达式与后缀表达式 1. 观察式子:1+2 平时我们所用的四则运算表达式都是运算符在两个数字中间的,...
  • #include using namespace std; void infixtopostfix...top2)//infix为中缀表达式,s2可以保存最终结果 { //top2为结果的栈顶指针 int maxsize; char s1[maxsize]; //s1为中转 int top1= -1; int i =0; while
  • 利用栈完成后缀表达式的计算 1000(ms) 10000(kb) 2114 / 4163后缀表达式不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) ...
  • 后缀表达式简单后缀表达式的计算后缀表达式的计算(完全) 简单后缀表达式的计算 就我个人来说,后缀表达式看起来很别扭,但是从变成来看,后缀表达式的处理比中缀表达式的处理方便很多。 中缀表达式:( 30 + 4 ) x ...
  • 表达式分为前缀表达式,中缀表达式,后缀表达式。 中缀表达式:指双目运算符在两个运算对象中间,如4+2。 那么后缀表达式和前缀表达式顾名思义就是了,也就是说后缀表达式的双目运算符在后,前缀表达式的双目...
  • 本程序实现了输入任意一个中缀表达式,将其转换为后缀表达式的功能
  • 这里有两个版本,第一个版本是拿到需求后自己先写出来的,第二个版本是看了别人写的好的之后写的,并做了一个总结比较助自己提升,自己再画图顺了一下后缀表达式生成的算法逻辑
  • 后缀表达式值思路: 1、从左到右扫描后缀表达式 2、如果遇到操作数,将其压入栈中。 3、如果遇到操作符,则从中弹出两个操作数,计算结果,然后把结果入栈。 4、遍历完后缀表达式,则计算完成,此时的栈顶...
  •  * 后缀表达式的实现  */ import java.util.Scanner; import java.util.Stack; import javax.management.RuntimeErrorException; public class OperateStack { public static void main(String[] args
  • 第一步,我们需要将先写出栈和的运算函数 #include <...//利用栈的原理计算简单表达式的值 //第一步,创建的结构类型和的运算函数 //创建用于存储的结构体类型 typedef struct{ Elem *data...
  • 那么可以想到后缀表达式就是操作符在两个数后面。 例子: 中缀表达式:1 + 2 * 3 后缀表达式:1 2 3 * + 算法过程 中存储的是操作符和括号。 从左到右遍历中缀表达式。 遇到括号 遇到左括号,进栈 遇到右括号,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,372
精华内容 12,948
关键字:

如何利用栈求后缀表达式