Reverse Polish Calculator （逆波兰计算器）方案的分析——如何解决问题，从需要到实现

最新推荐文章于 2020-09-22 15:29:50 发布
最新推荐文章于 2020-09-22 15:29:50 发布
阅读量2k 收藏 4
点赞数 5
分类专栏： 【这就是C】 文章标签： 逆波兰 计算器 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duanxu_yzc/article/details/11099377
版权

Reverse Polish Calculator （逆波兰计算器）方案的分析——如何解决问题，从需要到实现


注：文章素材来源于K&R第二版


需要实现的功能：

（针对用户的期望）

1、基本的四则运算

2、取模运算

*3、其它数学函数的运算。比如三角函数、幂函数、指数函数等

*4、能够调用上一步的结果（待补充）



用户可能的行为：

用户可能的输入（用□代表空格，其它不可见字符使用其转义字符表示）

正常输入：

3□2□-\n

3.5□2.1□*\n (带有小数点)

-0.5□-3□/\n (带有负数)

多余空格：□□\t3□2-□\n

小数点前不带整数：-.5□-.6□+\n


用户期待的结果：

能够进行多种数学运算，包括小数和负数的运算，三角函数等；

输入回车符后能立即得到正确答案，得到答案后程序不会退出，可以继续计算其他算术式，直到用户输入EOF，结束计算器的运行。



整体框架

while (下一个运算符或者操作数不是EOF )

          if (是数 )

                  将数压入栈中

          else if (是运算符 )

                 弹出所需数目的操作数

                  执行运算

                  将结果压入栈中

         else if (是换行符 )

                 弹出并打印栈顶值

          else

                 出错


    1/*

    2 *逆波兰计算器主函数

    3 */

    4

    5/*

    6 *算法描述：

    7 * while (下一个运算符或者操作数不是EOF )

    8 *  if (是数 )

    9 *      将数压入栈中

   10 *  else if (是运算符 )

   11 *      弹出所需数目的操作数

   12 *      执行运算

   13 *      将结果压入栈中

   14 *  else if (是换行符 )

   15 *      弹出并打印栈顶值

   16 *  else

   17 *      出错

   18 */

   19#include <stdio.h>

   20#include <stdlib.h>

   21#include <math.h>      //使用fmod()函数和其他数学函数

   22#include <string.h>    //使用strcmp()函数

   23

   24#define MAXOP 100

   25#define NUMBER'0'

   26#define NAME'f'

   27

   28intgetop(char s[] );

   29voidpush(double);

   30doublepop(void);

   31voidmathfunc(char s[] );

   32

   33intmain(void)

   34{

   35    int type;

   36    double op2;

   37    char s[MAXOP];

   38

   39    while( (type=getop(s)) != EOF )

   40    {

   41        switch( type)

   42        {

   43            case NUMBER:

   44                push(atof( s) );

   45                break;

   46            case'+':

   47                push(pop() +pop() );

   48                break;

   49            case'*':

   50                push(pop() *pop() );

   51                break;

   52            case'-':

   53                op2=pop();

   54                push(pop() - op2);

   55                break;

   56            case'/':

   57                op2=pop();

   58                if( op2!=0.0)

   59                    push(pop() / op2);

   60                else

   61                    printf("Error : zero divisor\n");

   62                break;

   63            /*

   64             *增加取模运算

   65             */

   66            case'%':

   67                op2=pop();

   68                if( op2!=0.0)

   69                    push(fmod(pop() , op2) );

   70                else

   71                    printf("Error : zero divisor\n");

   72                break;

   73            /*

   74             *增加其他数学函数

   75             */

   76            case NAME:

   77                mathfunc( s);

   78                break;

   79

   80            case'\n':

   81                printf("\t%.8g\n",pop() );

   82                break;

   83            default:

   84                printf("error: unknown command %s\n", s );

   85                break;

   86        }

   87    }

   88    return0;

   89}

   90

   91

   92voidmathfunc(char s[] )

   93{

   94    double op2;

   95

   96    if(strcmp( s,"sin") ==0)

   97        push(sin(pop() ) );

   98    else if(strcmp( s,"cos") ==0)

   99        push(cos(pop() ) );

  100    else if(strcmp( s,"exp") ==0)

  101        push(exp(pop() ) );

  102    else if(strcmp( s,"pow") ==0)

  103    {

  104        op2=pop();

  105        push(pow(pop(), op2) );

  106    }

  107    else

  108        printf("error: %s not supported\n", s );

  109}



如何获取操作数或者运算符（针对用户的行为）

1、获取操作符：基本的四则运算符是单个的字符，直接读入字符。

2、获取操作数：操作数是一系列数字值或者小数点符号或者负号。

3、获取输入结束符：根据用户需求，在读取一个换行符后结束输入，输出结果。

4、对错误输入的处理：读入数字字符和正常的运算符不会产生错误，对于非法的字符，直接读入，交由主函数处理。

具体获取方法：

1、由于针对操作数和运算符读取的方式不一样，操作数需要一个数组来存放一系列字符，而运算符只需要一个字符变量来存放即可，所以读取时需要进行两种类型变量的数据交换，字符变量使用返回值进行交换，字符串可以在函数中进行修改来实现数据交换。由此我们大致可以知道获取操作数和运算符的函数原型：

int getop ( char s[] );

函数返回int型值（实际为char，为了处理EOF所以为int），把一个字符数组作为函数的参数，存储读到的操作数；

2、以具体输入为例进行分析

□3.5□2.1□*\n

在这个输入中，我们希望得到两个操作数3.5、2.1和一个运算符*以及一个结束符\n

2.1、首先处理第一个前面的（如果有的话）和关键字符之间的空白（□或者\t）：采取的方法是跳过（连续读取，直至出现第一个不是空白的字符）空白。（空白还有一个作用就是区分负号和减号，在后面会具体谈及。）由于第一个字符可能是操作数的起始部分，而且空白的结束是以读取到下一个不是空白的字符为结束的，这个非空白的字符有可能就是操作数的一部分，所以还是应该将读取的字符存入数组。

2.2、在处理完空白之后，要及时将字符数组变为字符串，以免在其它函数使用时出错。

2.3、如果第一个非空字符不是操作数的组成部分（digit、'.'、'-'），就把这个字符返回。

2.4、如果这个字符是操作数的组成部分就“激活”字符数组，继续读取操作数的剩余部分并存入数组中，直到读到下一个不能组成操作数的字符，将字符数组转换为字符串。

2.5、处理最后读取的字符，如果它是EOF直接丢弃，否则就把它重新放入输入流，供下一次读取。

此时又引发一个问题，就是输入缓存，需要建立一个缓冲区，可以将“误读”的字符重新放到这个缓冲区内，供下一次读取。（稍后详谈）

2.6、正确读取到操作数后，函数需要一个返回值，由之前的假定，它不能是数组，只能是字符常量，但这个字符常量的值并无实际用途，所以只需要一个标签即可，我们把它设置为NUMBER '0'

3、负号和减号的区分

当读入的字符是'-'时，如果下一个字符是数字或者小数点，那么这个'-'就是负号，否则就是减号。

4、对数学函数的读取

当读入的是一个小写字母时，继续读入小写字母（如果后面有的话），并存入数组，形成字符串，将最后读入的一个不是小写字母的字符（不是EOF）放入输入中，判断字符串的长度，小于1就将读入的一个字符返回，否则就返回一个标志，表示已经读取到函数字符串，并在主程序中使用这种字符串。

 



    1/*

    2 *获取操作符或者操作数的函数

    3 */

    4#include <stdio.h>

    5#include <ctype.h>

    6#include <string.h>

    7

    8#define NUMBER'0'

    9#define NAME'f'

   10

   11intgetch(void);

   12intungetch(int c);

   13

   14intgetop(char s[] )

   15{

   16    int i, c;

   17    while( (s[0] = c =getch() ) ==' '  ||  c=='\t')

   18        ;

   19    s[1] = '\0';

   20    i=0;

   21

   22    /*

   23     *增加对其他函数字符串的读取

   24     */

   25

   26    if(islower( c) )

   27    {

   28        while(islower( s[++i] = c =getch() ) )

   29            ;

   30        s[i] = '\0';

   31        if( c!= EOF)

   32            ungetch( c);

   33        if(strlen( s) >1)

   34            return NAME;

   35        else

   36            return c;

   37    }

   38

   39    if( !isdigit( c)  &&  c!='.'  &&  c!='-')

   40        return c;

   41

   42    /*

   43     *增加对负号和减号的区分

   44     */

   45    if( c=='-')

   46        if(isdigit( c=getch() )  ||  c=='.')

   47            s[++i] = c;

   48        else

   49        {

   50            if( c!= EOF)

   51                ungetch( c);

   52            return'-';

   53        }

   54

   55    if(isdigit( c) )

   56        while(isdigit( s[++i] = c =getch() ) )

   57            ;

   58    if( c=='.')

   59        while(isdigit( s[++i] = c =getch() ) )

   60            ;

   61

   62    s[i] ='\0';

   63

   64    if( c!= EOF)

   65        ungetch( c);

   66

   67    return NUMBER;

   68}



如何实现栈（数据的组织）

我们把操作数都放到一个数组中，只要程序遇到操作符，就会将相应个数的操作数取出来，进行运算，然后将结果再次放入数组中。这种基于数组的“操作方式”（栈，实际上就是数组或者链表等，由于对其操作方式的不同，就会产生栈、列队等各种数据结构）就是栈。

它起码应该具备两个基本功能：进栈和出栈。

我们需要一个数组来存储数据，还要一个位置量来标记栈顶位置，方便进出栈。



    1/*

    2 *用于栈的操作函数

    3 */

    4#include <stdio.h>

    5#define MAXVAL 100

    6

    7int sp=0;

    8double val[MAXVAL];

    9

   10voidpush(double f)

   11{

   12    if( sp< MAXVAL)

   13        val[sp++] = f;

   14    else

   15        printf("error: stack full\n");

   16}

   17

   18doublepop(void)

   19{

   20    if( sp>0)

   21        return val[--sp];

   22    else

   23    {

   24        printf("error: empty stack\n");

   25        return0.0;

   26    }

   27}




如何实现输入缓存

我们需要一个栈（存取都发生在数组的同一端），当发生“误读”时，就将这个字符推进栈中，下一次读取时，如果栈不是空，就读取栈顶元素，否则就从标准输入读取。




    1/*

    2 *读取字符和放入被读取字符的函数

    3 */

    4#include <stdio.h>

    5#define BUFSIZE 100

    6

    7char buf[BUFSIZE];

    8int bufp=0;

    9

   10intgetch(void)

   11{

   12    return( bufp>0) ? buf[--bufp] :getchar();

   13}

   14

   15voidungetch(int c)

   16{

   17    if( bufp>= BUFSIZE)

   18        printf("ungetch: too many characters\n");

   19    else

   20        buf[ bufp++ ] = c;

   21}




最后提供源代码供大家编译运行


/*
 * 逆波兰计算器主函数
 */

/*
 * 算法描述：
 * while ( 下一个运算符或者操作数不是EOF )
 * 	if ( 是数 )
 * 		将数压入栈中
 * 	else if ( 是运算符 )
 * 		弹出所需数目的操作数
 * 		执行运算
 * 		将结果压入栈中
 * 	else if ( 是换行符 )
 * 		弹出并打印栈顶值
 * 	else
 * 		出错
 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>		//使用fmod()函数和其他数学函数
#include <string.h>		//使用strcmp()函数

#define MAXOP 100
#define NUMBER '0'
#define NAME 'f'

int getop ( char s[] );
void push ( double );
double pop ( void );
void mathfunc ( char s[] );

int main ( void )
{
	int type;
	double op2;
	char s[MAXOP];

	while ( (type=getop(s)) != EOF )
	{
		switch ( type )
		{
			case NUMBER:
				push ( atof ( s ) );
				break;
			case '+':
				push ( pop () + pop () );
				break;
			case '*':
				push ( pop () * pop () );
				break;
			case '-':
				op2 = pop ();
				push ( pop () - op2 );
				break;
			case '/':
				op2 = pop ();
				if ( op2 != 0.0 )
					push ( pop () / op2 );
				else
					printf ( "Error : zero divisor\n" );
				break;
			/*
			 * 增加取模运算
			 */
			case '%':
				op2 = pop ();
				if ( op2 != 0.0 )
					push ( fmod ( pop () , op2 ) );
				else
					printf ( "Error : zero divisor\n" );
				break;
			/*
			 * 增加其他数学函数
			 */
			case NAME:
				mathfunc ( s );
				break;

			case '\n':
				printf ( "\t%.8g\n", pop () );
				break;
			default:
				printf ( "error: unknown command %s\n", s );
				break;
		}
	}
	return 0;
}


void mathfunc ( char s[] )
{
	double op2;

	if ( strcmp ( s, "sin" ) == 0 )
		push ( sin ( pop () ) );
	else if ( strcmp ( s, "cos" ) == 0 )
		push ( cos ( pop () ) );
	else if ( strcmp ( s, "exp" ) == 0 )
		push ( exp ( pop () ) );
	else if ( strcmp ( s, "pow" ) == 0 )
	{
		op2 = pop ();
		push ( pow ( pop (), op2 ) );
	}
	else
		printf ( "error: %s not supported\n", s );
}



/*
 * 获取操作符或者操作数的函数
 */
#include <stdio.h>
#include <ctype.h>
#include <string.h>

#define NUMBER '0'
#define NAME 'f'

int getch ( void );
int ungetch ( int c );

int getop ( char s[] )
{
	int i, c;
	while ( (s[0] = c = getch() ) == ' '  ||  c == '\t' )
		;
	s[1] = '\0';
	i = 0;

	/*
	 * 增加对其他函数字符串的读取
	 */

	if ( islower ( c ) )
	{
		while ( islower ( s[++i] = c = getch () ) )
			;
		s[i] = '\0';
		if ( c != EOF )
			ungetch ( c );
		if ( strlen ( s ) > 1 )
			return NAME;
		else
			return c;
	}

	if ( !isdigit ( c )  &&  c != '.'  &&  c != '-' )
		return c;

	/*
	 * 增加对负号和减号的区分
	 */
	if ( c == '-' )
		if ( isdigit ( c = getch () )  ||  c == '.' )
			s[++i] = c;
		else
		{
			if ( c != EOF )
				ungetch ( c );
			return '-';
		}

	if ( isdigit ( c ) )
		while ( isdigit ( s[++i] = c = getch () ) )
			;
	if ( c == '.' )
		while ( isdigit ( s[++i] = c = getch () ) )
			;

	s[i] = '\0';

	if ( c != EOF )
		ungetch ( c );

	return NUMBER;
}


/*
 * 用于栈的操作函数
 */
#include <stdio.h>
#define MAXVAL 100

int sp = 0;
double val[MAXVAL];

void push ( double f )
{
	if ( sp < MAXVAL )
		val[sp++] = f;
	else
		printf ( "error: stack full\n" );
}

double pop ( void )
{
	if ( sp > 0 )
		return val[--sp];
	else
	{
		printf ( "error: empty stack\n" );
		return 0.0;
	}
}



/*
 * 读取字符和放入被读取字符的函数
 */
#include <stdio.h>
#define BUFSIZE 100

char buf[BUFSIZE];
int bufp = 0;

int getch ( void )
{
	return ( bufp > 0 ) ? buf[--bufp] : getchar();
}

void ungetch ( int c )
{
	if ( bufp >= BUFSIZE )
		printf ( "ungetch: too many characters\n" );
	else
		buf [ bufp++ ] = c;
}


yzc_1991
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Reverse-Polish-Calculator
03-18
反波兰计算器 安装说明：（适用于Windows） 从bin文件夹下载main.exe文件。 打开命令提示符，然后将您的工作目录定位到main.exe的保存目录。 使用命令main并使用该应用程序。 在计算机上创建可执行文件的说明：（Windows） I.使用目标代码（要求：已安装gnu编译器） 从bin文件夹下载main.o ， stack.o ， getch.o和getop.o文件。 打开命令提示符，并将您的工作目录移至保存这些文件的目录。 使用命令g++ -o main stack.o getch.o getop.o main.o获取main.exe文件 二。使用源代码（要求：gnu编译器和make实用程序已安装） 从根文件夹下载main.cpp ， stack.cpp ， getch.cpp ， getop.cpp ， calc.h和makeFile文件。 打开命令提示符，并将您的
reverse-polish-calculator
03-18
反向波兰计算器 安装说明：（适用于Windows） 从bin文件夹下载main.exe文件。 打开命令提示符，然后将您的工作目录定位到main.exe的保存目录。 使用命令main并使用该应用程序。 在您的计算机中创建可执行文件的说明：（Windows） 1.使用目标代码（要求：已安装gnu编译器） i. Download main.o, stack.o, getch.o and getop.o files from bin folder. ii. Open command prompt and loacte your working directory to the directory where these are saved. iii. Use command ```g++ -o main stack.o getch.o getop.o main.o``` to get
Exercises 4-3
www.jiav.net技术网站的加盟博客
04-21 382
Tips:此为逆波兰计算器实现 如： (1 – 2) * (4 + 5) 用逆波兰表示法为： 1 2 - 4 5 + * #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /* for atof() */ #include &lt;math.h&gt; #define MAXOP 100 /* max size of ope...
Reverse Polish notation calculator
brinews的博客
07-09 402
Functionally Solving Problems In this chapter, we’ll take a look at a few interesting problems and how to think functionally to solve them as elegantly as possible. We probably won’t be introducing an...
逆波兰计算器 c#
qq_26661927的专栏
09-22 385
using System; using System.Collections.Generic; namespace ANL { /// <summary> 逆波兰计算器 </summary> class ReversePolishCalculator { public void Test() { Console.WriteLine("输入公式"); string input =
RPN-calculator.rar_polish calculator_reverse polish_rpn java
09-23
逆波兰计算器，也被称为RPN计算器，是一种基于后缀表达式的计算工具，它在计算机科学和编程领域中具有特殊的应用价值。本项目是用Java语言实现的RPN计算器，能够帮助用户进行高效的数学运算，无需使用传统的括号或...
RPNCalculator:逆波兰符号计算器
07-11
逆波兰符号计算器（RPNCalculator）是一种基于逆波兰表示法（Reverse Polish Notation，简称RPN）的计算工具。在逆波兰表示法中，运算符位于其操作数之后，这与我们通常使用的中缀表达式（如2 + 3）不同。这种表示法...
bison分析计算器
12-28
3. `rpcalc.y` - "rpcalc"可能是"Reverse Polish Calculator"的缩写，这个文件可能包含了逆波兰表达式的语法规则。 4. `a.y` - 这个文件的含义不明确，但可能包含了一个额外的或通用的语法定义，例如一个基础的算术...
REPCAL (REverse Polish CALculator)-开源
04-28
REPCAL是一款基于Python开发的开源计算器，设计用于在RPN（反向波兰表示法）环境中执行计算。这种表示法是一种数学表达式处理方式，它将运算符置于操作数之后，提高了计算效率，尤其适用于计算器和某些编程语言。在...
逆波兰_逆波兰_DEMO_
09-30
通过这个 DEMO，你可以了解到逆波兰表示法在实际编程中的应用，以及如何利用 Python 的数据结构和控制流来实现一个简单的逆波兰计算器。在实际开发中，这样的程序可以作为更复杂计算模块的基础，比如在财务、工程或...
calculatorPolish
03-10
calculatorPolish
Polish-Calculator-1705028
03-19
Polish-Calculator-1705028
表达式计算 逆波兰式 栈 可括号小数负数
12-25
栈作中介，将表达式转化成逆波兰式，然后计算表达式的值。支持括号。允许负数和小数。
编写BISON程序，分析和计算逆波兰表达式
06-02
学习YACC(BISON)的语法结构，编写YACC(BISON)程序，生成能够分析和计算逆波兰表达式，构建逆波兰计算器。根据提示，在右侧编辑器补充代码，实现加法(+)、减法(-)、乘法(*)、除法(/)、乘方(^)以及取负运算(n)。
C语言实现的逆波兰式计算器
04-26
该工程是使用C语言在devc++平台上实现的逆波兰式计算器，需要用到dev打开，如果用vs需要自己设置头文件
用逆波兰表达式解决混合运算问题
LLL_justdoit的博客
05-20 668
    最近，做了一个java小型计算器，发现其中的一个比较核心的难题，即怎么解决混合运算问题。一开始百度之后，还有参考了别人的代码之后，自己也运用逆波兰表达式敲了比较完善的解决混合运算代码。    解释一下逆波兰表达式：逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，这种表示法也称为中缀表示。而按照逆波兰表达式，每一运算符都置于其运算对象之后，故称为...
基于逆波兰算法的计算方法C++程序(计算器算法)
qq_37358422的博客
07-19 1540
主要有以下功能：可以连续计算四则运算，可以自己分辨多位数，小数，负数。 后续会加入sin(),cos()等。(已经加入sin,cos,tan,次方pow,阶乘！ ，开平方sqrt，取对数log） 主要原理： 建立两个栈，一个用于存放数字，一个用于存放符号。 判断符号优先级，当符号优先级低于符号栈的栈头时，栈头出栈。（括号另算）否则则入栈。 出栈的符号进行运算，读取数字栈的两个数字并进行...
STL——stack栈（解决逆波兰算法）
沉迷单车的追风少年
07-10 392
逆波兰算法： 假定给定一个只 包含 加、减、乘、除，和括号的算术表达式，你怎么编写程序计算出其结果？ 问题是：在表达式中，括号，以及括号的多层嵌套 的使用，运算符的优先级不同等因素，使得一个算术表达式在计算时，运算顺序往往因表达式的内容而定，不具规律性。 这样很难编写出统一的计算指令。 使用逆波兰算法可以轻松解决这个问题。他的核心思想是将普通的中缀表达式转换为后缀表达式。 什么是中缀表达式？...
C语言利用栈实现Polish计算器
Pure Pleasure
09-28 2670
/************************************************************************/ /* 利用栈实现反向Polish计算器：比如，输入1 2 +，其实是要计算1 + 2； /* 比如输入1 2 + 4 5 -
The value of reverse Polish notation(逆波兰式) (also known as postfix expression) 1 23 4- /*5 + is
最新发布
06-08
首先，将逆波兰式从左到右依次读取，遇到数字就将其入栈，遇到运算符就将栈顶的两个数字弹出，进行相应的运算，然后将结果入栈，最终栈中只剩下一个数字，即为表达式的结果。 按照上述方法，对逆波兰式 1 23 4-/*5+...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值