用栈实现表达式求值

于 2022-10-24 20:49:11 发布
阅读量191 收藏
点赞数
文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65516813/article/details/127501026
版权

支持四则运算、小括号、中括号、乘方运算、小数运算 

//EvaluateExpression
//表达式求值

/*
	昔	我	往	矣，	杨	柳	依	依
	今	我	来	思，	雨	雪	霏	霏
*/

#include <iostream>
#include<stdlib.h>
#include<math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define ARGC_CNT 2		//参数个数
using namespace std;
typedef int Status;
//-----栈的顺序存储表示-----
#define STACK_INIT_SIZE 5			//栈的初始大小
#define STACKINCREMENT 2			//栈的扩展大小

typedef double OperandType;
typedef struct {
	OperandType* base;
	OperandType* top;
	int stacksize;
}SqStack_OPND;						//操作数栈

typedef char OperatorType;
typedef struct {
	OperatorType* base;
	OperatorType* top;
	int stacksize;
}SqStack_OPTR;						//操作符栈

//-----栈操作之函数原型----- 
Status InitStack_OPND(SqStack_OPND& S);
Status DestroyStack_OPND(SqStack_OPND& S);
Status ClearStack_OPND(SqStack_OPND& S);
Status StackEmpty_OPND(SqStack_OPND S);
int StackLength_OPND(SqStack_OPND S);
OperandType GetTop_OPND(SqStack_OPND S);
Status Push_OPND(SqStack_OPND& S, OperandType e);
Status Pop_OPND(SqStack_OPND& S, OperandType& e);
Status visit_OPND(OperandType x);
Status StackTraverse_OPND(SqStack_OPND S, Status(*visit)(OperandType));
Status InitStack_OPTR(SqStack_OPTR& S);
Status DestroyStack_OPTR(SqStack_OPTR& S);
Status ClearStack_OPTR(SqStack_OPTR& S);
Status StackEmpty_OPTR(SqStack_OPTR S);
int StackLength_OPTR(SqStack_OPTR S);
OperatorType GetTop_OPTR(SqStack_OPTR S);
Status Push_OPTR(SqStack_OPTR& S, OperatorType e);
Status Pop_OPTR(SqStack_OPTR& S, OperatorType& e);
Status visit_OPTR(OperatorType x);
Status StackTraverse_OPTR(SqStack_OPTR S, Status(*visit)(OperatorType));

//------表达式求值操作之函数原型-----
int Precede(OperatorType optr1, OperatorType optr2);
Status InOP(OperatorType e);
OperandType Operate(OperandType a, OperatorType theta, OperandType b);
OperandType Pow(OperandType a, OperandType b);
OperandType EvaluateExpression(char* expression);
Status InNum(OperatorType e);
Status InOP2(OperatorType e);

int main(int argc, char* argv[])
{
	//根据程序需要判断参数数量是否正确
	if (argc != ARGC_CNT)
	{
		printf("parameter input error.\n");
		printf("ERROR_01");
		getchar();				 //等待用户输入
		return -1;
	}
	char* p = argv[1];
	while (*p) p++;
	*p = '#';					//将表达式末尾改成终止符
	cout << EvaluateExpression(argv[1]);
	return 0;
}

//-----表达式求值之算法描述-----
int Precede(OperatorType theta1, OperatorType theta2) {
	//判断算符theta1和theta2的优先级
	//若theta1>theta2返回1，若小于返回-1，若等于返回0，若出错返回-2
	int i, j;
	//优先级矩阵
	int Relationship[10][10] = { {1,1,-1,-1,-1,1,1,-1,-1,1},
		{1,1,-1,-1,-1,1,1,-1,-1,1},
		{1,1,1,1,-1,1,1,-1,-1,1},
		{1,1,1,1,-1,1,1,-1,-1,1},
		{-1,-1,-1,-1,-1,0,-2,-1,-1,-2},
		{1,1,1,1,-2,1,1,1,-2,1},
		{-1,-1,-1,-1,-1,-2,0,-1,-1,-2},
		{1,1,1,1,-1,1,1,1, -1,1},
		{-1,-1,-1,-1,-1,-2,-2,-1,-1,0},
		{1,1,1,1,-2,1,1,1,-2,1} };
	enum { plus, subtraction, multiply, divide, leftbracket, rightbracket, pound, involution, leftBracket, rightBracket };
	switch (theta1)
	{
	case'+': i = plus; break;
	case'-': i = subtraction; break;
	case'*': i = multiply; break;
	case'/': i = divide; break;
	case'(': i = leftbracket; break;
	case')': i = rightbracket; break;
	case'#': i = pound; break;
	case'^': i = involution; break;
	case'[': i = leftBracket; break;
	case']': i = rightBracket; break;
	default:
		cout << "ERROR_02";
		return -2;
	}
	switch (theta2)
	{
	case '+': j = plus; break;
	case '-': j = subtraction; break;
	case '*': j = multiply; break;
	case '/': j = divide; break;
	case '(': j = leftbracket; break;
	case ')': j = rightbracket; break;
	case '#': j = pound; break;
	case '^': j = involution; break;
	case '[': j = leftBracket; break;
	case ']': j = rightBracket; break;
	default:
		cout << "ERROR_02";
		return -2;
	}
	return Relationship[i][j];
}//Precede

OperandType EvaluateExpression(char* expression) {
	//计算以字符串表示的表达式expression的值
	SqStack_OPND OPND;
	SqStack_OPTR OPTR;
	InitStack_OPND(OPND);
	InitStack_OPTR(OPTR);
	char c;
	OperatorType x, theta;
	OperandType a, b, num, num_dec;
	int dot;
	Push_OPTR(OPTR, '#');
	char* p = expression;
	c = *p;
	while (c != '#' || GetTop_OPTR(OPTR) != '#') {
		if (!InOP(c)) {
			if (!InNum(c)) {
				cout << "ERROR_02";
				exit(ERROR);
			}
			num = 0.0;
			dot = 0;
			int d = 10;
			while (!InOP(c)) {
				if (c != '.')
					num = 10 * num + c - '0';
				else {
					dot = 1;
					c = *++p;
					break;
				}//else
				c = *++p;
			}//while
			if (dot == 1) {
				if (InOP(c)) {
					cout << "ERROR_02";
					exit(ERROR);
				}
				while (!InOP(c)) {
					num = num + (double)(c - '0') / d;
					d = d * 10;
					c = *++p;
				}//while
			}//if
			Push_OPND(OPND, num);
		}//if
		else {

			if (InOP2(c) && InOP2(*(p + 1))) {
				cout << "ERROR_02";
				exit(ERROR);
			}
			switch (Precede(GetTop_OPTR(OPTR), c))
			{
			case -1:
				Push_OPTR(OPTR, c);
				c = *++p;
				break;
			case 0:
				Pop_OPTR(OPTR, x);
				c = *++p;
				break;
			case 1:
				Pop_OPTR(OPTR, theta);
				Pop_OPND(OPND, b);
				Pop_OPND(OPND, a);
				Push_OPND(OPND, Operate(a, theta, b));
				break;
			default:
				cout << "ERROR_02";
				exit(ERROR);
				break;
			}//switch
		}//else
	}//while
	double result = GetTop_OPND(OPND);
	DestroyStack_OPND(OPND);
	DestroyStack_OPTR(OPTR);
	return result;
}//EvaluateExpression

OperandType Operate(OperandType a, OperatorType theta, OperandType b) {
	//计算a theta b的值
	switch (theta)
	{
	case'+':
		return a + b;
		break;
	case'-':
		return a - b;
		break;
	case'*':
		return a * b;
		break;
	case'/':
		if (b == 0) {
			cout << "ERROR_03";
			exit(ERROR);
		}
		return a / b;
		break;
	case'^':
		return pow(a, b);
		break;
	default:
		exit(ERROR);
		break;
	}
	return ERROR;
}//Operate

OperandType Pow(OperandType a, OperandType b) {
	//指数计算
	int i;
	OperandType result = 1.0;
	for (i = 0; i < b; i++) 
		result = result * a;
	return result;
}//Pow

Status InOP(OperatorType e) {
	//判断元素e是否属于运算符集合OP，若属于返回TRUE，若不属于返回FALSE
	char OP[11] = "+-/*()[]^#";
	char* p;
	for (p = OP; *p; p++)
		if (*p == e) return TRUE;
	return FALSE;
}//InOP

Status InOP2(OperatorType e) {
	//判断元素e是否属于运算符集合OP2，若属于返回TRUE，若不属于返回FALSE
	char OP2[11] = "+-/*^";
	char* p;
	for (p = OP2; *p; p++)
		if (*p == e) return TRUE;
	return FALSE;
}//InOP2

Status InNum(OperatorType e) {
	//判断元素e是否属于数字集合，若属于返回TRUE，若不属于返回FALSE
	char Num[12] = "0123456789.";
	char* p;
	for (p = Num; *p; p++)
		if (*p == e) return TRUE;
	return FALSE;
}//InNum

//-----栈操作之算法描述
Status InitStack_OPTR(SqStack_OPTR& S) {
	//构造一个空栈S 
	S.base = (OperatorType*)malloc(STACK_INIT_SIZE * sizeof(OperatorType));
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}

Status DestroyStack_OPTR(SqStack_OPTR& S) {
	//销毁栈S，S不再存在 
	free(S.base);
	S.stacksize = 0;
	return OK;
}

Status ClearStack_OPTR(SqStack_OPTR& S) {
	//把S置为空栈 
	S.top = S.base;
	return OK;
}

Status StackEmpty_OPTR(SqStack_OPTR S) {
	//若栈S为空栈，则返回TRUE，否则返回FALSE 
	if (S.top == S.base) return TRUE;
	else return FALSE;
}

int StackLength_OPTR(SqStack_OPTR S) {
	//返回S的元素个数，即栈的长度
	int len = S.top - S.base;
	return len;
}

OperatorType GetTop_OPTR(SqStack_OPTR S) {
	//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR 
	OperandType e;
	if (S.base == S.top) return ERROR;
	e = *(S.top - 1);
	return e;
}

Status Push_OPTR(SqStack_OPTR& S, OperatorType e) {
	//插入元素e为新的栈顶元素 
	if (S.top - S.base >= S.stacksize) {		//判断是否栈满
		S.base = (OperatorType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(OperatorType));
		if (!S.base) exit(OVERFLOW);
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	*S.top++ = e;
	return OK;
}

Status Pop_OPTR(SqStack_OPTR& S, OperatorType& e) {
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR 
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}

Status visit_OPTR(OperatorType x) {
	printf("%c\t", x);
	return OK;
}

Status StackTraverse_OPTR(SqStack_OPTR S, Status(*visit)(OperatorType)) {
	//从栈底到栈顶依次对栈中每个元素调用函数visit(),一旦visit失败，则操作失败 
	OperatorType* p;
	for (p = S.base; p < S.base + StackLength_OPTR(S); p++)
		if (!visit(*p))
			return ERROR;
	return OK;
}

//-----栈操作的算法描述----- 
Status InitStack_OPND(SqStack_OPND& S) {
	//构造一个空栈S 
	S.base = (OperandType*)malloc(STACK_INIT_SIZE * sizeof(OperandType));
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}

Status DestroyStack_OPND(SqStack_OPND& S) {
	//销毁栈S，S不再存在 
	free(S.base);
	S.stacksize = 0;
	return OK;
}

Status ClearStack_OPND(SqStack_OPND& S) {
	//把S置为空栈 
	S.top = S.base;
	return OK;
}

Status StackEmpty_OPND(SqStack_OPND S) {
	//若栈S为空栈，则返回TRUE，否则返回FALSE 
	if (S.top == S.base) return TRUE;
	else return FALSE;
}

int StackLength_OPND(SqStack_OPND S) {
	//返回S的元素个数，即栈的长度
	int len = S.top - S.base;
	return len;
}

OperandType GetTop_OPND(SqStack_OPND S) {
	//若栈不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR 
	OperandType e;
	if (S.base == S.top) return ERROR;
	e = *(S.top - 1);
	return e;
}

Status Push_OPND(SqStack_OPND& S, OperandType e) {
	//插入元素e为新的栈顶元素 
	if (S.top - S.base >= S.stacksize) {		//判断是否栈满
		S.base = (OperandType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(OperandType));
		if (!S.base) exit(OVERFLOW);
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	*S.top++ = e;
	return OK;
}

Status Pop_OPND(SqStack_OPND& S, OperandType& e) {
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR 
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}

Status visit_OPND(OperandType x) {
	printf("%f\t", x);
	return OK;
}

Status StackTraverse_OPND(SqStack_OPND S, Status(*visit)(OperandType)) {
	//从栈底到栈顶依次对栈中每个元素调用函数visit(),一旦visit失败，则操作失败 
	OperandType* p;
	for (p = S.base; p < S.base + StackLength_OPND(S); p++)
		if (!visit(*p))
			return ERROR;
	return OK;
}

/*
	相	顾	无	相	识，
	长	歌	怀	采	薇。
*/

Lanzer Linzeux
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
利用栈进行表达式求值
kjrhk的博客
04-03 1160
利用栈进行表达式求值 实验步骤 1）构建操作数栈和运算符栈 2）确定优先级 3）括弧匹配 4）利用运算符栈转换成后缀式 5）利用操作数栈解出结果 源码： #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <ctype.h> ...
用栈实现两位数表达式的求值
qq_33487728的博客
05-04 853
#include&lt;iostream&gt; using namespace std; //const char oper[7] = {'+','-','*','/','(',')','#'}; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef char SElemType; typedef int Status; typed...
数据结构——栈的应用（表达式求值）（C语言）
热门推荐
Sup_klz的博客
04-16 2万+
char Precede(char t1, char t2)函数用于输出t1,t2两个运算符的优先级（t1为先出现的运算符（已经压入栈OPTR中），t2为后出现的运算符）char Precede(char t1, char t2){ int i,j; char pre[][7]={ //运算符之间的优先级制作成一张表格 {'>
表达式求职
qq_41031033的博客
04-08 454
表达式求职 OperandType EvaluateExpression(){ //算数表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈， //OP为运算符集合 InitStack(OPTR); Push(OPTR,'#'); initStack(OPND); c=getchar(); while(c!='#'||GetTop(OPTR)!='#'){ if(!In...
大二数据结构学习3（栈）
沉晨尘宸的博客
10-04 680
栈和队列栈一 定义二 代码结构【1】静态分布【2】动态分布【3】初始化【4】入栈【5】出栈【6】建立完整栈，实现入栈出栈链栈一 定义二 结构代码【1】建立结构【2】初始化【3】入栈【4】出栈【5】总体建立，实现出栈入栈栈的应用一.数制转换【1】思想：【2】代码： 栈 一 定义 1.栈：限定仅在表尾进行插入或删除操作的线性表 2 栈底固定不变，后进先出 二 代码结构 【1】静态分布 typedef struct link//定义一个栈 { ElemType elem[maxleng];//栈中的数据
复习九：栈的应用——表达式求值
yyy_zxc的博客
09-14 203
OperandType EvaluateExpression(){ //算术表达式求值的算符优先算法。设OPTR为运算符栈，OPND为操作数栈 //OP为运算符集合 InitStack(OPTR); Push(OPTR,'#'); //“#”为运算符栈的栈低元素 InitStack(OPND); c=getchar(); //输入表达式，表达式起始符为“#” while(c!= '#' || GetTop(OPTR)!='#'){
C++用栈实现表达式求值
04-15
C++用栈实现表达式求值，经过验收的，可以运行，没有问题
C语言数据结构用栈实现表达式求值
10-26
在本项目中，我们将探讨如何利用C语言的数据结构——栈，来实现表达式的求值。栈是一种特殊的线性数据结构，遵循“后进先出”（LIFO）的原则，非常适合处理具有运算顺序的计算问题，如数学表达式的求值。 首先，...
数据结构课程设计-用栈实现表达式求值的方法详解
09-05
总结来说，使用栈实现表达式求值是一种常见的数据结构应用，它利用了栈的后进先出（LIFO）特性，有效地处理了运算符的优先级，从而能正确地计算复杂的算术表达式。这个方法在编译原理、解析器设计以及各种计算任务...
EvaluateExpression
03-14
C语言代码练习，程序员：EvaluateExpression
栈实现表达式求值
12-27
栈实现表达式求值
数据结构学习笔记 --- 栈的应用举例
whz_zb的专栏
02-12 1150
1. 引言  本文主要讲解栈的一些应用：（1）迷宫求解 （2）表达式求值 （3）栈与递归 ——hanoi塔（4）括号匹配 2. 迷宫求解 2.1 解法1 #include // test #if 0 #define MAZE_COLUMN 7 // 迷宫的列数 #define MAZE_ROW 7 // 迷宫的
3.1 栈和队列-栈
michael_linux的博客，一个小小小学生。滴水穿石，步步为营，只为那刹那芳华。
09-06 480
栈和队列 - 栈 Stack 1栈的类型定义2栈的应用举例例一、数制转换例二、括号匹配的检验例三、行编辑程序问题例四、迷宫求解例五、表达式求值例六、实现递归3栈类型的实现栈 1栈的类型定义 ADT Stack{ 数据对象: D={ai∣ai∈ElemSet;i=l,2,...,n;n⩾0}D=\{a_{i} | a_{i} \in ElemSet; i=l,2,...,n; n \geqslant 0\}D={ai​∣ai​∈ElemSet;i=l,2,...,n;n⩾0} 数据关系: R1={<ai
栈的链式表示
weixin_42480264的博客
07-31 461
栈的操作是线性表操作的特例 ///栈的链式表示 #include &lt;cstdio&gt; #include &lt;cstdlib&gt; #include &lt;algorithm&gt; #include &lt;malloc.h&gt; using namespace std; #define OK 1 #define ERROR -1 #define TRUE 1 #defin...
C语言版数据结构顺序栈的数据结构和基本操作函数实现
cyannxc的博客
10-14 1555
这个简单程序的编写过程可谓不简单，一点小bug卡了将近10多天，今天灵感一来，解决了。 书上只有完整函数声明，但没有完整函数代码，于是我为了练习并且加深印象，就打算将所有函数实现一遍，于是就有了这个程序。在完成过程中有借鉴，但是有些借鉴并不正确，编译出来还是有错，我就自己再看书学习研究，根据自己的理解修改，最后费尽心思还是完成了这个练习程序代码，在Code::Blocks中顺利编译运行，真的是...
【实验报告】实验三顺序栈实现括号匹配
whyxian的博客
01-30 2510
顺序栈实现括号匹配 一、需求分析 1、数据存储结构为栈 2、输入形式为键盘 3、输出形式为打印形式 4、包含栈的基本操作 5、能够完成指定要求的括号匹配操作 二、概要设计 一、抽象数据类型定义 ADT Stack { 数据对象：D = {ai | ai ∈ ElemSet，i = 1,2,3,…,n, n ≥ 0} 数据关系： R1={<ai-1, ai> | ai-1 , ai∈D，i=2，…，n} // ai-1为前驱，ai为后继，约定 an 端为栈顶，a1 端为栈底 基本操作： Init
栈的应用-表达式求值
qq_51691366的博客
07-27 3290
表达式求值。
c语言数据结构栈中得到最小值,C语言数据结构 栈的基础操作
weixin_42501373的博客
05-16 217
C语言数据结构 栈的基础操作实现了栈的基本操作，包括入栈出栈，以及书上没有写的销毁栈等操作，并对代码进行了详细的注释MyStack.h/** Include.h** Created on: 2016.11.23* Author: Jack Cui*/#ifndef MYSTACK_H_#define MYSTACK_H_#include #include #include /*栈(Stack)...
使用栈实现表达式求值
最新发布
11-04
栈是实现表达式求值的一种常用数据结构。使用栈实现表达式求值的基本思路是，将中缀表达式转换为后缀表达式，然后再利用栈对后缀表达式进行求值。具体步骤如下： 1. 创建两个栈，一个用于存储操作数，一个用于存储运算符。 2. 从左到右扫描中缀表达式的每个元素，若是操作数则直接压入操作数栈中，若是运算符则与运算符栈的栈顶元素比较优先级，若当前运算符优先级高于栈顶运算符，则将当前运算符压入运算符栈中；否则，将运算符栈的栈顶元素弹出并压入操作数栈中，直到当前运算符的优先级高于栈顶运算符。 3. 当扫描完中缀表达式后，将运算符栈中的所有运算符依次弹出并压入操作数栈中。 4. 此时操作数栈中只剩下一个元素，即为表达式的值。 举个例子，假设要求解的中缀表达式为：3+4*5-6/2# 1. 将中缀表达式转换为后缀表达式：345*+62/-# 2. 从左到右扫描后缀表达式的每个元素，若是操作数则直接压入操作数栈中，若是运算符则弹出操作数栈中的两个元素进行计算，并将结果压入操作数栈中。 3. 扫描完后缀表达式后，操作数栈中只剩下一个元素，即为表达式的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lanzer Linzeux

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值