基于逆波兰算法的计算方法C++程序(计算器算法)

最新推荐文章于 2023-11-24 17:36:38 发布
最新推荐文章于 2023-11-24 17:36:38 发布
阅读量1.5k 收藏 18
点赞数 4
分类专栏： VC++ 文章标签： 逆波兰算法 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37358422/article/details/81123192
版权

主要有以下功能：可以连续计算四则运算，可以自己分辨多位数，小数，负数。

后续会加入sin(),cos()等。(已经加入sin,cos,tan,次方pow,阶乘！

，开平方sqrt，取对数log）

主要原理：

建立两个栈，一个用于存放数字，一个用于存放符号。

判断符号优先级，当符号优先级低于符号栈的栈头时，栈头出栈。（括号另算）否则则入栈。

出栈的符号进行运算，读取数字栈的两个数字并进行运算，将计算值返回至数字栈。

当输入的式子已全部读取完成时，若此时符号栈还有元素（此时数字栈肯定也还有），则从栈头逐个出栈，并进行运算。并将最后的计算值，返回数字栈的栈头。

对于括号，“（”拥有最高的优先级，“）”则为最低优先级。当运行时符号栈的出栈会在栈头为“（”时停止。

上面只是大致的概括，具体的请看程序：

#include<stack>
#include<iostream>
#include<math.h>
using namespace std;


stack<long double> _nu;	//用于存储数字的栈
stack<char> op;		//用于存储符号的栈

int nu_flag = 0;	//用于判断是否为多位数
int de_flag = 0;	//用于判断小数点
int	ne_flag = 1;	//用于判断负数
int tri_flag = 0;	//用于判断三角函数
int judge_time = 0;  //用于判断使用judge_time的次数

void nu_operat( char op );		//符号操作函数
char tri_function( char str );	//符号判断函数
long double fact( long double _number );	//阶乘运算函数

long double level( char str )	//用于判断优先级
{
	if( str == '(')
		return 6;
	else if( str == '!' )
		return 5.85;
	else if( str == '^' )
		return 5.75;
	else if ( (str == 'g') || (str == 'r') )
		return 5.73;
	else if( (( str == 'n' ) && ((tri_flag == 3) || (op.top() == 'n'))) || 
			 (( str == 's' ) && ((tri_flag == 6) || (op.top() == 's'))) ||
			 (( str == 't' ) && ((tri_flag == 9) || (op.top() == 't')))  )
		return 5.5;								//拿这个做示例，当这个为6.5时,sin(1.57)
	else if( ( str == '*' ) || ( str == '/' ) )
		return 5;
	else if( ( str == '+' ) || ( str == '-' ) )
		return 4;
	else if( ( str >= '0' ) || ( str <= '9' ) )
		return 3;
	else if( str == ')' )
		return 2;
	else if( str == '#' )
		return 1;
	else 
		return 0;
}

int judge(char str1)
{
	long double num = 0;
	char op1;
	int flag = 0; //用于判断括号的清除
	char str;


	judge_time++;
	
	str = tri_function( str1 );
	if( (str == '-') ||  (str == '(')  )ne_flag++;
	if( (ne_flag == 2) && (str == '(') )ne_flag = 1;
	if( ( str >= '0' ) && ( str <= '9') && ( nu_flag == 0 ))	//此处为数字栈的入栈口一，为1位数入栈口
	{
		num = (long double)str -48;
		if(ne_flag == 2) num = num*(-1);			//进行负数的转换
		else ne_flag =0;
		_nu.push(num);
		nu_flag = 1;
	}else if( ( ( str >= '0' ) && ( str <= '9') || ( str == '.' ) ) && ( nu_flag == 1) )	//此处为数字栈的入栈扣二,多位数和小数的入栈口
	{
		if((!de_flag)&&(str != '.'))		//此处为多位数的入栈口
		{
			num = 10 * _nu.top();
			if(ne_flag != 2) num = num + (long double)str - 48;		
			else num = num - (long double)str + 48;				//进行负数转换
			_nu.pop();
			_nu.push(num);
		}else if(de_flag)					//此处为小数的入栈口
		{
			num = _nu.top();
			if(ne_flag != 2) num = num + ( (long double)str - 48 ) / pow(10,de_flag);
			else num = num - ( (long double)str -48 ) / pow(10,de_flag);			//进行负数转换
			_nu.pop();
			_nu.push(num);
		}
		if(  (str == '.') || ( de_flag ) )de_flag ++;
		nu_flag = 1;
	}else if( ( ( level(str) == 4 ) || ( level(str) == 5 ) || ( level(str) == 5.75 ) || ( level(str) == 5.85 ) || ( level(str) == 6 ) ||
		( (str == 'n') && (tri_flag == 3) ) || ( (str == 's') && (tri_flag == 6) ) || ( (str == 't') && (tri_flag ==9) ) ||
		( (str == 'g') && (tri_flag == 12)) || ( (str == 'r') && (tri_flag == 16)) ) &&
		( ( level( str ) > level( op.top() ) ) || ( ( op.top() == '(' ) &&  ( level(str) >= 4 ) ) ) )
	{															//此处为符号栈的入栈口
		
		if( (str != '(') && (str != '-' ) )ne_flag = 0;
		if( (ne_flag != 2) || ((str == '-')&&(judge_time == 1)) )op.push( str );	//仅首个字符为'-'号时可进入
		if((str == '-')&&(judge_time == 1)) ne_flag = 0;
		nu_flag = 0;
		de_flag = 0;
		return num;
	}else if( ( ( level(str) >= 4 ) && ( ( level( str ) <= level(( op.top() ) ) ) ) || ( str == ')') ) )
	{															//此处为符号栈的出栈口一，即当仍有输入时的出栈规则
		if( (str != '(') && (str != '-' ) )ne_flag = 0;
		nu_flag = 0;
		de_flag = 0;
		char a = op.top();
		while( ( ( level( str ) <= level( op.top() ) )&& ( op.top() != '#' ) ) &&  ( op.top() != '(' ) ) 
		{
			op1 = op.top();
			op.pop();
			nu_operat( op1 );
			if( ( op.top() == '(' ) && ( str == ')' ) )
			{
				op.pop();
				flag = 1;
				break;
			}
		}
		if( str != ')' )op.push( str );
		else if( ( str == ')' ) && ( op.top() == '(' ) && ( flag == 0 ) )op.pop();
		char b = op.top();
		long double c = _nu.top();
		return num;
	}
	while( (op.top() != '#') && ( str == 'z' ) )				//此处为符号栈的出栈口二，即没有输入时的出栈规则
	{
		op1 = op.top();
		op.pop();
		nu_operat( op1 );
	}
	
	return num;
}

void nu_operat( char op )		//符号运算，使相应的符号进行运算，并将结果存入数字栈头部
{
	long double nu1,nu2;
	switch(op)
	{
	case '*':
		nu1 = _nu.top();
		_nu.pop();
		nu2 = _nu.top();
		_nu.pop();
		_nu.push( nu2 * nu1 );
		break;
	case '/':
		nu1 = _nu.top();
		_nu.pop();
		nu2 = _nu.top();
		_nu.pop();
		_nu.push( nu2 / nu1 );
		break;
	case '+':
		nu1 = _nu.top();
		_nu.pop();
		nu2 = _nu.top();
		_nu.pop();
		_nu.push( nu2 + nu1 );
		break;
	case '-':
		nu1 = _nu.top();
		_nu.pop();
		nu2 = _nu.top();
		_nu.pop();
		_nu.push( nu2 - nu1 );
		break;
	case 'n':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( sin( nu1 ) );
		break;
	case 's':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( cos( nu1 ) );
		break;
	case 't':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( tan( nu1 ) );
		break;
	case '^':
		nu1 = _nu.top();
		_nu.pop();
		nu2 = _nu.top();
		_nu.pop();
		_nu.push( pow( nu2, nu1 ) );
		break;
	case '!':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( fact(nu1) );
		break;
	case 'g':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( log(nu1)/log(10) );
		break;
	case 'r':
		nu1 = _nu.top();
		_nu.pop();
		_nu.push( sqrt( nu1 ) );
		break;
	default:
		break;
	}
}

long double fact( long double _number)	//阶乘会自动取整，故返回为整数
{
	if( _number <0 )return -1;
	int n = _number;
	long double results = 1;

	if( n == 0 )results = 1;
	else if( n >= 1)
	{
		for(int i = 1;i <= n; i++)
			results = i * results;
	}

	return results;
}

 char tri_function( char str )	//用于判断三角函数，标记三角函数的最后一个字母，使其变为符号可以入栈,或转换最后一个字符
{								//防止字符重复的情况，如sin和cos的s如果不加判断会重复入栈
	char tri;
	tri = str;
	if( ((str == 's') && (tri_flag != 5)) || (tri_flag == 1) || (tri_flag ==2) )		//sin的s会和cos的s重复判断
	{
		if(str =='s')tri_flag = 1;
		if( (str == 'i') || (tri_flag ==2) )
		{
			if(str == 'i')tri_flag = 2;
			if( str == 'n' )
				tri_flag = 3;
		}
	}

	if( (str == 'c') || (tri_flag == 4) || (tri_flag ==5) )
	{
		if(str == 'c')tri_flag = 4;
		if( (str == 'o') || (tri_flag ==5) )
		{
			if(str == 'o')tri_flag = 5;
			if( str == 's' )
				tri_flag = 6;
		}
	}

	if( (str == 't') || (tri_flag == 7) || (tri_flag == 8 ))
	{
		if( str == 't')tri_flag = 7;
		if( (str == 'a') || (tri_flag == 8) )
		{
			if( str == 'a' )tri_flag = 8;
			if( str == 'n')
			{
				tri_flag = 9;
				tri = 't';
			}
		}		
	}
	
	if( (str == 'l') || (tri_flag == 10) || (tri_flag == 11))
	{
		if( str == 'l')tri_flag = 10;
		if( (str == 'o') || (tri_flag == 11) )
		{
			if( str == 'o' )tri_flag = 11;
			if( str == 'g' )
				tri_flag = 12;
		}
	}

	if( ((str == 's') && (tri_flag != 6)) || (tri_flag == 1) || (tri_flag == 14) || (tri_flag == 15))
	{									//squrt 和 cos 的s
		if( str == 's')tri_flag = 1;
		if( (str =='q') || (tri_flag == 14) )
		{
			if( str == 'q')tri_flag =14;
			if( (str == 'r') || (tri_flag == 15))
			{
				if( str == 't')
				{
					tri_flag = 16;
					tri = 'r';
				}
			}
		}
	}

	if( (str != 's') && (str != 'i') && (str != 'n') && (str != 'c') 
		&& (str != 'o') && (str != 't') && (str != 'a') && (str != 'l')
		&& (str != 'g') && (str != 'q') && (str != 'r'))
	tri_flag = 0;

	return tri;
} 

void test()
{
	char str[] = "-7.8*sin((log(48^2)-48.7/2.56)/(4!))+tan(4.75*cos(log(74*58.2)))";//在这里编辑需要计算的算式
	int len = strlen(str);
	char str_last = 'z';//用于判断结束
 

	cout<<str<<endl;
   	for(int i = 0;i < len; i++ )
	judge(str[i]);
	judge(str_last);
	cout<<"op:"<<op.top()<<endl;
	cout<<"_nu:"<<_nu.top()<<endl;
	getchar();
}


int main()
{
	char init_op = '#';	//注意这里不能少，要在符号栈先存入一个#号，防止程序出错时，指空
	op.push(init_op);
	char init_nu = 0;
	_nu.push(init_nu); //在数字栈中输入初始值0,以便判断第一位是否为负数

	test();
	getchar();
	return 0;
}

 

国防费哥哥
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
逆波兰算法c++代码
04-20
逆波兰算法c/c++源代码，压缩包中包含头文件与源文件
逆波兰表达式实现计算器(附c++代码)
HLYHero的博客
08-17 7157
要实现一个简单的计算器,可以对+,-,*,/,(,)进行处理并返回正确的值,最先想到的就是逆波兰表达式实现之.首先,用到第一个栈把算式转化为逆波兰表达式存一个数组中,在使用另一个栈对这个数组进行,判断,出栈,运算,入栈,判断……不断处理,最后的栈顶元素就是结果,直接返回就ok.关于这一个过程这篇博客写得很清楚:http://blog.csdn.net/xiaobai1593/article/deta
C++逆波兰表达式转化实现简单计算器
hahazhangyu0310的博客
07-28 1780
使用C++模版实现一个模版栈，并将中缀字符串计算式转化为逆波兰表达式，实现一个简单计算器功能。计算器有 + - * / ，支持负号，不支持小数，数字范围为 int 类型的取值范围。 下面为代码： stack_template.h #ifndef _MY_STACK_H #define _MY_STACK_H #include template struct stackNode { T
使用C++开发的逆波兰式计算器
最新发布
qq_59332802的博客
11-24 498
本人代码小白一个，在学校期间进行课程设计，网上资源繁多，但精品甚少，本着人人为我，我为人人的想法，把我以前完成过的课程设计发出来供大家参考。一、项目背景设计一个计算器，该计算器主要是用来进行数学计算，用过输入的数据进行运算，得出我们所需要的计算结果。采用的是栈的基本操作，通过栈实现先乘除后加减，括号优先的原则，得到用户所需要的结果，满足更多人的需求，增加计算器的可实用性。
逆波兰算法 C++——String及Stack实现
爱学习的小武童鞋
01-22 556
#include "cstdio" #include "iostream" #include "stack" #include "string" #include "sstream"using namespace std; stack<float> n; stack<string> f; int main(){ string s,buf; float a,b; float t
基于vs2017开发的逆波兰算法下的计算器控制台程序，可用于数据结构学习练手
03-03
本代码基于vs2017下开发的c++代码，代码主要使用逆波兰算法构建四则运算框架，从而实现计算器程序的构建，此外代码中还加入了三角函数，反三角函数等函数的处理，并且做了表达式的正确性检验，可以作为数据结构以及...
简单的控制台版逆波兰计算器
06-12
代码看起来有点不伦不类，是因为要求用c++写，我先用c写的，然后改了下头文件和函数，但是完全可以用 当时是用的vs2010编译的，有些代码可能不通用。。 代码很简单，如果不是信息类专业的同学需要做此类课设可以直接...
C++使用逆波兰表达式实现计算器四则运算（完整代码）
04-10
使用C++模拟了计算器的四则运算，包括加减乘除以及括号优先级运算，主要解决办法是将键盘输入的四则运算表达式转为逆波兰表达式，然后再进一步计算逆波兰表达式的值，具体算法思路在主页，资源包括一个main.cpp文件...
逆波兰表达式实现的简易计算器
04-27
输入中缀表达式转换成逆波兰表达式的值显示出来，并通过转化的逆波兰表达式求出中缀表达式的值，主要利用到栈的原理。
VS2005基于MFC的C++设计计算器，功能强大
09-23
VS2005基于MFC的C++设计计算器，功能强大，可以基本按钮实现功能，也可以输入表达式实现多重括号复杂计算，采用逆波兰式，算法高效，但限于水平，难免会有不妥之处，还望大牛们批评指正。
逆波兰计算器C++源码
04-12
逆波兰计算器是一种比较好的计算器，不管不复杂的式子都可以不用括号进行表达
C++ 程序图形界面计算器（波兰表达式）
10-25
这是一个C++(windows forms)编写的表达式计算器，具有图形化界面，采用正常的波兰表达式输入
C++实现逆波兰式
12-16
(a+b)c的逆波兰式为ab+c，假设计算机把ab+c按从左到右的顺序压入栈中，并且按照遇到运算符就把栈顶两个元素出栈，执行运算，得到的结果再入栈的原则来进行处理，那么ab+c的执行结果如下： 1）a入栈（0位置） 2）b入栈（1位置） 3）遇到运算符“+”，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置） 4）c入栈（1位置） 5）遇到运算符“”，将d和c出栈，执行dc的操作，得到结果e，再将e入栈（0位置） 经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。 逆波兰式除了可以实现上述类型的运算，它还可以派生出许多新的算法，数据结构，这就需要灵活运用了。逆
逆波兰式的生成与计算
03-26
主要进行逆波兰式的 读取输入和相关计算，经反复测试后代码可用
逆波兰式的产生及计算
06-04
逆波兰式的产生及计算
C++ | 栈的应用（逆波兰算法） | 计算器
专注于C/C++/Linux领域创作
11-30 1165
#include <iostream> using std::cin; using std::cout; using std::endl; template<typename T> class Stack { public: Stack(int _size = 20) :size(_size), mtop(0) { data = new T[size](); ...
【编译原理】C++实现“逆波兰式的产生及计算“（超级详细系列、有源码+注解）
小树じ的博客
05-11 3774
目录 逆波兰式的产生及计算 1.实验目的 2.实验步骤 2.1由上图可知需要对运算符的优先级进行判断，构造一个优先级类如下： 2.2根据上图算法构造Polish类对逆波兰表达式的生成过程进行编写（我采用了两个栈来分别存储运行数和运算符，优先级的比较在运算符栈进行），然后通过一个打印类将逆波兰表达式结果显示出来： 2.3构造一个cal类用来计算逆波兰表达式的值，这里采用一个栈来进行运算： 3.实验结果 4.实验源码+注释 逆波兰式的产生及计算 1.实验目的 将用中缀式表示的算..
逆波兰计算器 - C++实现
Mzying2001的博客
04-23 386
逆波兰计算器 - C++实现 #include <iostream> #include <cctype> #include <cstdlib> #include <string> #include <vector> #include <stack> #define ADD '+' #define SUB '-' #define MUL '*' #define DIV '/' #define to_str(c) std::string
逆波兰计算器android源码简书,汪都能理解的逆波兰计算器(C++实现)
weixin_30895873的博客
05-29 146
简介 EXPLANATION逆波兰表示法(Reverse Polish notation, RPN)也称作后缀表示法，与之对应的是波兰表示法(Polish notation)，也就是前缀表示法。之所以使用“波兰”来命名，是因为发明者的名字太难发音logicianJan Łukasiewicz，只好以国籍来命名。实际意义由于逆波兰表达式在计算时不需要将表达式括起来，进行计算时输入较少。此外，用户...
基于c#的简直逆波兰式算法的计算器
06-07
你可以使用以下步骤来实现基于C#的简单逆波兰式计算器： 1. 创建一个接受用户输入表达式的文本框和一个按钮来触发计算。 2. 当用户按下按钮时，获取文本框中的表达式。 3. 将表达式转换为逆波兰式（后缀表达式）。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值