《数据结构实验》第三章实验：多位整数带括号的简单四则运算器

最新推荐文章于 2023-07-27 20:10:03 发布
最新推荐文章于 2023-07-27 20:10:03 发布
阅读量699 收藏 11
点赞数 3
分类专栏： C语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18404993/article/details/84575299
版权

四则运算器：实现多位整数的带括号的四则运算  

#include <stdio.h>
#include <stdlib.h>
 
#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType;
typedef struct
{
	StackElementType elem[Stack_Size];
	int top;
}SeqStack;
typedef struct
{
	int elem[Stack_Size];
	int top;
}SeqStack_num;
//初始化栈
void InitStack(SeqStack *S)
{
	S->top=-1;
} 

void InitStack_num(SeqStack_num *S)
{
	S->top=-1;
} 
//进栈
int Push(SeqStack *S,StackElementType x)
{
	if(S->top==Stack_Size-1)
	 return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}
int Push_num(SeqStack_num *S,int x)
{
	if(S->top==Stack_Size-1)
	 return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}
//出栈
int Pop(SeqStack *S,StackElementType *x)
{
	if(S->top==-1)
	 return(FALSE);
	else
	{
		*x=S->elem[S->top];
		S->top--;
		return(TRUE); 
	}
} 
int Pop_num(SeqStack_num *S,int *x)
{
	if(S->top==-1)
	 return(FALSE);
	else
	{
		*x=S->elem[S->top];
		S->top--;
		return(TRUE); 
	}
} 
//读栈顶元素
StackElementType GetTop(SeqStack *S)
{
	StackElementType x;
	if(S->top==-1)
	 return(FALSE);
	else
	{
		x=S->elem[S->top];
		return(x);
	}
} 
int GetTop_num(SeqStack_num *S)
{
	int x;
	if(S->top==-1)
	 return(FALSE);
	else
	{
		x=S->elem[S->top];
		return(x);
	}
} 

//优先级比较函数

/*StackElementType Compare(StackElementType ch,StackElementType ch_temp)
{
	char compare[7][7]={
		{'<','<','<','<','<','0','>'},
		{'<','<','<','<','<','0','>'},
		{'>','>','<','<','<','0','>'},
		{'>','>','<','<','<','0','>'},
		{'>','>','>','>','>','0','>'},
		{'<','<','<','<','=','0','0'},
		{'<','<','<','<','<','0','0'}
	
	};
	int index,index_temp;
	switch(ch)
	{
		case '+':index=0;break;
		case '-':index=1;break;
		case '*':index=2;break;
		case '/':index=3;break;
		case '(':index=4;break;
		case ')':index=5;break;
		case '#':index=6;break;
	}
	switch(ch_temp)
	{
		case '+':index_temp=0;break;
		case '-':index_temp=1;break;
		case '*':index_temp=2;break;
		case '/':index_temp=3;break;
		case '(':index_temp=4;break;
		case ')':index_temp=5;break;
		case '#':index_temp=6;break;
	}
	return(compare[index][index_temp]);
}
*/
StackElementType Compare(StackElementType m,StackElementType n){
	switch(m){
	case'+':switch(n){
			case'+':return '=';
			case'-':return '=';
			case'*':return '<';
			case'/':return '<';
			case'#':return '>';
			case'(':return '>';
			}
	case'-':switch(n){
			case'+':return '=';
			case'-':return '=';
			case'*':return '<';
			case'/':return '<';
			case'#':return '>';
			case'(':return '>';
			}
	case'*':switch(n){
			case'+':return '>';
			case'-':return '>';
			case'*':return '=';
			case'/':return '=';
			case'#':return '>';
			case'(':return '>';
			}
	case'/':switch(n){
			case'+':return '>';
			case'-':return '>';
			case'*':return '=';
			case'/':return '=';
			case'#':return '>';
			case'(':return '>';
			}
	case'(':switch(n){
			case'+':return '>';
			case'-':return '>';
			case'*':return '>';
			case'/':return '>';
			case'#':return '>';
			case'(':return '>';
			}
	default:return '<';
	}
}


//主函数
int main()
{
	SeqStack_num OVS;
	SeqStack OPTR;
	InitStack_num(&OVS);
	InitStack(&OPTR);//初始化
	char ch,ch_temp,op;
	int num,v,temp,x;
	Push(&OPTR,'#');
	printf("Please input an expression(Ending with #):");
	ch=getchar();
	while(ch!='#'||GetTop(&OPTR)!='#')
	{
		if(ch>='0'&&ch<='9')//不是操作符，是操作数 
		{
			temp=ch-'0';//先把当前操作数从字符转换成数字 
			ch=getchar();
			while(ch>='0'&&ch<='9')
			{
				temp=temp*10+ch-'0';
				ch=getchar();
			}
			Push_num(&OVS,temp);
		}
		else
		{
		 switch(Compare(ch,GetTop(&OPTR)))
		 {
		 	case '>':Push(&OPTR,ch);ch=getchar();break;
		 	case '=':
		 	case '<':
		 		num=GetTop_num(&OVS);
				Pop_num(&OVS,&x);
				switch(GetTop(&OPTR)){
					case'+':num=GetTop_num(&OVS)+num;break;
					case'-':num=GetTop_num(&OVS)-num;break;
					case'*':num=GetTop_num(&OVS)*num;break;
					case'/':num=GetTop_num(&OVS)/num;break;
				}
				Pop(&OPTR,&op);
				Pop_num(&OVS,&x);
				Push_num(&OVS,num);
				if(ch==')'){
					Pop(&OPTR,&op);
					ch=getchar();
				}
		 }
		}
		v=GetTop_num(&OVS);

		 
		
	}
	printf("the result is %d",v);
	
	 
}

 下面是两个失败的例子

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType; //运算符 
typedef double StackElementType_num; //运算数 
typedef struct
{
	StackElementType elem[Stack_Size];
	int top;
}SeqStack; //运算符栈 
typedef struct
{
	StackElementType_num elem[Stack_Size];
	int top;
}SeqStack_num; //运算数栈 

StackElementType_num ExpEvaluation();

void InitStack(SeqStack *S);
int Push(SeqStack *S,StackElementType x);
int Push_num(SeqStack *S,StackElementType_num x);

int Pop(SeqStack *S,StackElementType *x);
int Pop_num(SeqStack *S,StackElementType_num *x);
int GetTop(SeqStack *S,StackElementType *x);
int GetTop_num(SeqStack *S,StackElementType_num *x);
StackElementType Compare(StackElementType ch1,StackElementType ch2);
StackElementType Execute(StackElementType_num a,StackElementType op,StackElementType_num b);

int main()
{
    printf("%lf",ExpEvaluation()); 
	return(0);
}
StackElementType_num ExpEvaluation()
{
	char exp[100];//用字符数组将运算表达式存起来 
	int i=0,count=0;
	printf("Please input an expression (Ending with #:)");
	exp[i]=getchar();
	while(exp[i]!='#')
	{
		i++;count++; 
		exp[i]=getchar();
	}
	SeqStack OPTR;
	SeqStack_num OVS;
	StackElementType ch,op,x;
	StackElementType_num a,b,v;
	InitStack(&OPTR);
	InitStack(&OVS);
	Push(&OPTR,'#');
	for(i=0;i<count;i++)
	{
		ch=exp[i];
		while(ch!='#'||GetTop(&OPTR,&x)!='#')
	    {
		  if(ch>='0'&&ch<='9')//不是操作符，是操作数，进OVS栈 
		  {
			int temp;
			temp=ch-'0';//先把当前操作数从字符变为数字 
			i++;
			ch=exp[i];
			while(ch>='0'&&ch<='9')//继续判断下一位是否为操作数
			{
				temp=temp*10+ch-'0';
				i++;
				ch=exp[i];
			} 
			Push_num(&OVS,temp);//压栈 
			
		  }
		  else
		  switch(Compare(ch,GetTop(&OPTR,&x)))
		  {
			case '>':Push(&OPTR,ch);
			  i++;ch=exp[i];
			case '=':Pop(&OPTR,&op);i++;ch=exp[i];break;//脱括号 
			case '<':Pop(&OPTR,&op);//形成运算 
		    Pop_num(&OVS,&b);
		    Pop_num(&OVS,&a);
		    v=Execute(a,op,b);
		    Push_num(&OVS,v);
		    break; 
		  }
	    }
	}
	
	v=GetTop_num(&OVS,&x);
	return(v);
} 

//初始化
void InitStack(SeqStack *S)
{
	/*构造一个空栈S*/
	S->top=-1; 
} 
//进栈
int Push(SeqStack *S,StackElementType x)
{
	if(S->top==Stack_Size-1)
	 return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
} 
int Push_num(SeqStack *S,StackElementType_num x)
{
	if(S->top==Stack_Size-1)
	 return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
} 

//出栈
int Pop(SeqStack *S,StackElementType *x)
{
	if(S->top==-1)
	 return(FALSE);
	*x=S->elem[S->top];
	S->top--;
	return(TRUE);
} 
int Pop_num(SeqStack *S,StackElementType_num *x)
{
	if(S->top==-1)
	 return(FALSE);
	*x=S->elem[S->top];
	S->top--;
	return(TRUE);
} 

//读栈顶
int GetTop(SeqStack *S,StackElementType *x)
{
	if(S->top==-1)
	 return(FALSE);
	else
	{
		*x=S->elem[S->top];
		return(TRUE);
	}
} 

int GetTop_num(SeqStack *S,StackElementType_num *x)
{
	if(S->top==-1)
	 return(FALSE);
	else
	{
		*x=S->elem[S->top];
		return(TRUE);
	}
} 


//比较优先级，返回'>','<','=' 
StackElementType Compare(StackElementType ch1,StackElementType ch2)
//ch1为还未进栈的运算符，ch2为当前运算符栈顶元素 
{
	//'('未入栈时，优先级最高，入栈后，优先级最低
	int m,n; 
	switch(ch1)
	{
		case '(':m=6;break;
		case '*':
		case '/':m=5;break;
		case '+':
		case '-':m=4;break;
		case ')':m=3;break;
		
	}
	switch(ch2)
	{
		case '*':
		case '/':n=6;break;
		case '+':
		case '-':n=5;break;
		case ')':n=4;break;
		case '(':n=3;break;
		
	}
	if(ch1>ch2)
	 return('>');
	 else if(ch1=ch2)
	  return('=');
	  else
	   return('<');
}
StackElementType_num Execute(StackElementType_num a,StackElementType op,StackElementType_num b)
{
	StackElementType_num v;
	switch(op)
	{
		case '+':v=a+b;break;
		case '-':v=a-b;break;
		case '*':v=a*b;break;
		case '/':v=a/b;break;
	}
	return(v);
}

 

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType; 
typedef struct
{
	StackElementType elem[Stack_Size];
	int Top;
}SeqStack; 

void InitStack(SeqStack *S);
int Push(SeqStack *S,StackElementType x);
int Pop(SeqStack *S,StackElementType *x);
int GetTop(SeqStack *S,StackElementType *x);
StackElementType Compare(StackElementType ch1,StackElementType ch2);
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b);

int main()
{
    printf("%c",ExpEvaluation()); 
	return(0);
}
StackElementType ExpEvaluation()
{
	SeqStack OPTR,OVS;
	StackElementType n;
	StackElementType a,b,ch,op,x,v;
	InitStack(&OPTR);
	InitStack(&OVS);
	Push(&OPTR,'#');
	printf("Please input an expression(Ending with #):");
	ch=getchar();//为方便，所以数字也以字符形式来存储 
	while(ch!='#'||GetTop(&OPTR,&x)!='#')
	{
		if(ch>='0'&&ch<='9')//不是操作符，是操作数，进OVS栈 
		{
			int temp;
			temp=ch-'0';//先把当前操作数从字符变为数字 
			ch=getchar();
			while(ch>='0'&&ch<='9')//继续判断下一位是否为操作数
			{
				temp=temp*10+ch-'0';
				ch=getchar();
			} 
			Push(&OVS,temp);
			
		}
		else
		switch(Compare(ch,GetTop(&OPTR,&x)))
		{
			case '>':Push(&OPTR,ch);
			  scanf("%d",&ch);
			case '=':Pop(&OPTR,&op);ch=getchar();break;//脱括号 
			case '<':Pop(&OPTR,&op);//形成运算 
		    Pop(&OVS,&b);
		    Pop(&OVS,&a);
		    v=Execute(a,op,b);
		    //此处需要将v转换为字符型并且入站 
		    Push(&OVS,v);
		    break; 
		}
	}
	v=GetTop(&OVS,&x);
	return(v);
} 

//初始化
void InitStack(SeqStack *S)
{
	/*构造一个空栈S*/
	S->top=-1; 
} 
//进栈
int Push(SeqStack *S,StackElementType x)
{
	if(S->top==Stack_Size-1)
	 return(FALSE);
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
} 
//出栈
int Pop(SeqStack *S,StackElementType *x)
{
	if(S->top==-1)
	 return(FALSE);
	*x=S->elem[S->top];
	S->top--;
	return(TRUE);
} 
//读栈顶
int GetTop(SeqStack *S,StackElementType *x)
{
	if(S->top==-1)
	 return(FALSE);
	else
	{
		*x=S->elem[S->top];
		return(TRUE);
	}
} 


//比较优先级，返回'>','<','=' 
StackElementType Compare(StackElementType ch1,StackElementType ch2)
//ch1为还未进栈的运算符，ch2为当前运算符栈顶元素 
{
	//'('未入栈时，优先级最高，入栈后，优先级最低 
	switch(ch1)
	{
		case '(':ch1=6;break;
		case '*':
		case '/':ch1=5;break;
		case '+':
		case '-':ch1=4;break;
		case ')':ch1=3;break;
	}
	switch(ch2)
	{
		case '*':
		case '/':ch2=5;break;
		case '+':
		case '-':ch2=4;break;
		case ')':ch2=3;break;
		case '(':ch2=2;break;
	}
	if(ch1>ch2)
	 return('>');
	 else if(ch1=ch2)
	  return('=');
	  else
	   return('<');
}
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b)
{
	double v;
	switch(op)
	{
		case '+':v=(double)a+(double)b;break;
		case '-':v=(double)a-(double)b;break;
		case '*':v=(double)a*(double)b;break;
		case '/':v=(double)a/(double)b;break;
	}
	return((StackElementType)v);
}

 

Zijeak
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 （1）能够判断表达式中的括号是否匹配，测试的表达式中括号不匹配，可以重新输入。 （2）能够处理多位整数以及浮点数。 （3）具体测试数据...
c语言 数据结构 多为整数带括号四则运算,用C语言实现 多位整数的四则运算，用栈，例如56*（12+20）-102/2...
weixin_28681255的博客
05-22 278
该楼层疑似违规已被系统折叠隐藏此楼查看此楼gets(szExpression);// 中缀表达式转后缀表达式，结果保存在expression中for (int i = 0; i < strlen(szExpression); i++){if (isspace(szExpression[i])) // 空白字符{if (bFindBegin){expression[num].type = ...
用C语言中栈的思想实现加减乘除四则运算和括号的计算器
九幽小班的博客
02-26 7278
用C语言中栈的思想实现加减乘除四则运算和括号的计算器 设计思路 将每个运算符设置优先级，运用栈先入后出的思想，从左到右扫描输入到电脑上的计算公式，将扫描到的数字数据和字符数据的优先级分别存入两个数组，再依次从两个数组中弹出对应的数据和计算符号进行计算 主要问题 1.如何让计算机实现正确的符号计算顺序？ 为每个符号设定相应的优先级，在这个程序中我将+，-优先级设置为1，*，/设置为2，（设置为3，）...
c语言 数据结构 多为整数带括号四则运算,用C语言数据结构算法编写程序!算术表达式求值：以字符序列的形式从终端输入语法正确的、不含变量的整数表达式,利用给定的算符优先关系,实现对算术四则混合运算表达式...
weixin_35931397的博客
05-22 549
优质解答#include#include#include#defineLENsizeof(stacknode)typedefstructstacknode{chardata;structstacknode*next;}stacknode;typedefstruct{stacknode*top;}LinkStack;intprecedence(charc){switch...
数据结构实验三
kexuhang的博客
06-16 800
题目描述 树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。对于每一个结点至多只有两棵子树的一类树，称其为二叉树。二叉树的链式存储结构是一类重要的数据结构，其形式定义如下：而二叉树的前序、中序遍历是非常重要的能够访问二叉树所有结点的算法，下面分别列出一种先序遍历和两种中序遍历的算法。第一种中序遍历的方法（算法6.3）：第二种中序遍历的方法（算法6.2）：通过读入一个字符串，建立二叉树的算法如下：在本题中，将会给出一个按照先序遍历得出的字符串，空格代表空的子节点，大写字母代表节点内容。请通过这个字
【C语言】数据结构C语言版 实验3 带头结点的单链表
点滴记忆
12-09 4940
slnklist.h #include <stdio.h> #include <stdlib.h> /**************************************/ /* 链表实现的头文件，文件名slnklist.h */ /**************************************/ typedef int datatype...
四则运算实现（c 语言 数据结构课程设计题
07-02
在本课程设计中，主要任务是使用C语言和数据结构实现基本的四则运算。这里采用了堆栈（Stack）的数据结构来处理运算过程中的运算符和操作数。堆栈是一种后进先出（LIFO）的数据结构，非常适合处理数学表达式中的...
第1讲最简单的C语言程序设计(1)ppt课件.ppt
11-13
3. **高级语言（算法语言）**：如C语言，第三代语言，通过编译程序转换成机器语言，可编译一次多次运行，或通过解释程序逐行翻译执行。 4. **非过程化语言**：第四代，如SQL，只描述问题需求，不关注执行过程。 5. *...
C语言经典源代码实例 数据结构 操作系统 图形等
12-28
108 递归整数四则运算 109 复平面作图 110 绘制彩色抛物线 111 绘制正态分布曲线 112 求解非线性方程 113 实矩阵乘法运算 114 求解线性方程 115 n阶方阵求逆 116 复矩阵乘法 117 求定积分 118 求满足特异...
Lua教程（三）：表达式和语句
09-22
Lua是一种轻量级的脚本语言，...例如，理解table构造器的灵活性，可以帮助你创建复杂的数据结构，而掌握逻辑操作符的短路行为，则有助于编写简洁高效的代码。在实际编程中，这些基础知识将为你的项目提供强大的支撑。
计算器（加减乘除基本运算-带括号）
05-22
计算器（加减乘除基本运算-带括号） 去除字符串中的所有空格 检查算术表达式的基本合法性 判断字符是否是0-9的数字 测试
C语言图书管理系统 大学C语言项目作业
12-25
C语言编写的图书管理系统,项目作业 #include #include #include #include #include #define STACK_INIT_SIZE 10 #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 struct student /*定义学生类型，用于存放借出的书籍*/ { int carnum; char lendbook[10]; }student[1000]; struct employ /*定义职工类型*/ { int employnum; char employname[15]; int employage; char employsex[2]; char employleve[10]; long int employtage; }employ[50]; struct book /*定义书的类型*/ { int booknum; char bookname[10]; char bookcreat[10]; int turefalse; /*用于借书和还书模块判断一本书是否借出的条件*/ }book[1000]; struct car /*借书卡的数据类型*/ { int carnum; char studentname[10]; int studentclass; }car[100];
使用栈实现的带括号的四则运算
01-13
用栈实现的四则运算。支持括号，以及多位数字。使用了中序转后序然后计算的思路。
简易计算器（数据结构）
12-23
利用数据结构中的栈的知识完成加减乘除乘方五种运算，可运用小括号
C++实现四则运算器（带括号）
01-19
本文实例为大家分享了C++实现四则运算器的具体代码，供大家参考，具体内容如下 基本分析可以看另一篇文章：C++实现四则运算器(无括号) 栈的实现 //stack.h #ifndef STACK_H #define STACK_H #include<iostream> class stack_int { private: int* bottom; //栈底 int* top; //栈顶 unsigned int capacity;//栈容量 unsigned int size; //栈大小 public: stack_int() :bottom(new int[11]),
数据结构教程实验三栈的应用
Annzz123的博客
06-16 1563
三、实验要求1.用Ｃ描述栈的每种操作在顺序栈或链栈上的实现。2.将初始化栈、判断栈是否非空、入栈、出栈、十进制到二进制的转换分别定义为5个子函数，通过主函数实现对上述子函数的调用。四、实验内容 1.实现顺序栈的各种基本运算在实现顺序栈各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化栈s。（2）判断栈s是否为空。3）依次将6，3，8，10元素进栈s。（4）判断栈s是否为空。（5）输出栈序列。（6）判断栈s是否为空。（7）释放栈s。
【数据结构】实验三：链表
最新发布
m0_65787507的博客
07-27 2130
数据结构实验
【数据结构】【a】十进制整数四则运算计算器正文终稿.doc
07-11
"该文档是东北大学信息科学与工程学院数据结构课程设计报告，主题是构建一个十进制整数四则运算计算器。学生需要根据输入的四则运算表达式字符串，生成相应的二叉树，并通过后序遍历计算出结果。设计要求包括使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值