数据结构：整数简易四则运算（类实现）

于 2023-04-18 13:03:51 发布
阅读量689 收藏 2
点赞数
分类专栏： 数据结构课程作业 文章标签： 数据结构 c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51264201/article/details/130198070
版权

文章目录

基本要求

用户输入一串表达式字符串，能在txt文本以及控制台输出表达式及其计算结果。

部分结果：
在这里插入图片描述

参照

参考内容为数据结构（c语言版，清华大学出版社）P52~P54 。

思路

总体思路为：字符串经过条件判断后，分别压入两个栈中，然后不断计算得到最终结果输出。
创建栈的结构:

//队列结构
typedef struct Sqstack
{
	char* base;
	char* top;
	int stacksize;
}SqC;


typedef struct V_Sqstack
{
	int* base;
	int* top;
	//计数器
	int stacksize;
}SqV;

基础思路

1.依次判别字符串中字符的类型：数字或运算符。
根据类型不同将字符入不同栈。
读取字符使用的语句是getchar()，整个读取循环操作的基础。
根据输入流不断向下读取：

//不断向下读取字符，直到读取到设置的结束字符，程序结束，得到最终成果。
char c = getchar();

判别函数：

//辅助函数:用于判断字符进栈分类
	bool InOP(char c)
	{
		if (c == '*' || '(' == c || ')' == c || '/' == c || '+' == c || '-' == c || '#' == c)
			return true;
		else
			return false;
	};

判别函数的应用：

//读取数字
		if (!op.InOP(c))
{
//对数字的操作
...
}
else
{
...//对运算符的操作
}

需要注意：
基本四则运算式的顺序并不是一致的，即并不是都从左往右或都从右往左的。因为，运算符有优先级。
例如： 3- 2*2 与 (3-2)*2 运算顺序明显不同。
但两个数的四则运算是固定的。 因此，可以将一个运算式分解成若干个两数的四则运算再进行组合。

例如：
a.在3-2*2中，运算符“ - ”的优先级低于“ * ”，故而，运算顺序为：
2*2 得到 4，然后3 - 4 得到 -1。
b.在(3-2)*2中，由于( )的存在，优先计算内部算式，故而，运算顺序为：
3 - 2 得到 1，然后1*2得到 2。

//计算四则运算式
	int OpOp(int b, char theta, int a)
	{
		if (theta == '*')
			return a * b;
		if (theta == '/')
			return a / b;
		if (theta == '+')
			return a + b;
		if (theta == '-')
			return a - b;

	}

由此，得到下一步思路：

2.栈顶元素运算：
根据运算符优先级的比较，对输入的表达式中数字进行处理。
例如：
3-2*2中，运算符“-”与“*”相比较，运算优先级为“-”小于“ * ”，因此，先处理2与2的运算。
因此，在两个栈中，总是需要根据运算符优先级比较，对栈顶元素进行操作（加入，脱出，更新）。

// 运算符优先级比较表
char OP::Precede(char c1, char c2)
{
	//+ -运算符等级
	if (c1 == '+')
		if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '*' || c2 == '/' || c2 == '(')
			return '<';
		else
			return ERROR;
	else if (c1 == '-')
		if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '*' || c2 == '/' || c2 == '(')
			return '<';
		else
			return ERROR;
	//* /运算符等级
	else if (c1 == '*')
		if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '(')
			return '<';
		else
			return ERROR;
	else if (c1 == '/')
		if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '(')
			return '<';
		else
			return ERROR;
	// ( )运算符等级
	else if (c1 == '(')
		if (c2 == ')')
			return '=';
		else if (c2 == '#')
			return ERROR;
		else
			return '<';
	else if (c1 == ')')
		if (c2 == ')')
			return ERROR;
		else
			return '>';
	else if (c1 == '#')
		if (c2 == '#')
			return '=';
		else
			return '<';
	else
		return ERROR;
}

注明：其中“#”为最后结束输入的判断字符。 相应优先级为最低。

3.输入字符串转化为整型数字
需要注意到，输入的表达式为一串字符串，而在第一步，已经完成了运算符与非运算符的判别，如今需要对类型进行转化。
可以知道的是数字 “0”在阿斯克码中排行"48" 。
则字符型自然数转化为整型的函数可以得到：

int OP::c_to_int(char c)
{
	return int(c - '0');
}

但这种函数现在只能处理一位数字，需要得到连续数字，即大数字转化，设立循环。
因为整数的每一位都由自然数构成。
循环代码：

//将一串自然数转化为int类型数字
			int count = 0;
			//创建字符数组储存转化数字
			const int arr_max = 5;
			char c_to_i[arr_max];
			int to_i[arr_max];
			while (!op.InOP(c))
			{
				c_to_i[count] = c;
				to_i[count++] = op.c_to_int(c);
				//向下移动
				c = getchar();
				To_File(c);

			}
			//转化为数字
			int result = 0;
			for (int i = 1; i <= count; i++)
			{
				int num = to_i[count - i];
				for (int m = 1; m < i; m++)
					num *= 10;
				result += num;
			}

4.根据优先级进行的操作：
优先级根据运算符的不同分为三类：大于，小于，等于。
例如：
大于：“*”>“-”，“*”>“(”。
小于与大于正好相反。
等于：“(”=“)”。
因此根据上述第二步的优先级比较表，使用switch语句进行分支运行。

	switch (op.Precede(op.GetTop(), c))
			{
			case '<':
				op.PushStack(c); c = getchar();
				To_File(c);
				break;
			
			case'=':
				//在运算符栈中，将前括号去掉
				op.Pop(); 
				c = getchar();
				To_File(c);
				break;
			case'>':
				//记录运算符
				int op_ab =op.Pop();
				//两个数字运算
				int a = op.Pop_V();
				int b = op.Pop_V();
				//将两个数字运算后加入栈顶
				op.PushStack(op.OpOp(a, op_ab, b));
				break;
			}

注明：就如代码中注明的，不同的两个运算符比较，会对栈顶进行不同操作，分为三类：
栈顶元素的加入，运算并更改栈顶值，脱出栈顶元素。

类创建

 确认了基本思路后，开始根据思路创建函数。（由于博主更习惯于使用类解决问题，所以程序代码会有所不同。）

类基础数据

数字栈与运算符栈：

//队列结构
typedef struct Sqstack
{
	char* base;
	char* top;
	int stacksize;
}SqC;


typedef struct V_Sqstack
{
	int* base;
	int* top;
	//计数器
	int stacksize;
}SqV;

类中私有数据：

private:
	static const int MAX_SIZE = 20;
	//运算符栈
	SqC oper;
	//运算后得到值的储存栈
	SqV Value;

类中公有函数：

public:
	OP();
	~OP();
	
	//辅助函数:用于判断字符进栈分类
	bool InOP(char c)
	{
		if (c == '*' || '(' == c || ')' == c || '/' == c || '+' == c || '-' == c || '#' == c)
			return true;
		else
			return false;
	};
	//将输入加入到栈队列中
	
	//数字进入数字队列，字符进入字符队列
	void PushStack(char c);
	//数字栈
	void PushStack(int c);

	//得到栈顶元素
	char GetTop()const
	{
		if (oper.top == oper.base)
			return ERROR;
		return *(oper.top - 1);
	}

	int GetPop_V()
	{
		if (Value.top == Value.base)
			return ERROR;
		return *(Value.top - 1);
	}
	//栈顶元素脱出
	char Pop()
	{
		if (oper.top == oper.base)
			return ERROR;
		return *(--oper.top);
	}

	int Pop_V()
	{
		if (Value.top == Value.base)
			return ERROR;
		return *(--Value.top);
	}

	//运算符比较函数
	char Precede(char c, char ch);

	//辅助函数
	//将char 转化为 int
	int c_to_int(char c);
	//计算四则运算式
	int OpOp(int b, char theta, int a)
	{
		if (theta == '*')
			return a * b;
		if (theta == '/')
			return a / b;
		if (theta == '+')
			return a + b;
		if (theta == '-')
			return a - b;
	}

实现方法

  对需要用到的类函数进行实现构造。

类实现方法

构造函数：
创建运算符栈以及数字栈，并初始化类数据。

OP::OP()
{
	//运算符栈
	oper.base = new char[MAX_SIZE];
	oper.top = oper.base;
	oper.stacksize = 0;

	//数字栈
	Value.base = new int[MAX_SIZE];
	Value.top = Value.base;
	Value.stacksize = 0;
}

析构函数：
不做操作。

/析构函数
OP::~OP() {};

元素加入栈顶函数：
由于两个栈只是类型不同，构造相似，故而使用函数重载。

//运算符元素加入栈顶
void OP::PushStack(char c)
{
	//保障安全性
	if (oper.top - oper.base >= MAX_SIZE)
	{
		//复制原栈队列储存值，并且将栈扩容
		oper.base = (char*)realloc(oper.base, (oper.stacksize + MAX_SIZE) * sizeof(char));
		//保证安全性
		if (!oper.base)
			exit(OVERFLOW);
		oper.top = oper.base + oper.stacksize;
		oper.stacksize += MAX_SIZE;
	}
	*oper.top++ = c;
	oper.stacksize++;
}

//int 类型
void OP::PushStack(int c)
{
	if (Value.top - Value.base >= MAX_SIZE)
	{
		//复制原栈队列储存值，并且将栈扩容
		Value.base = (int*)realloc(Value.base, (Value.stacksize + MAX_SIZE) * sizeof(char));
		if (!Value.base)
			exit(OVERFLOW);
		Value.top = Value.base + Value.stacksize;
		Value.stacksize += MAX_SIZE;
	}
	*Value.top++ = c;
	Value.stacksize++;
}

转换函数：

//转化函数：将char型转化为int型
int OP::c_to_int(char c)
{
	return int(c - '0');
}

运算符比较函数：
依次对使用到的所有运算符进行优先级比较。

// 运算符优先级比较表
char OP::Precede(char c1, char c2)
{
	//+ -运算符等级
	if (c1 == '+')
		if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '*' || c2 == '/' || c2 == '(')
			return '<';
		else
			return ERROR;
	else if (c1 == '-')
		if (c2 == '+' || c2 == '-' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '*' || c2 == '/' || c2 == '(')
			return '<';
		else
			return ERROR;
	//* /运算符等级
	else if (c1 == '*')
		if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '(')
			return '<';
		else
			return ERROR;
	else if (c1 == '/')
		if (c2 == '+' || c2 == '-' || c2 == '*' || c2 == '/' || c2 == ')' || c2 == '#')
			return '>';
		else if (c2 == '(')
			return '<';
		else
			return ERROR;
	// ( )运算符等级
	else if (c1 == '(')
		if (c2 == ')')
			return '=';
		else if (c2 == '#')
			return ERROR;
		else
			return '<';
	else if (c1 == ')')
		if (c2 == ')')
			return ERROR;
		else
			return '>';
	else if (c1 == '#')
		if (c2 == '#')
			return '=';
		else
			return '<';
	else
		return ERROR;
}

类中的内联函数：
判断函数：

//辅助函数:用于判断字符进栈分类
	bool InOP(char c)
	{
		if (c == '*' || '(' == c || ')' == c || '/' == c || '+' == c || '-' == c || '#' == c)
			return true;
		else
			return false;
	};

返回栈顶元素：
主要用于栈顶的运算符优先级比较。

//得到栈顶元素
	char GetTop()const
	{
	//保障正确性
		if (oper.top == oper.base)
			return ERROR;
		return *(oper.top - 1);
	}

	int GetPop_V()
	{
		if (Value.top == Value.base)
			return ERROR;
		return *(Value.top - 1);
	}

栈顶元素的脱出：
用于计算过后的字符脱出栈列，以及运算符"(“和”)"的消去。

//栈顶元素脱出
	char Pop()
	{
		if (oper.top == oper.base)
			return ERROR;
		return *(--oper.top);
	}

	int Pop_V()
	{
		if (Value.top == Value.base)
			return ERROR;
		return *(--Value.top);
	}

四则运算：
两数的四则运算是组成计算式的基础。

int OpOp(int b, char theta, int a)
	{
		if (theta == '*')
			return a * b;
		if (theta == '/')
			return a / b;
		if (theta == '+')
			return a + b;
		if (theta == '-')
			return a - b;

	}

类外函数

输入文件函数：
在txt文件中展示：
其中，设立了一个静态变量，通过它控制额外输入：（计算式）

void To_File(char c)
{
	using namespace std;
	//计数器
	static int Count_V = 1;

	ofstream FileOut;
	FileOut.open("OutPut_OP.txt", ios::out | ios::app);
	if (Count_V == 1)
	{
		FileOut << "计算式:\n";
		Count_V++;
	}
	//创建录入数字
	if (!FileOut.is_open())
	{
		cout << "ERROR";
		exit(EXIT_FAILURE);
	}
	//不让结束字符输入到文件中
	if (c != '#')
		FileOut << c;

};

主函数

由思路搭建框架，函数完成具体实现。

int main()
{
using namespace std;
	//创造对象
	OP op;

	//加入字符栈底
    op.PushStack('#');
	ofstream FileOut;
	FileOut.open("OutPut_OP.txt", ios::out | ios::app);
	//创建录入数字
	if (!FileOut.is_open())
	{
		cout << "ERROR";
		exit(EXIT_FAILURE);
	}

	char c = getchar();
	//将除'#'以外的字符都输入到文件中
	To_File(c);
	while (c != '#' || op.GetTop() != '#')
	{
		//读取数字
		if (!op.InOP(c))
		{
			//将一串自然数转化为int类型数字
			int count = 0;
			//创建字符数组储存转化数字
			const int arr_max = 5;
			char c_to_i[arr_max];
			int to_i[arr_max];
			while (!op.InOP(c))
			{
				c_to_i[count] = c;
				to_i[count++] = op.c_to_int(c);
				//向下移动
				c = getchar();
				To_File(c);

			}
			//转化为数字
			int result = 0;
			for (int i = 1; i <= count; i++)
			{
				int num = to_i[count - i];
				for (int m = 1; m < i; m++)
					num *= 10;
				result += num;
			}
			op.PushStack(result);
			//读取符号(已经有了getchar());
		}
		else
			//开始运算
			switch (op.Precede(op.GetTop(), c))
			{
			case '<':
				op.PushStack(c); c = getchar();
				To_File(c);
				break;
			
			case'=':
				//在运算符栈中，将前括号去掉
				op.Pop(); 
				c = getchar();
				To_File(c);
				break;
			case'>':
				//记录运算符
				int op_ab =op.Pop();
				//两个数字运算
				int a = op.Pop_V();
				int b = op.Pop_V();
				//将两个数字运算后加入栈顶
				op.PushStack(op.OpOp(a, op_ab, b));
				break;
			}
	}
	cout << "结果为:\n";
	FileOut << '='<<op.GetPop_V()<<endl;
	return op.Pop_V();
}

至此，程序完成。

程序结果截图

控制台结果输出：

在这里插入图片描述

txt结果输出保存：

在这里插入图片描述

代码仅供参考，如有错误欢迎指正，欢迎留言。

鱼非愚而为瑜
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 长整数四则运算
03-18
本资源完全自己原创，用于给学习数据结构的同学理解并完成线性表的结构。
简单四则运算的实现
weixin_30765319的博客
07-13 127
问题描述： 代码如下： View Code 1 #include <iostream> 2 #include <stack> 3 using namespace std; 4 5 int calculate(int len,char *expStr) 6 { 7 stack<char> st; 8 for(int i=0...
简单的四则运算实现
chuanmp的博客
04-15 730
由键盘输入两个整数，分别计算这两个数的和、差、积、商，并输出结果。输出4行数据，自上而下每行分别为两个数的和、差、积、商的结果。所输入的两个整数用逗号分隔。
数据结构——整数的四则运算
rqc112233的专栏
10-19 1865
栈的应用——整数的四则运算： 例如计算：(1+2)*3-4/4; 代码如下：/************************************************************************/ /* 整数加减乘除四则运算，先要完成后续排列，然后完成数据进出栈 */ /**********************************
【C语言】—— 实现简易四则运算
m0_62386635的博客
09-20 3704
在我们使用计算器进行简单的加减乘除运算的时候，需要注意很多问题，最重要的是乘除法的算数优先级和加减法是不同的，如果在一连串连续输入的时候，我们要如何做到正确解答问题呢？
长整数四则运算数据结构专业课程设计.doc
12-06
长整数四则运算数据结构专业课程设计.doc
数据结构之长整数四则运算
05-03
程序没有问题，内含4个代码文件和1个EXE文件，绝对OK
数据结构长整数四则运算代码
11-02
该文件为数据结构中，长整数四则运算课程设计代码
C++实现正整数的四则运算表达式
12-17
本文实例为大家分享了C++正整数的四则运算表达式的具体代码，供大家参考，具体内容如下 设计程序，用户输入一个正整数的四则运算表达式的字符串，输出相应的运算结果。 （假设每个字符串表达式只有一个运算符，且是...
C#实现的简单整数四则运算计算器功能示例
08-29
主要介绍了C#实现的简单整数四则运算计算器功能,涉及C#界面布局、事件响应及数值运算等相关操作技巧,需要的朋友可以参考下
长整数四则运算 C语言
04-25
首先对输入串进行输入格式判断，如果判断不正确则重新输入，输入正确将输入串存储在链表中 。根据链表的存储结果和相应算法对链表进行相应的操作。判断输入串是整数还是负数决定是否输出‘-’，对两串的绝对值的大小进行比较，并根据四则运算控制符的符号来判断进行的运算和符号标识位的值。
c语言 大整数四则运算
05-21
用C语言实现大整数（超过ulong的取值范围）的四则运算
用c语言实现超长整数的四则运算
03-22
在编程计算时, 程序设计语言本身的计算精度能满足一般问题的精度要求, 但对于计算精度要求较高 的一些特殊问题, 如计算100 阶乘的精确值, 用普通编程方法不能满足精度要求, 必须采用特殊的编程方 法。本文把计算机原理中的数值运算方法应用于高级语言编程, 总结出了一个提高计算精度的有效方法, 叫做分段运算法, 如不考虑机器的运行时间和内存容量, 采用这种方法可以使计算精度达到任意位。
简单四则运算实现--第二次作业
weixin_30542079的博客
11-09 190
这次的代码码云地址为：https://gitee.com/z_m_g/personal_project41678/tree/master/2016035107300 PSP2.1 Personal Software ProcessStages 预估耗时（分钟） 实际耗时（分钟） Planning 计划 480 ...
C语言实现简易四则运算表达式
m0_55124878的博客
09-22 6359
简单理解： 对于C语言实现四则运算我们首先必须知道先乘除后加减，由于这个特性，所以四则运算的运算顺序极为重要，对于怎样解决这个问题，我们可以想到使用栈来解决。 大体思路： 首先，一说到栈，我们能想到栈的特殊处理方式，先进后出，由此我们又能想到，使用两个栈利用它特殊的处理方式来实现简单的四则运算，第一个栈用来存储数据，将你输入的字符串中的所有的数字都存入这个栈中，方便后续的使用，另一个栈用来存储符号，当然不能只无脑的往栈中存储，还需要考虑怎么才能实现先乘除后加减的特殊运算顺序，此时我们可以为其特殊的符号赋予不
完成简单的四则运算（包含小括号）（栈）
qq_41891805的博客
02-18 625
设计目标：借用栈的特性（后进后出），可将先进入的数据进行暂时存储，在得到运算符后进行运算。 考虑因素：因为四则运算中既包含一级运算也包含二级运算（优先级高），所以需对这两种情况进行不同的区分，此外对于出现小括号时压栈和出栈的情况也要进行考虑。 主要思路： 由于栈的特性，我们可以在拿到运算符时进行对前一个运算符进行判断，借此来完成数值的运算。 1）、建立两个栈结构、一个存储运算符（栈A）、一个存储数...
计算公式 - 四则运算实现
_
01-22 2246
计算公式 - 四则运算实现 要对公式进行运算，首先需要实现基础的四则运算（包含符号()+-*/），用于解析一个字符串的计算式子（如：'(6+2)/4-2'）。算法思路如下： 第一步：中缀表达式转后缀表达式 中缀表达式是利于人理解的表达方式，而后缀表达式更方便计算机的运算。 <section> （或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。 与前缀表达式（例：+ 3 4）或后缀表达式（例
给你一个简单的四则运算表达式，包含两个实数和一个运算符，请编程计算出结果
weixin_53287269的博客
03-31 2303
C++ 给你一个简单的四则运算表达式，包含两个实数和一个运算符，请编程计算出结果 #include<iostream> using namespace std; #include<iomanip> #include<math.h> int main() { double s1, s2; char op; cin >> s1 >> op >> s2; switch (op) { case'+': cout <<
C语言：整数四则运算
2301_76472823的博客
03-24 1034
例题：答案：
长整数四则运算   数据结构
最新发布
08-27
在数据结构中，常用的方法是使用字符串来表示长整数，并通过模拟手工计算的方式进行运算。 一种常见的做法是将长整数表示为字符串，每一位数字对应字符串中的一个字符。然后按照手工计算的方式进行加减乘除运算，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值