【c++栈的应用】表达式的求值

最新推荐文章于 2024-05-03 15:15:40 发布
最新推荐文章于 2024-05-03 15:15:40 发布
阅读量2.6k 收藏 32
点赞数 3
分类专栏： C++ 文章标签： 栈 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53268869/article/details/118640947
版权

今天我们来利用栈来实现一下表达式的求值。

之前我也写过关于栈的基本功能的内容，链接如下：

数据结构之栈与队列（一）

什么是“表达式求值“

表达式的求值，简单来说，就是实现任意加减乘除与括号的表达式求值，以文本的文件的方式来输入输出。

最终效果演示

1.这里我们需要先将未计算的表达式写入begin.txt文本
在这里插入图片描述
2.运行程序
.
3.查看finall.txt文本
在这里插入图片描述

实现代码

求取算数表达式的值，我们将这个过程分成两步：

1.将算数表达式exp转化为后缀表达式postexp。
2.使用后缀表达式postexp求值。

将算数表达式exp转化为后缀表达式postexp

在转换过程中，我们采用一个运算符栈，用来存储运算符结构如下：

struct
{
	char *data;
	int top;
}op;

将中缀表达式exp转化为后缀表达式postexp的过程为：

while(从exp读取字符ch,ch!='\0')
{
if ch 为数字，将后续的所有数字均以次存放在postexp中，并以字符“#”标志数值串结束。
if ch 为'('，则将括号进栈到运算符栈op中
if ch 为')'，则将运算符op中左括号右边的运算符依次出栈并放在postexp中，并将左括号删除。
if ch 为 运算符 ，当ch的优先级不大于栈顶运算符（栈顶元素为"（"除外）的优先级，则以此出栈并存入postexp中，然后将ch进栈。
}

当字符串exp扫描完毕时，则将运算符栈op中的所有运算符以此出栈并以此出栈存放到postexp，最后得到后缀表达式postexp.

这里给出一个例子，以便理解：
在这里插入图片描述

将exp转化为后缀表达式postexp的trans()算法如下。

void trans(char exp[], char postexp[])
{
	char ch;
	op.data = new char[MAXSIZE];
	op.top = -1;
	int i = 0, j = 0;//i为exp下标，j为postexp下标
	
	ch = exp[i];
	//cout << ch<<"_";
	i = 1;
	//cout << ch << "_";
	while (ch!='\0')//扫描字符数组exp
	{
		switch (ch)
		{
		
		case '(':      //左括号直接入栈
			op.top++;
			op.data[op.top] = ch;
			break;
		case ')':       
			while (op.data[op.top] != '(')   //‘（’之前的字符以此出栈并存入postexp
			{
				postexp[j] = op.data[op.top];  
				j++;
				op.top--;
			}
			op.top--;  //左括号出栈，并删除
			break;
		case'+':   //符号优先级不大于栈顶任何运算符的优先级，且栈顶不是‘（’
		case'-':
			//cout << op.top << "_";
			//if ((exp[0] == '+'|| exp[0] == '-')&&(op.top==-1))//当首运算符为+或-
			//{
			//	postexp[j] = 0;  
			//	postexp[++j] = '#';
			//	j++;
			//}
			
			while (op.top != -1 && op.data[op.top] != '(')//依次出栈，存入postexp
			{
				postexp[j] = op.data[op.top];
				j++;
				op.top--;
				//cout << op.top << "_";
			}

			op.top++;             //将ch进栈
			//cout << op.top<<"_";
			op.data[op.top] = ch;
			break;
		case'*':    //符号优先级不大于栈顶任何运算符的优先级，且栈顶不是‘（’
		case'/':
			while (op.top != -1 && op.data[op.top] != '('&&
				(op.data[op.top]=='*'||op.data[op.top]=='/'))
			{
				postexp[j] = op.data[op.top];//依次出栈，存入postexp
				j++;
				op.top--;
			}
			op.top++;//将ch进栈
			op.data[op.top]=ch;
			break;
		case' ':     //将空格过滤
			break;
		default:
			while (ch >= '0' && ch <= '9')  //判定为数字
			{
				postexp[j] = ch;
				j++;
				ch = exp[i];    
				i++; 
			}
			i--;
			postexp[j] = '#'; //在每段数字结束后加‘#’作为结束符
			j++;
		}
		ch = exp[i]; 
		i++;
	}
	while (op.top != -1)
	{
		postexp[j] = op.data[op.top];
		j++;
		op.top--;
	}
	postexp[j] = '\0';

}

使用后缀表达式postexp求值

在计算后缀表达式值得过程中使用中使用一个数值栈st,设计其结构如下：

struct
{
	float* data;
	int top;
}st;

求值过程如下：
 while(从postexp读取字符ch,ch!='\0')
 {
 if ch 为数字，将后继的所有数字构成一个整数存放在数值栈st中
 if ch 为“+”,则从数值栈st中退站两个运算数，相加后进栈st中
 if ch 为“-”,则从数值栈st中退站两个运算数，相减后进栈st中
 if ch 为“*”,则从数值栈st中退站两个运算数，相乘后进栈st中
 if ch 为“/”,则从数值栈st中退站两个运算数，相除后进栈st中（若除数为0，则提示错误）
 }

我们将上一个例子得到的后缀表达式求值

在这里插入图片描述

根据上述原理得到compvalue算法

float compvalue(char postexp[])
{
	float d;
	char ch;
	int i = 0;
	st.data = new float[MAXSIZE];
	st.top = -1;
	ch = postexp[i];
	//cout << ch <<"_"<< endl;;
	i++;
	while (ch != '\0')
	{
		switch (ch)
		{
		case'+':
			st.data[st.top - 1] = st.data[st.top - 1] + st.data[st.top];
			st.top--;
			break;
		case'-':
			st.data[st.top - 1] = st.data[st.top - 1] - st.data[st.top];
			st.top--;
			break;
		case'*':
			st.data[st.top - 1] = st.data[st.top - 1] * st.data[st.top];
			st.top--;
			break;
		case'/':
			if(st.data[st.top]!=0)
			st.data[st.top - 1] = st.data[st.top - 1] / st.data[st.top];
			else
			{
				cout << ("\n\t除零错误!\n");
				exit(0);
			}
			st.top--;
			break;
		case' ':
			break;
		
		default:
			d = 0;
			while (ch >= '0' && ch <= '9')
			{
				d = 10 * d + ch - '0';    
				ch = postexp[i];
				i++;
			}
			st.top++;
			st.data[st.top] = d;
			
		}
		ch = postexp[i];
		i++;
	}
	return st.data[st.top];

}

以上就是表达式求值的核心部分。

接下来是完整的代码

1.头文件 calulate.h

#pragma once
#include<iostream>
using namespace std;
#include<fstream>
#include<string>
#include<string.h>

#define MAXSIZE 100

struct
{
	char *data;
	int top;
}op;
struct
{
	float* data;
	int top;
}st;
string read(int k);
void trans(char exp[], char postexp[]);
float compvalue(char postexp[]);
void Print(char over[]);

2.源文件calulate.cpp

#include"calulate.h"

void Init()
{
	
}
string read(int k)
{
	fstream ofs;
	ofs.open("begin.txt", ios::in|ios::out);
	if (!ofs.is_open())
	{
		cout << "文件打开失败！" << endl;
	}
	string data[100];
	int i = 0;
	while (getline(ofs, data[i]))
	{
		i++;
	}
	return data[k];


}
void trans(char exp[], char postexp[])
{
	char ch;
	op.data = new char[MAXSIZE];
	op.top = -1;
	int i = 0, j = 0;//i为exp下标，j为postexp下标
	
	ch = exp[i];
	//cout << ch<<"_";
	i = 1;
	//cout << ch << "_";
	while (ch!='\0')//扫描字符数组exp
	{
		switch (ch)
		{
		
		case '(':      //左括号直接入栈
			op.top++;
			op.data[op.top] = ch;
			break;
		case ')':       
			while (op.data[op.top] != '(')   //‘（’之前的字符以此出栈并存入postexp
			{
				postexp[j] = op.data[op.top];  
				j++;
				op.top--;
			}
			op.top--;  //左括号出栈，并删除
			break;
		case'+':   //符号优先级不大于栈顶任何运算符的优先级，且栈顶不是‘（’
		case'-':
			//cout << op.top << "_";
			//if ((exp[0] == '+'|| exp[0] == '-')&&(op.top==-1))//当首运算符为+或-
			//{
			//	postexp[j] = 0;  
			//	postexp[++j] = '#';
			//	j++;
			//}
			
			while (op.top != -1 && op.data[op.top] != '(')//依次出栈，存入postexp
			{
				postexp[j] = op.data[op.top];
				j++;
				op.top--;
				//cout << op.top << "_";
			}

			op.top++;             //将ch进栈
			//cout << op.top<<"_";
			op.data[op.top] = ch;
			break;
		case'*':    //符号优先级不大于栈顶任何运算符的优先级，且栈顶不是‘（’
		case'/':
			while (op.top != -1 && op.data[op.top] != '('&&
				(op.data[op.top]=='*'||op.data[op.top]=='/'))
			{
				postexp[j] = op.data[op.top];//依次出栈，存入postexp
				j++;
				op.top--;
			}
			op.top++;//将ch进栈
			op.data[op.top]=ch;
			break;
		case' ':     //将空格过滤
			break;
		default:
			while (ch >= '0' && ch <= '9')  //判定为数字
			{
				postexp[j] = ch;
				j++;
				ch = exp[i];    
				i++; 
			}
			i--;
			postexp[j] = '#'; //在每段数字结束后加‘#’作为结束符
			j++;
		}
		ch = exp[i]; 
		i++;
	}
	while (op.top != -1)
	{
		postexp[j] = op.data[op.top];
		j++;
		op.top--;
	}
	postexp[j] = '\0';

}
float compvalue(char postexp[])
{
	float d;
	char ch;
	int i = 0;
	st.data = new float[MAXSIZE];
	st.top = -1;
	ch = postexp[i];
	//cout << ch <<"_"<< endl;;
	i++;
	while (ch != '\0')
	{
		switch (ch)
		{
		case'+':
			st.data[st.top - 1] = st.data[st.top - 1] + st.data[st.top];
			st.top--;
			break;
		case'-':
			st.data[st.top - 1] = st.data[st.top - 1] - st.data[st.top];
			st.top--;
			break;
		case'*':
			st.data[st.top - 1] = st.data[st.top - 1] * st.data[st.top];
			st.top--;
			break;
		case'/':
			if(st.data[st.top]!=0)
			st.data[st.top - 1] = st.data[st.top - 1] / st.data[st.top];
			else
			{
				cout << ("\n\t除零错误!\n");
				exit(0);
			}
			st.top--;
			break;
		case' ':
			break;
		
		default:
			d = 0;
			while (ch >= '0' && ch <= '9')
			{
				d = 10 * d + ch - '0';    
				ch = postexp[i];
				i++;
			}
			st.top++;
			st.data[st.top] = d;
			
		}
		ch = postexp[i];
		i++;
	}
	return st.data[st.top];

}

3.测试文件test.cpp

#include"calulate.h"

void test()
{
	fstream fst;
	fst.open("final.txt", ios::app);

	char*postexp;
	postexp = new char[20];
	int i = 0;
	int j = 0;
	float tiv=0;
	string s;
	char mine[20]="0";
	for (i = 0; i < 20; i++)
	{
		if (read(i) != "")
		{
			s = read(i);
		           
					strncpy_s(mine, s.c_str(), s.length()-1);
					//当首元素为运算符时
					if (mine[0] == '-'||mine[0]=='+')
					{
						for (int m = 18; m > -1; m=m - 1)
						{
							mine[m + 1] = mine[m];
						}
						mine[0] = '0';
					}

					//当出现(-x)时
					for (int y = 1; y < 20; y++)
					{
						if (mine[y] == '-'&&mine[y-1]=='(')
						{
							for (int w = 18; w > y - 1; w = w - 1)
							{
								mine[w + 1] = mine[w];
							}
							mine[y] = '0';
						}
					}
					trans(mine, postexp);


	//char postexp[20] = "0#1#-2#+";
					tiv=compvalue(postexp);
					//cout <<endl<< postexp;
					if (mine[0] != '0')
					{
						for (j = 0; mine[j];j++)
						{
							cout << mine[j];
							fst << mine[j];
						}
					}
					if(mine[0]=='0')
					{
						for (j = 1; mine[j]; j++)
						{
							cout << mine[j];
							fst << mine[j];
						}
					}
                    
					cout <<"="<< tiv << endl;
					fst << "=" << tiv << endl;
		}
		

	}
	
}
int main()
{
	test();
	return 0;
}
Ornamrr
关注
  • 3
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
表达式求值【栈】C++
01-13
表达式求值，用栈实现，C++，支持符号、括号、以及出错处理，程序健壮性应该比较好，本人自己编写，上传的压缩包中有一个运行环境为VS2005，另一个运行环境为VC6.0的源文件，可根据自己电脑的运行环境自行选择
数据结构之栈的应用 -- 表达式求值（C++）
C2395850595的博客
05-10 626
一、栈的定义 栈作为一种数据结构 ，是一种只能在一端进行插入和删除操作的特殊线性表 。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 二、整体代码 #include <iostream> #include <cstring> #include <algorithm> #include <stack> #include <unordered_map>
数据结构栈实现表达式求值
01-12
数据结构栈实现表达式求值数据结构栈实现表达式求值数据结构栈实现表达式求值数据结构栈实现表达式求值
【栈】实现表达式求值(C++)(详解)
半生瓜のblog
10-15 2006
【栈】实现表达式求值 思路 && 理解 && 注意 给定一串表达式，字符串类型，依次遍历从头开始遍历每一个位置的内容。 第一个数字，第一个运算符先直接往栈里面push(两个不同的栈) 接着走，遇到数push进来，接着走，遇到运算符，和前面那个已经push进栈的运算符进行优先级比较，如果当前运算符优先级大，那就接着push进来，反之，pop出栈，运算前面的式子之和(之后判断运算符栈中是否还有内容，并且当前运算符的优先级是否小于等于已有的运算符，小于等于就接着运算前面的表达式，
表达式求值
weixin_38199770的博客
01-08 861
成绩 15 开启时间 2017年10月18日 星期三 14:00 折扣 0.8 折扣时间 2017年11月8日 星期三 23:55 允许迟交 否 关闭时间 2018年01月8日 星期一 23:55 背景： 我们的教材中已经介绍了表达式求值的算法，现在我们将该算法的功能进行扩展，
C++利用链栈实现表达式求值
12-31
本文实例为大家分享了C++利用链栈实现表达式求值的具体代码，供大家参考，具体内容如下 #include typedef int Status; typedef char Cstack; #define OK 1 #define ERROR 0 typedef struct StackNode { Cstack data; struct StackNode *next; }StackNode,*LinkStack; Status InitStack(LinkStack &S) { S=NULL; return OK; } Status Push(Link
使用栈实现表达式求值
热门推荐
BestFSQ的博客
02-19 4万+
任何一个表达式都是由操作数，运算符，界限符组成的。操作数即是参加运算的数值或者变量，运算符则是加减乘除等组成，为简单起见，这里只实现加减乘除的运算，而常见的界限符则是左右括号和终止符。在运算过程中，要判断两个先后出现的运算符之间的优先顺序。 为了实现算法，设置两个工作栈：用于存储运算符的栈opter，以及用于存储操作数及中间结果的栈opval。 算法基本思想如下： （1）首先将操作数栈opv
C++学习之交互式表达式求值的详细讲解和简单代码示例
分享型博主
04-14 1069
交互式求表达式值是指通过命令行交互的方式，接收用户输入的数值和运算符号，然后计算出其表达式的值并返回给用户。这种方式可以方便地进行简单的计算和查错，也可以用于程序设计中一系列复杂的计算。
（C++）整数表达式计算
coderge's CSDN Blog.
08-07 1872
实现多位整数表达式计算 （ 1.浮点数不OK 2.未用中追转后缀 ） #include&lt;iostream&gt; //输入的表达式要以'#'结尾，如‘5+6*3/(3-1)#’ #include&lt;cstring&gt; #include&lt;cctype&gt; #include&lt;stack&gt; using namespace std;...
C++实现简单表达式求值
m0_73038387的博客
05-09 1109
【代码】C++实现简单表达式求值。
微信小程序任务栈实现原理。.zip
03-10
爬虫的工作流程包括以下几个关键步骤： URL收集： 爬虫从一个或多个初始URL开始，递归或迭代地发现新的URL，构建一个URL队列。这些URL可以通过链接分析、站点地图、搜索引擎等方式获取。 请求网页： 爬虫使用HTTP...
基于微信支付javaSDK的接口层封装（技术栈：springboot）.zip
03-10
如果您下载了本程序，但是该程序存在问题无法运行，那么您可以选择退款或者寻求我们的帮助（如果找我们帮助的话，是需要追加额外费用的）。另外，您不会使用资源的话（这种情况不支持退款），也可以找我们帮助（需要...
超级有影响力霸气的Java面试题大全文档
07-18
在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。...
Java开发实战1200例(第1卷).(清华出版.李钟尉.陈丹丹).part3
06-12
　本书非常适合Java的初学者，如高校学生、求职人员作为练习、速查、学习使用，也适合Java程序员参考、查阅。 目 录 第1篇 Java语法与面向对象技术 第1章 开发环境的应用 2 1.1 Java环境 3 实例001 下载JDK开发...
数据结构--顺序表经典OJ题
zy1215058242的博客
05-02 409
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。设计实现一个时间复杂度为O(m + n)的算法解决此问题.解：对于这道题来说我们有多种思路，但是在限制了时间复杂度后，三变量就是最好的方法。
数据结构===散列表
最新发布
yajunjiao的专栏
05-03 401
散列表，很重要的数据结构，常用。重要概念，散列思想；散列冲突如何解决，开放寻址法，链表法；好好学学，很多地方都很常用。
【数据结构初阶】时间复杂度和空间复杂度详解
Qiwaw的博客
04-29 906
关于复杂度，你真的理解吗？来这看看吧！
数据结构-链表练习（面试题）
2302_81705247的博客
04-29 771
建立变量cur指向第二个节点，curN指向cur.next，将第二个节点的next改为head，head=cur这样实现，前两个节点顺序的翻转，第二个节点指向了第一个节点，之后cur向后移（cur=curN），curN也向后移，进行循环，直到所以节点的顺序都翻转。1，先用快慢指针，找到中间值，然后将中间值后面的节点翻转，然后，中间值以前的节点从前往后遍历，中间值以后的节点从后往前遍历，并对比节点的val是否相同，如果完全相同，则为回文，如果不相同，则不是。7， 输入两个链表，找出它们的第一个公共结点。
栈中缀表达式转后缀表达式
08-26
栈中缀表达式转后缀表达式的过程可以使用栈来实现。下面是实现该转换的算法： 1. 创建一个空栈和一个空字符串，用于存储后缀表达式。 2. 从左到右遍历中缀表达式的每个字符： - 如果字符是数字或字母，直接将其添加到后缀表达式字符串中。 - 如果字符是左括号"("，将其入栈。 - 如果字符是右括号")"，则将栈顶元素出栈并添加到后缀表达式字符串，直到遇到左括号为止。左括号不添加到后缀表达式中，也不入栈。 - 如果字符是运算符（如"+", "-", "*", "/"等）： - 如果栈为空，或者栈顶元素是左括号"("，则将该运算符入栈。 - 否则，将栈顶运算符与当前运算符进行比较： - 如果栈顶运算符的优先级大于等于当前运算符，则将栈顶运算符出栈并添加到后缀表达式字符串中，循环执行该步骤直到不满足条件。 - 将当前运算符入栈。 3. 遍历完中缀表达式后，将栈中剩余的所有运算符依次出栈并添加到后缀表达式字符串中。 4. 后缀表达式字符串即为转换后的结果。 以下是一个示例的实现（使用Python语言）： ```python def infix_to_postfix(expression): # 定义运算符优先级 precedence = {"+": 1, "-": 1, "*": 2, "/": 2} stack = [] postfix = "" for char in expression: if char.isalnum(): postfix += char elif char == "(": stack.append(char) elif char == ")": while stack and stack[-1] != "(": postfix += stack.pop() stack.pop() # 弹出左括号 else: while stack and stack[-1] != "(" and precedence[char] <= precedence.get(stack[-1], 0): postfix += stack.pop() stack.append(char) while stack: postfix += stack.pop() return postfix ``` 可以通过调用 `infix_to_postfix` 函数将中缀表达式转换为后缀表达式。例如，`infix_to_postfix("3+4*2/(1-5)^2^3")` 将返回后缀表达式字符串 "342*15-23^^/"。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Ornamrr

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

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

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

打赏作者

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

抵扣说明：

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

余额充值