NYOJ 35 表达式求值（栈）

最新推荐文章于 2025-12-02 16:00:32 发布
最新推荐文章于 2025-12-02 16:00:32 发布 · 100 阅读 · 0
文章标签：

#c/c++

本文通过使用C++模板改进了一个表达式求值程序，解决了原始版本中操作数和操作符栈类型不统一的问题，并增强了程序的功能，使其能够处理包含小数的表达式。

这些函数中都有“重复”的，因为操作数(OPND)栈用double，操作符(OPTR)栈用char。C++中的模板可以解决这个问题吗？

这是对着书写的：

#include <iostream>
using namespace std;

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 100

char Precede_Matrix[7][7] = 
{
	{'>', '>', '<', '<', '<', '>', '>',},
	{'>', '>', '<', '<', '<', '>', '>',},
	{'>', '>', '>', '>', '<', '>', '>',},
	{'>', '>', '>', '>', '<', '>', '>',},
	{'<', '<', '<', '<', '<', '=', '0',},
	{'>', '>', '>', '>', '0', '>', '>',},
	{'<', '<', '<', '<', '<', '0', '=',}
};

char Precede ( char a, char b )
{
	int i = 0;
	int j = 0;
	switch (a)
	{
	case '+' : i = a - '+'; break;
	case '-' : i = a - '-' + 1; break;
	case '*' : i = a - '*' + 2; break;
	case '/' : i = a - '/' + 3; break;
	case '(' : i = a - '(' + 4; break;
	case ')' : i = a - ')' + 5; break;
	case '#' : i = a - '#' + 6; break;
	default : cout << "Error1!" << endl;
	}
	switch (b)
	{
	case '+' : j = b - '+'; break;
	case '-' : j = b - '-' + 1; break;
	case '*' : j = b - '*' + 2; break;
	case '/' : j = b - '/' + 3; break;
	case '(' : j = b - '(' + 4; break;
	case ')' : j = b - ')' + 5; break;
	case '#' : j = b - '#' + 6; break;
	default : cout << "Error2!" << endl;
	}
	char c = Precede_Matrix[i][j];
	return c;
}

int Operate(int a, char oper, int b)
{
	switch (oper)
	{
	case '+': return a + b;
	case '-': return a - b;
	case '*': return a * b;
	case '/': return a / b;
	default: cout << "Error3!" << endl; return 0;
	}
}

struct stack_char
{
	char *base;
	char *top;
	int stacksize;
}OPTR;

struct stack_int
{
	int *base;
	int *top;
	int stacksize;
}OPND;	// 两位数的只能用int来存？

void InitStack(struct stack_char &S)
{
	S.base = (char *)malloc( STACK_INIT_SIZE * sizeof(char) );
	if(!S.base)
		cout << "Overflow1!" << endl;
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;	
}

void InitStack(stack_int &S)
{
	S.base = (int *)malloc( STACK_INIT_SIZE * sizeof(int) );
	if(!S.base)
		cout << "Overflow2!" << endl;
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;	
}

void Push(stack_char &S, char e)
{
	if(S.top - S.base >= S.stacksize)	// 判满
	{
		S.base = (char *)realloc( S.base,
			(S.stacksize + STACKINCREMENT) * sizeof(char) );
		if(!S.base)
			cout << "Overflow3!" << endl;
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	* S.top++ = e;
}

void Push(stack_int &S, int e)
{
	if(S.top - S.base >= S.stacksize)	// 判满
	{
		S.base = (int *)realloc( S.base, 
			(S.stacksize + STACKINCREMENT) * sizeof(int) );
		if(!S.base)
			cout << "Overflow4!" << endl;
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	* S.top++ = e;
}

void Pop (stack_char &S, char &e)
{
	if(S.top == S.base)					// 判空
		cout << "Error4!" << endl;
	e = * --S.top;
}

void Pop (stack_int &S, int &e)
{
	if(S.top == S.base)					// 判空
		cout << "Error5!" << endl;
	e = * --S.top;
}

char GetTop(stack_char S)
{
	if (S.top == S.base)				// 判空
		cout << "Error6!" << endl;
	return *(S.top - 1);
}

int GetTop(stack_int S)
{
	if (S.top == S.base)				// 判空
		cout << "Error7!" << endl;
	return *(S.top - 1);
}

int EvaluateExpression()
{
	int a;
	int b;
	char x;
	char theta;
	InitStack(OPTR);
	Push(OPTR, '#');
	InitStack(OPND);
	char c = getchar();					// 输入若是数字，只能是个位数
	while ( !(c == '#' && GetTop(OPTR) == '#') )
	{
		if ( '0' <= c && c <= '9' )		// c is operand
		{
			c -= '0';
			Push(OPND, c);
			c = getchar();
		}
		else							// c is operator or delimiter
		{
			switch (Precede (GetTop(OPTR), c))
			{
			case '<':
				Push(OPTR, c);
				c = getchar();
				break;
			case '=':
				Pop(OPTR, x);
				c = getchar();
				break;
			case '>':
				Pop(OPTR, theta);
				Pop(OPND, b);
				Pop(OPND, a);
				Push(OPND, Operate(a, theta, b));
				break;
			default: cout << "Error8!" << endl;
			}
		}
	}
	//  OPTR栈的栈顶元素和当前读入的字符均为“#”
	//  即“#”=“#”时整个表达式求值完毕
	int result = GetTop(OPND);	
	free(OPTR.base);
	free(OPND.base);
	return result;	//	要在释放前保留下结果
}							

int main()
{	
	cout << EvaluateExpression() << endl;
	
	return 0;
}


NYOJ上该题的标程：

 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char str[1005];
int start;
char s[50],ss[50];int i,j;
double Term();double Expression();double Factor();
double Term()
{
    double f=Factor(),t;
    --start;
    if(str[start]=='*')
    {
        t=Term();
        return t*f;
    }
    else if(str[start]=='/')
    {
        t=Term();
        return t/f;
    }
    else {++start;return f;}
}
double Expression()
{
    double t=Term(),e;
    --start;
    if(str[start]=='+')
    {
        e=Expression();
        return e+t;
    }
    else if(str[start]=='-')
    {
        e=Expression();
        return e-t;
    }
    else {++start;return t;}
}
double Factor()
{
    --start;
    double ret;
    if(str[start]==')')
    {
        ret=Expression();
        --start;
        return ret;
    }
    else
	{
		i=0;
		memset(ss,0,sizeof(ss));
		while((str[start]>='0'&&str[start]<='9')||str[start]=='.')
			s[i++]=str[start--];
		++start;
		for(j=0;j<i;j++)
		{
			ss[j]=s[i-1-j];
		}
		return atof(ss);
	}
}
int main()
{
	//freopen("1.txt","r",stdin);
	int n;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%s",str);
		start=strlen(str)-1;
		printf("%.2lf\n",Expression());
	}
}


2012/5/17 更新：

终于用模板解决了那个问题

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;

#define STACK_INIT_SIZE 1024
#define STACKINCREMENT 30

char Precede_Matrix[7][7] = 
{
	{'>', '>', '<', '<', '<', '>', '>',},
	{'>', '>', '<', '<', '<', '>', '>',},
	{'>', '>', '>', '>', '<', '>', '>',},
	{'>', '>', '>', '>', '<', '>', '>',},
	{'<', '<', '<', '<', '<', '=', '0',},
	{'>', '>', '>', '>', '0', '>', '>',},
	{'<', '<', '<', '<', '<', '0', '=',}
};

char Precede ( char a, char b )
{
	int i = 0;
	int j = 0;
	switch (a)
	{
	case '+' : i = 0; break;
	case '-' : i = 1; break;
	case '*' : i = 2; break;
	case '/' : i = 3; break;
	case '(' : i = 4; break;
	case ')' : i = 5; break;
	case '#' : i = 6; break;
	default : cout << "Error1!" << endl;
	}
	switch (b)
	{
	case '+' : j = 0; break;
	case '-' : j = 1; break;
	case '*' : j = 2; break;
	case '/' : j = 3; break;
	case '(' : j = 4; break;
	case ')' : j = 5; break;
	case '#' : j = 6; break;
	default : cout << "Error2!" << endl;
	}

	return ( Precede_Matrix[i][j] );
}

double Operate(double a, char oper, double b)
{
	switch (oper)
	{
	case '+': return a + b;
	case '-': return a - b;
	case '*': return a * b;
	case '/': return a / b;
	default: cout << "Error3!" << endl; return -1;
	}
}

struct stack_char
{
	char *base;
	char *top;
	int stacksize;
};

struct stack_double
{
	double *base;
	double *top;
	int stacksize;
};  // 计算结果可能是两位数，只能用double，不能用char来存？

template <class T2, class T1>
void InitStack(T1 &S)
{
	S.base = (T2 *)malloc( STACK_INIT_SIZE * sizeof(T2) );
	if(!S.base)
		cout << "Overflow2!" << endl;
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;  
}

template <class T1, class T2>
void Push(T1 &S, T2 e)
{
	if(S.top - S.base >= S.stacksize)    // 判满
	{
		S.base = (T2 *)realloc( S.base,
			(S.stacksize + STACKINCREMENT) * sizeof(T2) );
		if(!S.base)
			cout << "Overflow3!" << endl;
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	*S.top++ = e;
}

template <class T1, class T2>
void Pop (T1 &S, T2 &e)
{
	if(S.top == S.base)                 // 判空
		cout << "Error5!" << endl;
	e = *--S.top;
}

template <class T2, class T1>
T2 GetTop(T1 S)
{
	if (S.top == S.base)                // 判空
		cout << "Error6!" << endl;
	return *(S.top - 1);
}

bool IsOperand(char c)
{
	if( ('0' <= c && c <= '9') || c == '.' )	//	c是数字或小数点
		return true;
	else
		return false;
}

int main(void)
{
	string str;
	while (cin >> str) {
		str.push_back('#');						//  最后是#（结束标志）
		double a;
		double b;
		char x;
		char theta;
		stack_char OPTR;
		InitStack<char> (OPTR);
		Push(OPTR, '#');
		stack_double OPND;
		InitStack<double> (OPND);
		int i = 0;
		char c = str[i++];
		double operand = 0;
		while ( !(c == '#' && GetTop<char> (OPTR) == '#') )
		{
			if ( IsOperand(c) )					// c is operand
			{
				operand = atof( &str[i - 1] );	//	把从c开头的数转化成double
				Push(OPND, operand);
				while( IsOperand(str[i]) )
					i++;
				c = str[i++];
			}			
			else                            // c is operator or delimiter
			{
				switch (Precede (GetTop<char> (OPTR), c))
				{

				case '<':
					Push(OPTR, c);
					c = str[i++];
					break;

				case '=':
					Pop(OPTR, x);
					c = str[i++];
					break;

				case '>':
					Pop(OPTR, theta);
					Pop(OPND, b);
					Pop(OPND, a);
					Push(OPND, Operate(a, theta, b));
					break;

				default:
					cout << "Error8!" << endl;
					break;
				}
			}       
		}
		//  OPTR栈的栈顶元素和当前读入的字符均为“#”
		//  即“#”=“#”时整个表达式求值完毕
		cout << GetTop<double> (OPND) << endl;

		free(OPTR.base);
		free(OPND.base);
	}

	return 0;
}

同时功能上改进了，欢迎体验！

iteye_18800
关注
05-D. DS堆栈--表达式计算
bianchengfive的博客
10-20 1290
05-栈与队列- 题目描述 计算一个表达式的运算结果 使用C++自带stack堆栈对象来实现 参考课本的算法伪代码P53-54 例如 1 . Push (OPTR, ‘#’);表示把字符#压入堆栈OPTR中，转换成c++代码就是OPTR.push(’#’); 2 .Pop(OPND, a); 表示弹出栈OPND的栈顶元素，并把栈顶元素放入变量a中。因此改成c++代码是两个操作： a = OPND.top(); OPND.pop(); 3 .a = GetTop(OPND)表示获取栈OPN
《数据结构》— NYOJ 35 表达式求值
69小石头的博客
04-04 589
题目35 题目信息 运行结果 本题排行 讨论区 表达式求值 时间限制：3000ms | 内存限制：65535KB 难度：4 描述 ACM队的mdd想做一个计算器，但是，他要做的不仅仅是一计算一个A+B的计算器，他想实现随便输入一个表达式都能求出它的值的计算器，现在请你帮助他来实现这个计算器吧。 比如输入：“1+2/4=”，程序就输出1.50（结果保留两位小数） 输入 第...
数据结构学习（栈与队列：四（栈的典型应用（延迟缓冲）））
weixin_43723259的博客
07-29 341
栈的典型应用 延迟缓冲 在一些应用问题中，输入可分解为多个单元并通过迭代依次扫描处理，但过程中各步计算往往滞后于扫描的进度，需要等到必要的信息已经完整到一定程度之后，才能做出判断并实施计算的这类场合，而栈则可以扮演数据缓冲区的角色。 表达式求值 中缀表达式的求取便是一个延迟缓冲的问题。当程序扫描一个表达式并对其进行求取，无法在刚扫描之后就对表达式的部分进行求取，而是要判断一下某个运算符是否在此时可以进行运算，而这个判断完成时往往是滞后于扫描速度的。这时候就可以运用栈工具，比如，现在要求取下面这个表达式：
利用栈求表达式的值（数据结构课程设计）
持之以恒
06-27 1万+
课程设计的内容和要求（包括原始数据、技术要求、工作要求等） 编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。 主要功能描述如下： 1、从键盘上输入表达式。 2、分析该表达式是否合法： （1）是数字，则判断该数字的合法性。若合法，则压入数据到堆栈中。 （2）是规定的运算符，则根据规则进行处理。在处理过程中，将计算该表达式的值。 （3）若是其它字符
c++表达式求值（利用数据结构栈）
cristina_song的博客
10-23 2975
主要是用到栈**先进后出**的数据结构。在该程序中建有两个栈：一个用于存储运算符OPTR(+-*/#)，另一个OPND用于存储操作数或运算结果(5 2 2.5)。基本过程是： （1）首先设置操作数栈为空栈，设置运算符栈以‘#’为栈底元素（其优先级最低）。 （2）通过为栈内栈外运算符设置值而比较其优先级 （3）依次找到表达式中的所有运算符和操作数，对于操作数直接入栈，运算符则和**运算符栈的栈顶运算符**进行比较优先级
栈应用--表达式求值--nyoj
lele_pipi
11-30 548
表达式求值 描述ACM队的mdd想做一个计算器，但是，他要做的不仅仅是一计算一个A+B的计算器，他想实现随便输入一个表达式都能求出它的值的计算器，现在请你帮助他来实现这个计算器吧。 比如输入：“1+2/4=”，程序就输出1.50（结果保留两位小数） 输入第一行输入一个整数n，共有n组测试数据（n 每组测试数据只有一行，是一个长度不超过10
ACM在线评测系统 NYOJ 题库 离线看题网页版 nyoj
10-04
NYOJ，全称为南阳理工学院在线评测系统（Nanyang Institute of Technology Online Judge），是为ACM（国际大学生程序设计竞赛）以及其他编程爱好者提供的一种在线编程练习平台。该系统支持用户提交代码并进行实时...
NYOJ 301 递推求值【矩阵快速幂取模】
AC_Dreameng
10-28 1521
析：由于n的值比较大，所以常规方法肯定会超时。根据递推式求第n个表达式的值时，通常用矩阵乘法来做。 本题要构造两个矩阵，其中一个为矩阵A，作为初始矩阵 f2 0 0 f1 0 0 1 0 0 另一个为矩阵B b a c 1 0 0 0 0 1 因为F(2)和F(1)是已知的，当n>=3时，每次都乘以矩阵B，就能推出下一个矩阵。而矩阵的第一行第一列的元素就是所求的结果。 所以利用矩阵快速幂能够快速准确地求出结果。
nyoj部分ACM答案
11-17
### nyoj部分ACM答案解析 #### 背景与目的 本篇文章旨在解析一个针对NYOJ（网络在线裁判系统）中ACM题目解答的示例代码。该代码使用了C++语言，并且主要涉及到了回溯算法的实现。对于初学者来说，通过深入理解这段...
nyoj-517 求1-n的最小公倍数
Usopp
04-06 1776
清明节放假去玩了，回来后做的第一个题。表示很没有手感。明天上午蓝桥杯比赛、、、、怎么办呢 、、、 题意： 求1-n所有数的最小公倍数。n的范围是【1-100】 分析： 仔细观察会发现，【1-n】的最小公倍数，是【1-n-1】的最小公倍数乘以n的所有素因子中没有被【1-n-1】包含的素因子。 例如：【1-7】的最小公倍数是2*3*2*5*7，8=2*2*2,(8中2出现3次，【1-7】的素
DS堆栈--表达式计算
半濠春水的博客
09-23 658
/* 计算一个表达式的运算结果 使用C++自带stack堆栈对象来实现 参考课本的伪代码，把伪代码改造成可运行的代码 例如: Push (OPTR, ‘#’);表示把字符#压入堆栈OPTR中，转换成c++代码就是OPTR.push(’#’); Pop(OPND, a);表示弹出栈OPND的栈顶元素，并把栈顶元素放入变量a中。 因此改成c++代码是两个操作：a=OPND.top();OPND.pop(); a=GetTop(OPND);表示获取栈OPND的栈顶元素，转成c++代码就是：a=OPND.top()
数据结构中用栈实现表达式求值（c语言实现）
qq_42167528的博客
05-08 6706
/*该程序完成了个位数的各类表达式求值运用了数据结构中的栈及对栈操作的各类函数，操作全用指针完成如输入 2+3*（3+3*1）#  输出结果为 20经测试个位数的表达式运算结果均正确*/#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#include&lt;string.h&gt;#define STACK_INIT_SIZE 1000typedef ...
四则运算【加减乘除，使用双栈】——括号，加减乘除
二十四桥明月夜的博客
10-28 1266
#include<iostream> #include<string> #include<stack> #include<sstream> using namespace std; int getP(char ch) { //获取优先级 if (ch == '(') return 1; ...
HDU1237,简单计算器,Stack<Double>
ieayoio
06-03 2099
简单计算器 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 11983    Accepted Submission(s): 3901 Problem Description 读入一个只包含 +, -, *, / 的非负整
栈 表达式求值算法c/c++
万人迷_的博客
03-22 1万+
表达式求值，一般采用栈和队列的方式来求值，下面介绍表达式求值的两种算法。方法一、使用两个栈，一个为操作符栈OPTR(operator)，一个是操作数栈OPND(operand) 算法过程： 当输入 3 * ( 4 - 1 * 2 ) + 6 / ( 1 + 1 )时，先将输入的数据存储在一个字符数组中，按照字符的顺序一个一个的处理，比如ch = getchar() 12然后根据ch 的值判断。若 ...
overflow溢出处理
热门推荐
路漫漫~
05-03 5万+
overflow 属性规定当内容溢出元素框时发生的事情 overflow: hidden:隐藏 visible:出现，默认 scroll:滚动条 auto:自动隐藏出现滚动条 IE存在一个bug，当宽高特别小的时候显示效果不一致，可以使用overfollow:hidden来处理。 为了 保证不出问题，在reset.css的.cls 下添加 overfollow:hid
C++表达式求值（利用数据结构栈）
YYC的专栏
05-04 1万+
唉，刚刚用C++又重新写了一个较完善的表达式求值程序，最后精简后程序还不到100行，这不经让我 想到了大一上学期刚学c语言时自己费了好大的劲，写了几百行而且功能还不是很齐全(当时还不能计算有括号的表 达式)的简单计算器程序。刚把两个程序对比了一下，感触还是挺深的，同时也再一次体现了数据结构在程序设计 中的重要性。 以前的那个程序有漏洞而且逻辑复杂，所以就不提了，只说说现在改进后的程序，其思
探索三相交错并联 Boost 变换器
最新发布
2508_94198873的博客
12-02 310
三相交错并联boost变换器1、电压外环，电流内环。外环生成给定Iref/3分配给三个电流内环单独做控制2、三相交错并联结构三路开关管采取移相120°的交错调制方式最近一直在研究三相交错并联 Boost 变换器，感觉它真的很有意思，今天就来和大家分享一下。
NYOJ题目集 离线浏览解决方案
优快云（China Software Developer Network）是一个覆盖专业领域的中文IT社区，而nyoj题目所在的“ojrobot”目录，可能指的是一个专门的子项目或仓库，用于存放NYOJ相关的爬虫代码和题库文件。在这样的社区平台上，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值