算数表达式栈

最新推荐文章于 2022-09-01 21:46:44 发布
最新推荐文章于 2022-09-01 21:46:44 发布
阅读量179 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44554979/article/details/103673822
版权

算术表达式（可以算多位数）

#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -1//申请空间失败
#include<conio.h>
#include<dos.h> 
typedef int ElemType;
typedef int Status; 
typedef struct Stack_Node{
	ElemType data;
	struct Stack_Node *next;
}Stack_Node;
typedef struct {
	Stack_Node *top;
	Stack_Node *bottom;
	int length;
}StackList;
StackList Establish()//建栈 
{
	StackList S;
	 S.top=(Stack_Node*)malloc(sizeof(Stack_Node));
	 
	if(!S.top)
	{
		printf("Failed to open up space！\n");
		exit(1);//建站失败 
	}
	S.bottom=S.top;
	S.bottom->next=NULL;
	return S; 
} 
void Push(StackList* S,ElemType e)
{
	
	Stack_Node *newnode=(Stack_Node*)malloc(sizeof(Stack_Node));
	if(!newnode)
	{
		printf("Failed to open up space！");
		exit(1);
	}
	S->top->data=e;
	newnode->next=S->top;
	S->top=newnode;
	 
}
ElemType Pop(StackList* S)//出栈 未判断是否为空 
{
	   Stack_Node *p;//暂时指向top 
     	ElemType e;
     	p=S->top->next;
     	e=p->data;
	    S->top->next=p->next;
		 free(p);
		return e;
	
}
ElemType GetTop(StackList* S)//出栈 未判断是否为空 
{
	   Stack_Node *p;//暂时指向top 
     	ElemType e;
     	p=S->top->next;
     	e=p->data;
		return e;
	
}
Status Precede(ElemType e1,ElemType e2)
{
	int optr[7][7]={//1表示大于，2表示<,-1表示= 
		1, 1, 2, 2, 2, 1, 1,
		1, 1, 2, 2, 2, 1, 1,
		1, 1, 1, 1, 2, 1, 1,
		1, 1, 1, 1, 2, 1, 1,
		2, 2, 2, 2, 2, 0, -1,
		1, 1, 1, 1, -1, 1, 1,
		2, 2, 2, 2, 2, -1, 0 
	};
	//printf("ee%d\n",optr[1][1]);
	int op[7]={'+','-','*','/','(',')','#'};//用于查找运算符的序号
	int i=0;  
	while(op[i]!=e1)
	{
		i++;
	}
	 
	int j=0;  
	while(op[j]!=e2)
	{
		j++;
	}
//	printf("##%d %d %d\n",i,j,optr[i][j]);
	return optr[i][j];
}
/*
Status In(ElemType e)
{
	if()
	{
		return 0;
	}
	else{
		return 1;
	}
}*/
ElemType Operate(ElemType a,char theta,ElemType b)
{
	if(theta=='+')
	{
		return a+b;
	}
	else if(theta=='-')
	{
		return a-b;
	}
	else if(theta=='*')
	{
		return a*b;
	}
	else if(theta=='/')
	{
		return a/b;
	}
}
int Getin(int *f,char ch[],int *k)
{
	int p=0;
	
	if(ch[*k]>='0'&&ch[*k]<='9')
    {
	   p=p*10+ch[*k]-'0';
	  *k=*k+1;
        while(ch[*k]>='0'&&ch[*k]<='9')
	  {
	      //printf(" a  %c\n",a);
	      p=p*10+ch[*k]-'0';
	      *k=*k+1;
	  }
	  *f=0;
	 // *k=*k-1;//再退回去 
	   	
	}
	else{
		*f=1;
		p=(int)ch[*k]; 
		*k=*k+1;
	}
	   //printf("%d",p);
	   return p;
}
int  EvaluateExpression(char* ch)
{
		ElemType c;
		int b, a;
		int flag=0; 
		char theta;
		int k=0;//位置 
	   StackList S1;//操作符栈
	   StackList S2;//操作数栈
    	S1= Establish();
	  S2= Establish();
	   //c='#'
	  Push(&S1,'#');
	  c=Getin(&flag,ch,&k);
	  
  while(c!='#'||GetTop(&S1)!='#')
  {
			if(flag==0) //如果是运算数 
			{
				Push(&S2,c);
				c=Getin(&flag,ch,&k);
			}
			else{
				//printf("%c %c\n",c,GetTop(&S1));
			//	printf("%d\n",Precede(GetTop(&S1),c));
				switch(Precede(GetTop(&S1),c))
				{
					case 2:
						Push(&S1,c);
						c=Getin(&flag,ch,&k);
						break;
				    case 0:
				    		c=Pop(&S1);
				    		c=Getin(&flag,ch,&k);
				    		break;
				   case 1:
				   theta=Pop(&S1);
				   	a=Pop(&S2);
				    b=Pop(&S2);
					Push(&S2,Operate(b,theta,a));
					break;	
				}
			}
  }
	
  return GetTop(&S2);	
 } 
 int main()
 {
 	int value;
 	char ch[1000];
 	printf("请输入算数式（最后请以“#”结束）\n");
	 scanf("%s",ch);
 	value=EvaluateExpression(ch);
 	printf("%d\n",value);
 	return 0;
 }

只能输入个位数


#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -1//申请空间失败
#include<conio.h>
#include<dos.h> 
typedef int ElemType;
typedef int Status; 
typedef struct Stack_Node{
	ElemType data;
	struct Stack_Node *next;
}Stack_Node;
typedef struct {
	Stack_Node *top;
	Stack_Node *bottom;
	int length;
}StackList;
StackList Establish()//建栈 
{
	StackList S;
	 S.top=(Stack_Node*)malloc(sizeof(Stack_Node));
	 
	if(!S.top)
	{
		printf("Failed to open up space！\n");
		exit(1);//建站失败 
	}
	S.bottom=S.top;
	S.bottom->next=NULL;
	return S; 
} 
void Push(StackList* S,ElemType e)
{
	
	Stack_Node *newnode=(Stack_Node*)malloc(sizeof(Stack_Node));
	if(!newnode)
	{
		printf("Failed to open up space！");
		exit(1);
	}
	S->top->data=e;
	newnode->next=S->top;
	S->top=newnode;
	 
}
ElemType Pop(StackList* S)//出栈 未判断是否为空 
{
	   Stack_Node *p;//暂时指向top 
     	ElemType e;
     	p=S->top->next;
     	e=p->data;
	    S->top->next=p->next;
		 free(p);
		return e;
	
}
ElemType GetTop(StackList* S)//出栈 未判断是否为空 
{
	   Stack_Node *p;//暂时指向top 
     	ElemType e;
     	p=S->top->next;
     	e=p->data;
		return e;
	
}
Status Precede(ElemType e1,ElemType e2)
{
	int optr[7][7]={//1表示大于，2表示<,-1表示= 
		1, 1, 2, 2, 2, 1, 1,
		1, 1, 2, 2, 2, 1, 1,
		1, 1, 1, 1, 2, 1, 1,
		1, 1, 1, 1, 2, 1, 1,
		2, 2, 2, 2, 2, 0, -1,
		1, 1, 1, 1, -1, 1, 1,
		2, 2, 2, 2, 2, -1, 0 
	};
	//printf("ee%d\n",optr[1][1]);
	int op[7]={'+','-','*','/','(',')','#'};//用于查找运算符的序号
	int i=0;  
	while(op[i]!=e1)
	{
		i++;
	}
	 
	int j=0;  
	while(op[j]!=e2)
	{
		j++;
	}
//	printf("##%d %d %d\n",i,j,optr[i][j]);
	return optr[i][j];
}
Status In(ElemType e)
{
	if(e>'0'&&e<'9')
	{
		return 0;
	}
	else{
		return 1;
	}
}
ElemType Operate(ElemType a,char theta,ElemType b)
{
	if(theta=='+')
	{
		return a+b;
	}
	else if(theta=='-')
	{
		return a-b;
	}
	else if(theta=='*')
	{
		return a*b;
	}
	else if(theta=='/')
	{
		return a/b;
	}
}
int  EvaluateExpression()
{
		ElemType c;
		int b, a;
		char theta;
	   StackList S1;//操作符栈
	   StackList S2;//操作数栈
    	S1= Establish();
	  S2= Establish();
	   //c='#'
	  Push(&S1,'#');
	  	  c=getchar();
	  
  while(c!='#'||GetTop(&S1)!='#')
  {
   
  	if(!(c=='#'||c=='('||c==')'||c=='+'||c=='-'||c=='*'||c=='/'||c>='0'&&c<='9')){
		printf("你的输入不符合计算器规则！");
		exit(1);
		}
			if(!In(c)) 
			{
				Push(&S2,c-'0');
				c=getchar();
			}
			else{
				//printf("%c %c\n",c,GetTop(&S1));
			//	printf("%d\n",Precede(GetTop(&S1),c));
				switch(Precede(GetTop(&S1),c))
				{
					case 2:
						Push(&S1,c);
						c=getchar();
						break;
				    case 0:
				    		c=Pop(&S1);
				    		c=getchar();
				    		break;
				   case 1:
				   theta=Pop(&S1);
				   	a=Pop(&S2);
				    b=Pop(&S2);
					Push(&S2,Operate(b,theta,a));
					break;	
				}
			}
  }
	
  return GetTop(&S2);	
 } 
 int main()
 {
 	int value;
 	printf("请输入算数式（最后请以“#”结束）\n");
 	value=EvaluateExpression();
 	printf("%d\n",value);
 	return 0;
 }
zero_one_Machel
关注
操作数栈
weixin_43217817的博客
09-26 968
序言 对于操作数栈来说，其实他本身的概念是很模糊的，我们基本上只能通过对字节码指令进行反推才能得出他的结果，但是其实他又深深的藏在字节码指令的每一个角落，基本上所有的字节码指令都是围绕它展开的，小到加减乘除，大到现如今互联网浪潮中的每一次激浪，都离不开他，可以说，他是Java的基石 对于栈这个概念，其实我们多多少少都有所了解，所谓栈，无非就是出栈和入栈，Java虚拟机中的操作数栈也差不多，但是相对...
用栈实现算术表达式的计算
11-28
数据结构课程作业 实现+-*/四则运算和^ 按照优先级来计算
前缀、中缀、后缀表达式-java，中缀转后缀，逆波兰计算器实现
cheng87995211的博客
05-05 329
前缀、中缀、后缀表达式一、前缀表达式(波兰表达式)1. 前缀表达式的计算机求值二、中缀表达式三、后缀表达式1. 后缀表达式的计算机求值四、中缀转后缀表达式五、逆波兰计算器 一、前缀表达式(波兰表达式) 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前 举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 1. 前缀表达式的计算机求值 从右至左扫描表达式，遇...
算数表达式求解（栈）
m0_52192682的博客
09-23 380
题目： 我们需要使用C语言的栈思想去实现简易四则运算表达式 样例： 输入：3+4*5/5 输出结果：7 实现思路： 我们需要设置两个栈，一个用来存储数字，一个用来存储符号，遇见数字压入数字栈，遇见符号就比较于符号栈栈顶符号的优先级（初始符号栈中栈顶元素是‘#’，我们设定‘#’的优先级最低），若优先级大于符号栈栈顶的符号就压入符号栈中，若优先级小于或者等于符号栈栈顶的符号就取数字栈中的两个元素使用符号栈栈顶的符号进行计算，并将计算结果再次存入数字栈中 注意的点： 我们用户在输入算式的时候不可能在式子最后再加上
数据结构栈的运算
Allureyou的博客
11-07 3008
栈在表达式过程中的应用：建立操作数栈和运算符栈。运算符有优先级。规则： 自左至右扫描表达式，凡是遇到操作数一律进操作数栈。 当遇到运算符时，如果它的优先级比运算符栈栈顶元素的优先级高就进栈。反之，取出栈顶运算符和操作数栈栈顶的连续两个操作数进行运算，并将结果存入操作数栈，然后继续比较该运算符与栈顶运算符的优先级。 左括号一律进运算符栈，右括号一律不进运算符栈，取出运算符栈顶运算符和操作数栈顶
算数表达式求值-数据结构实验报告
09-08
这篇报告主要讨论的是一个大一下学期数据结构课程的设计项目，目标是实现一个算数表达式求值的程序。这个程序采用“算符优先法”来处理包含加减乘除及括号的算术表达式，并通过栈这一数据结构来辅助计算。 首先，...
哈工大数据结构作业-算数表达式求值
11-29
在哈工大的数据结构课程中，学生被分配了一项作业，任务是实现一个算数表达式求值的程序。这个程序不仅需要处理基本的算数运算，如加法、减法、乘法和除法，还要扩展到处理小数计算以及涉及变量的计算。这个项目旨在...
使用栈求解算数表达式.docx
10-23
为了求解这样的表达式，我们使用两个栈：一个操作数栈（Operand Stack）用于存储操作数，一个运算符栈（Operator Stack）用于存储运算符。 以下是使用栈求解算术表达式的主要步骤： 1. 初始化操作数栈和运算符栈。...
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
最新发布
06-29
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
算数表达式求值（C实现）
05-05
最后，对于给定的文件"算数表达式求值"，可能包含了实现这个算法的源代码。通过阅读和理解代码，可以深入学习到C语言编程、数据结构（栈）以及算法（算术表达式求值）的应用。同时，也可以通过调试和修改代码来增强...
操作数栈概念
Leon_Jinhai_Sun的博客
05-28 2963
操作数栈：Operand Stack 每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last - In - First -Out）的操作数栈，也可以称之为表达式栈（Expression Stack） 操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop） 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈 比如：执行复制、交换、求和等操作 代码举例 操作数栈，主要用于保存计算过程的中..
对象栈和运算栈
snowyuuu的博客
08-27 6586
表达式3*2^(4+2*2-6*3)-5求值过程中当扫描到6时,对象栈和运算符栈为(),其中^为乘幂 A.3,2,4,1,1;(*^(+*- B.3,2,8;(*^- C.3,2,4,2,2;(*^(- D.3,2,8;*^(- 链接：https://www.nowcoder.com/questionTerminal/3a42f70613294...
算术表达式运算栈实现-数据结构-golang
流年似水
07-07 249
算术表达式运算栈实现-数据结构-golang package main import ( "fmt" "log" "strconv" ) //运算符stack type opStack []string //操作数stack type dataStack []int //操作符的优先级标识 type priority map[string]map[string]int var p = make(priority) func main() { ops := opStack{} init
栈与运算符类
Ray
07-08 308
[code="java"] /** * 栈 * @author RuiLin.Xie - xKF24276 */ class Shed { ArrayList list = new ArrayList(); //长度 public int getSize() { return list.size(); } //存 public voi...
四则运算-栈方法 JAVA
simonGeek的专栏
04-01 1224
栈的规则是先进后出。利用压栈的思想来计算四则运算表达式方法如下：创建两个栈，一个存放四则表达式的数字，另一个存放对应的操作符。 例如一个表达是（3-1）*6-8/4，那么就将这个表达是的数字和操作符分别压入各自的栈，压栈规则如下： 1>遇到数字则直接压入数字栈顶； 2>遇到运算符（+-*/）时，若操作符栈为空，则直接放入操作符栈顶，否则，见3； 3>若操作符栈顶元素的优先级比当前运算符的优先
函数堆栈
OPEN_GIS
08-10 843
函数的调用必须通过堆栈来完成； 函数堆栈：使用的是程序的堆栈段内存空间，程序的堆栈段是系统为程序分配的一种静态数据区，但函数堆栈是在调用函数的时候才动态分配的。所以，不能再编译时就为函数分配好一块静态空间作为堆栈。原因：1）编译时无法确定一个函数运行时所需的堆栈大小；2）函数在调用完后如果还为它保留堆栈空间会浪费内存。
栈是什么
eeeemon的博客
11-20 473
概念 栈Stack：栈顶插入或者删除，栈底不变 基本操作：入栈push，出栈pop 按照存储方式分类 顺序存储：顺序栈 链式存储：链栈 中缀表达式和后缀表达式 定义： 比如：2*（9+6/3-5）+4=??? 这个算数表达式先算括号里的，再算括号里的除法，再算...总之就是存在优先级 这样的表达式就叫做中缀表达式，也叫算术表达式，算出来是16 而计算机如果要计算2*（9+6/3-5）+4，如果也像人一样，先算...，再算...的中缀表示式，程序设计？就很麻烦！！！ 计算机用..
【数据结构】栈（stack）
debug...
09-01 918
栈的应用，波兰表达式，逆波兰表达式
栈之计算表达式值
码路编
04-26 708
算法思想： 规定运算符的优先级表 设置两个栈，运算数栈，运算符栈。 输入一个表达式，自左向右扫描，进行如下处理：若遇到运算数则进栈，若遇到运算符，则与运算符栈中的栈顶元素进行优先级比较。1.如果当前运算符优先级大于栈顶元素的优先级，则当前运算符进栈。2.如果当前运算符的优先级小于等于栈顶元素的优先级，则运算符栈退栈一次，运算数栈退栈两次，得到运算数a和运算数b和运算符op，执行运算后将得到的结果压进
算数表达式求值 栈c++
09-10
算数表达式求值可以使用栈来实现，以下是一个简单的实现示例： ```python def evaluate_expression(expression): # 定义操作符优先级 precedence = {'+': 1, '-': 1, '*': 2, '/': 2} # 定义操作数栈和操作符栈 operand_stack = [] operator_stack = [] # 辅助函数：执行操作符计算 def apply_operator(): operator = operator_stack.pop() operand2 = operand_stack.pop() operand1 = operand_stack.pop() if operator == '+': result = operand1 + operand2 elif operator == '-': result = operand1 - operand2 elif operator == '*': result = operand1 * operand2 elif operator == '/': result = operand1 / operand2 operand_stack.append(result) # 遍历表达式计算结果 for char in expression: if char.isdigit(): operand_stack.append(int(char)) elif char in ['+', '-', '*', '/']: while (operator_stack and operator_stack[-1] != '(' and precedence[char] <= precedence[operator_stack[-1]]): apply_operator() operator_stack.append(char) elif char == '(': operator_stack.append(char) elif char == ')': while operator_stack[-1] != '(': apply_operator() operator_stack.pop() while operator_stack: apply_operator() return operand_stack[-1] expression = input("请输入算数表达式: ") result = evaluate_expression(expression) print(f"表达式的计算结果为: {result}") ``` 这段代码可以读入一个算术表达式，并使用栈来求值。注意，这里只考虑了简单的四则运算，没有处理复杂的情况如函数调用、括号嵌套等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值