数据结构与算法B代码编写作业，表达式·表达式树·表达式求值，AC代码&注释

最新推荐文章于 2020-10-31 19:37:45 发布
最新推荐文章于 2020-10-31 19:37:45 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： 数据结构与算法B
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moien_podiene/article/details/13158881
版权

现在处于刚刚A题身心俱疲的状态…解题报告什么的实在是写不动了…从这篇文章开始将没有解题报告，只有附有详细注释的代码。

另外…这里的代码只是一个思路的参考，同学们还是要自己写的啊=___=

（当然真实情况是）为了防止被助教同志查出代码重复而请我喝茶…小伙伴们一定不要直接把我的代码交给DSB……

所以代码在下面……

/*
ID: Moien_Podiene
LANG: C++
*/

#include <iostream>
#include <cstdlib>
#include <string.h>
#include <memory.h>

using namespace std;

const int MAX_LEN = 65536;	//表达式最大长度
const int MAX_ELE = 256;	//最大变量数

class BinTreeNode;

class BinTreeNode
{
public:
	BinTreeNode(int, char);	//由当前节点的变量值（参数1）和变量名（参数2）创建节点
	BinTreeNode *GetLeftChild();	//返回当前节点的左孩子指针
	BinTreeNode *GetRightChild();	//返回当前节点的右孩子指针
	BinTreeNode *SetLeftChild(BinTreeNode *);	//由参数中的节点设置当前节点的左孩子，返回左孩子指针
	BinTreeNode *SetRightChild(BinTreeNode *);	//由参数中的节点设置当前节点的右孩子，返回右孩子指针
	int GetData();	//获取节点值
	int SetData(int);	//设置节点值，返回设置的值
	char GetName();	//获取变量名
	char SetName(char);	//设置变量名，返回设置名字
private:
	int data;	//当前节点的值，若为运算符则为-1
	char name;	//当前节点的变量名，或运算符号
	BinTreeNode *leftChild;
	BinTreeNode *rightChild;
};

int MaxInt(int, int);	//求两树最大值，返回最大值
int Power(int, int);	//乘方函数，求参数1的参数2次方

BinTreeNode *BuildTree(int, int, char *);	//生成参数3表达式中，从参数1到参数2的树，并返回根节点指针
BinTreeNode *LastOrder(BinTreeNode *);	//后序遍历一棵树，并输出变量名和运算符，返回树的根节点指针
BinTreeNode *FindNode(BinTreeNode *, int, int);	//返回参数1为根的第参数2层第参数3个节点的指针

int Calculate(int, int, char *, int *, char *, int);	//计算参数3的表达式从参数1到参数2的值，返回结果
														//参数4、5为变量名-数值对照表，参数6为表的元素数
int FindLevel(BinTreeNode *);	//返回以参数为根节点的二叉树的层数
bool MakeChart(char[][MAX_ELE], int, BinTreeNode *);	//生成用来输出的层数为参数2的根为参数3的二叉树示意图，存储在参数1的数组中
												//若树为空返回false，否则返回true

int main()
{
	int treeLevel = 0;
	int chartLen = 0;	//变量值-变量名表的长度
	int valChart[MAX_ELE];	//变量值表
	char nameChart[MAX_ELE];	//变量名表
	char formula[MAX_LEN];	//表达式字符串
	char treeChart[MAX_ELE][MAX_ELE];	//输出树的格式
	cin >> formula;
	cin >> chartLen;
	for(int i = 0; i < chartLen; i++)
		cin >> nameChart[i] >> valChart[i];
	BinTreeNode *root = BuildTree(0, strlen(formula) - 1, formula);	//由整个表达式生成二叉树
	treeLevel = FindLevel(root);	//查找树的深度
	LastOrder(root);	//后序遍历整棵二叉树输出逆波兰表达式
	cout << endl;
	MakeChart(treeChart, treeLevel, root);	//建立输出表
	for(int i = 0; i < treeLevel * 2 - 1; i++)
		cout << treeChart[i] << endl;
	cout << Calculate(0, strlen(formula) - 1, formula, valChart, nameChart, chartLen) << endl;	//计算并输出计算结果
	return 0;
}

BinTreeNode::BinTreeNode(int val, char word)
{
	data = val;
	name = word;
	leftChild = rightChild = NULL;
}

BinTreeNode *BinTreeNode::GetLeftChild()
{
	return leftChild;
}

BinTreeNode *BinTreeNode::GetRightChild()
{
	return rightChild;
}

BinTreeNode *BinTreeNode::SetLeftChild(BinTreeNode *val)
{
	leftChild = val;
	return leftChild;
}

BinTreeNode *BinTreeNode::SetRightChild(BinTreeNode *val)
{
	rightChild = val;
	return rightChild;
}

int BinTreeNode::GetData()
{
	return data;
}

int BinTreeNode::SetData(int val)
{
	data = val;
	return data;
}

char BinTreeNode::GetName()
{
	return name;
}

char BinTreeNode::SetName(char word)
{
	name = word;
	return name;
}

int MaxInt(int x, int y)
{
	if(x > y)
		return x;
	else
		return y;
}

int Power(int x, int y)
{
	int res = 1;
	if(y < 0)
		return 0;	//后面构造输出表时用到，负指数定义为0
	for(int i = 0; i < y; i++)
		res *= x;
	return res;
}

BinTreeNode *BuildTree(int start, int end, char *formula)
{
	if(start > end)
		return NULL;
	int match = 0;
	for(int i = end; i >= start; i--)
	{
		if(formula[i] == '(')
			match++;
		else if(formula[i] == ')')
			match--;
		else if(formula[i] == '+' && match == 0)
		{
			BinTreeNode *root = new BinTreeNode(-1, '+');	//存储当前节点为运算符
			root -> SetLeftChild(BuildTree(start, i - 1, formula));	//递归处理左侧表达式为左子树
			root -> SetRightChild(BuildTree(i + 1, end, formula));	//递归处理右侧表达式为右子树
			return root;
		}
		else if(formula[i] == '-' && match == 0)
		{
			BinTreeNode *root = new BinTreeNode(-1, '-');	//存储当前节点为运算符
			root -> SetLeftChild(BuildTree(start, i - 1, formula));	//递归处理左侧表达式为左子树
			root -> SetRightChild(BuildTree(i + 1, end, formula));	//递归处理右侧表达式为右子树
			return root;
		}
	}
	match = 0;
	for(int i = end; i >= start; i--)
	{
		if(formula[i] == '(')
			match++;
		else if(formula[i] == ')')
			match--;
		else if(formula[i] == '*' && match == 0)
		{
			BinTreeNode *root = new BinTreeNode(-1, '*');	//存储当前节点为运算符
			root -> SetLeftChild(BuildTree(start, i - 1, formula));	//递归处理左侧表达式为左子树
			root -> SetRightChild(BuildTree(i + 1, end, formula));	//递归处理右侧表达式为右子树
			return root;
		}
		else if(formula[i] == '/' && match == 0)
		{
			BinTreeNode *root = new BinTreeNode(-1, '/');	//存储当前节点为运算符
			root -> SetLeftChild(BuildTree(start, i - 1, formula));	//递归处理左侧表达式为左子树
			root -> SetRightChild(BuildTree(i + 1, end, formula));	//递归处理右侧表达式为右子树
			return root;
		}
	}
	if(formula[start] == '(' && formula[end] == ')')
		return BuildTree(start + 1, end - 1, formula);
	BinTreeNode *root = new BinTreeNode(-1, formula[start]);	//若未遇到运算符则必为单字符变量
	return root;
}

BinTreeNode *LastOrder(BinTreeNode *root)
{
	if(root -> GetLeftChild() != NULL)
		LastOrder(root -> GetLeftChild());	//递归后序遍历左子树
	if(root -> GetRightChild() != NULL)
		LastOrder(root -> GetRightChild());	//递归后序遍历右子树
	cout << root -> GetName();
	return root;
}

BinTreeNode *FindNode(BinTreeNode *root, int level, int num)
{
	if(root == NULL)
		return root;	//如果子树为空，直接返回空指针
	if(level == 1)	//递归出口，已查找到当前层
		return root;
	if(num <= Power(2, level - 2))
		return FindNode(root -> GetLeftChild(), level - 1, num);	//节点序号小于左右序号分界点2^(level - 2)
																	//在左子树，递归查找左子树
	else
		return FindNode(root -> GetRightChild(), level - 1, num - Power(2, level - 2));	//节点序号超过左右分界点
																						//在右子树，递归查找右子树
	return NULL;
}

int Calculate(int start, int end, char *formula, int *valChart, char *nameChart, int chartLen)
{
	int match = 0;
	for(int i = end; i >= start; i--)
	{
		if(formula[i] == '(')
			match++;
		else if(formula[i] == ')')
			match--;
		else if(formula[i] == '+' && match == 0)	//检测运算符，将表达式分为运算符左侧与运算符右侧，二分求值
			return Calculate(start, i - 1, formula, valChart, nameChart, chartLen) + 
				   Calculate(i + 1, end, formula, valChart, nameChart, chartLen);
		else if(formula[i] == '-' && match == 0)
			return Calculate(start, i - 1, formula, valChart, nameChart, chartLen) - 
				   Calculate(i + 1, end, formula, valChart, nameChart, chartLen);
	}
	match = 0;
	for(int i = end; i >= start; i--)
	{
		if(formula[i] == '(')
			match++;
		else if(formula[i] == ')')
			match--;
		else if(formula[i] == '*' && match == 0)
			return Calculate(start, i - 1, formula, valChart, nameChart, chartLen) * 
				   Calculate(i + 1, end, formula, valChart, nameChart, chartLen);
		else if(formula[i] == '/' && match == 0)
			return Calculate(start, i - 1, formula, valChart, nameChart, chartLen) / 
				   Calculate(i + 1, end, formula, valChart, nameChart, chartLen);
	}
	if(formula[start] == '(' && formula[end] == ')')
		return Calculate(start + 1, end - 1, formula, valChart, nameChart, chartLen);
	char buff = formula[start];	//若未遇到运算符则必为单字符变量
	for(int i = 0; i < chartLen; i++)
	{
		if(nameChart[i] == buff)
			return valChart[i];
	}
	return 1;
}

int FindLevel(BinTreeNode *root)
{
	if(root -> GetLeftChild() == NULL && root -> GetRightChild() == NULL)
		return 1;	//左右子树均为空，叶节点，已经到底层
	else if(root -> GetLeftChild() == NULL)
		return FindLevel(root -> GetRightChild()) + 1;
	else if(root -> GetRightChild() == NULL)
		return FindLevel(root -> GetLeftChild()) + 1;
	return MaxInt(FindLevel(root -> GetLeftChild()), FindLevel(root -> GetRightChild())) + 1;
}

bool MakeChart(char treeChart[][MAX_ELE], int treeLevel, BinTreeNode *root)
{
	if(treeLevel == 0)
		return false;
	for(int i = 0; i < MAX_ELE; i++)
	{
		for(int j = 0; j < MAX_ELE; j++)
			treeChart[i][j] = ' ';	//将后面可能考虑不到的地方先填上空格
		treeChart[i][MAX_ELE - 1] = 0;
	}
	int eleNum;	//当前层节点数
	int posi[MAX_LEN];	//当前处理层有字符的位置序号
	BinTreeNode *nodeBuff;	//暂存找到的节点
	memset(posi, 0, sizeof(posi));
	eleNum = Power(2, treeLevel - 1);	//二叉树第n层有2^(n - 1)个位置
	for(int i = 0; i < eleNum; i++)
		posi[i] = i * 2;	//1、3、5、7……位置对应数组标号0、2、4、6……
	for(int i = treeLevel; i > 0; i--)	//从叶节点层根据叶节点位置数据开始生成输出表
	{
		for(int j = 0; j < eleNum; j++)
		{
			nodeBuff = FindNode(root, i, j + 1);	//找到当前处理节点
			if(nodeBuff != NULL)
			{
				treeChart[i * 2 - 2][posi[j]] = nodeBuff -> GetName();
				for(int k = 0; k < j; k++)
					treeChart[i * 2 - 2][posi[k] + 1] = ' ';	//抹去前面设置的行结尾符号
				treeChart[i * 2 - 2][posi[j] + 1] = 0;	//设置行结尾，若后面再没有有效节点，这里就是行结尾
				if(i != treeLevel)	//若非末尾行，构造下面的树枝符号
				{
					if(nodeBuff -> GetLeftChild() != NULL)
					{
						treeChart[i * 2 - 1][posi[j] - 1] = '/';	//左子树示意字符
						for(int k = 0; k < j; k++)
							treeChart[i * 2 - 1][posi[k]] = treeChart[i * 2 - 1][posi[k] + 2] = ' ';	
																					//抹去前面设置的行结尾符号
						treeChart[i * 2 - 1][posi[j]] = 0;	//设置行结尾，若后面再没有有效节点，这里就是行结尾
					}
					if(nodeBuff -> GetRightChild() != NULL)
					{
						treeChart[i * 2 - 1][posi[j] + 1] = '\\';	//右子树示意字符，注意C++中反斜杠\标记为'\\'
						for(int k = 0; k <= j; k++)
							treeChart[i * 2 - 1][posi[k]] = treeChart[i * 2 - 1][posi[k] + 2] = ' ';	
																					//抹去前面设置的行结尾符号
						treeChart[i * 2 - 1][posi[j] + 2] = 0;	//设置行结尾，若后面再没有有效节点，这里就是行结尾
					}
				}
			}
		}
		eleNum = Power(2, i - 2);
		for(int j = 0; j < eleNum; j++)	//构造上一层的位置表：前一层俩位置中间
			posi[j] = (posi[j * 2] + posi[j * 2 + 1]) / 2;
	}
	return true;
}

我曾经邪恶的想过这样上传我的代码：


想了想还是算了…没被请喝茶我就继续传文本…不用图片折磨大家了…

Moien_Podiene
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
POJ2014考研试题表达式·表达式树·表达式求值答案
10-24
POJ2014考研试题表达式·表达式树·表达式求值答案
表达式·表达式树·表达式求值
魏莘墨的专栏
12-08 1万+
/* 表达式·表达式树·表达式求值 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65535kB 描述 众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b*c，可以表示为如下的表达式树： + / \ a * / \ b c 现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的
表达式求值(表达式树)
weixin_30507481的博客
03-03 938
一个非常基础的问题，建出表达式树后在树上DP即可。预处理时记录每个位置之前每种符号最近的出现位置可以做到线性，这里直接写了$O(n^2)$算法。 注意减法和除法不满足交换律所以要取最右边的一个作为当前子树的根，而乘方要取最左边的。以及注意区分减号和负号。 1 #include<cmath> 2 #include<cstdio> 3 #include<...
运用表达式树求解表达式的值--洛谷AC
weixin_45800653的博客
08-12 1657
题目背景 表达式的计算曾用算符优先法，本题用表达式树来计算表达式的值。 题目描述 表达式树是一种特殊类型的树，其叶结点是操作数（operand），而其它结点为操作符（operator）： （1）由于操作符一般都是双目的，通常情况下该树是一棵二叉树； （2）对于单目操作符（如++），其只有一个子结点。 如表达式：a+b*(c-d)-e/f的后缀表示式为abcd-+ef/- 对应的表达式树为：（见PPT） 题目要求从标准输入中读入一个整数算术运算表达式，计算表达式结果，并输出。 说明： 1、表达式运算符只有+、
【Openjudge】表达式·表达式树·表达式求值
DreamChaserYx的专栏
11-07 1121
代码写的比较烂，有时间再看看别人代码，重写一个好了。#include #include #include #include #include using namespace std; bool compare(char c, char c_in_stack){ if (c == '*' || c == '/'){ if (c_in_stack == '+' || c_in_stack =
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目).zip
最新发布
01-02
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目) 项目包含： 01_变位词问题 02_python数据类型的性能 03_python实现ADT Stack 04_栈的应用1括号匹配 05_栈的应用2十进制转二进制 06_栈的...
数据结构课程设计，最小生成树，克鲁斯卡尔 (Kruskal)，约瑟夫环，表达式求值，
03-20
每个都有很详细的注释，算法是参照严蔚敏和吴伟明的书写的，因为我们课程设计正好用的是这本书，保证你一看就懂！！！
吉林大学数据结构PTA上机题
11-17
吉林大学数据结构 PTA 上机题，只有题目，代码和思路，没有输入和输出的样例。 如果中文注释乱码，用GBK格式打开后不再乱码再用UTF-8格式保存即可。 为后来者提供一些参考，祝上机愉快！上机顺利！ 1. spfa 算法...
JAVA上百实例源码以及开源项目源代码
09-17
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
数据结构课设
01-03
4.概要设计：给出每道题采用的数据结构，算法设计思想，算法的时间复杂度； 5.详细设计：给出每道题的源程序，并在必要的代码处给出注释； 6.功能测试：给出每道题的测试数据和结果； 7.完成情况：每道题完成部分和...
表达式树的简单实现
KingKazma 的专栏
10-10 4053
表达式树是树结构的一个经典应用，常用于编译器的设计。 在表达式树中，叶子通常是常数值或者变量名，统称为操作数（operands）。而其他非叶子结点则包含各种操作符（operators）。 在不同的词法解析中，表达式树的分支设计也不同。对于简单的诸如表达式求解而言，表达式树往往采用二叉树。这是因为每一个操作符正好对应两个操作数。 而在包含一元操作符（e.g自增自减操作符）或三元操作
AC计算表达式 相信你也秒懂
jianxingzhang的博客
03-20 533
You may find it’s easy to calculate the expression such as: a = 3 b = 4 c = 5 a + b + c = ? Isn’t it? InputThe first line contains an integer stands for the number of test cases. Each test case start ...
别样表达式求值
chwei_cson的专栏
07-12 888
表达式求值 时间限制：3000 ms  |  内存限制：65535 KB 难度：3 题目来源：http://acm.nyist.net/JudgeOnline/problem.php?pid=305 描述 Dr.Kong设计的机器人卡多掌握了加减法运算以后，最近又学会了一些简单的函数求值，比如，它知道函数min(20,23)的值是20 ，add(10,98) 的值是108等等。经
表达式树
热门推荐
buaa_shang的专栏
06-18 1万+
用到了栈，并且递归实现了中序遍历，后序遍历，前序遍历。 同时应该学会union的使用方法。 基础知识： 一、表达式树          表达式树的树叶是操作数(operand)，加常数或变量名字，而其他的结点为操作数(operator)。由于这里所有的操作都是二元的，因此这棵特定的树正好是二叉树，虽然这是最简单的情况，但是结点还是有可能含有多于两个的儿子，这里我们不讨
二叉树应用-表达式·表达式树·表达式求值（数据结构基础 第6周）
NodYoung
07-11 8284
问题描述 分析 有点麻烦，这道题还没做。大概想了一下，首先应该是由中缀表达式可转换为后缀表达式（ 栈与队列-等价表达式（数据结构基础 第3周））。然后可以由中缀和后缀构建出整棵树（二叉树基础-由中根序列和后根序列重建二叉树（数据结构基础 第5周））。后缀表达式可直接带入数值进行等式计算。 详情参考：http://blog.csdn.net/u014391294/article/deta
栈&二叉树-表达式·表达式树·表达式求值
w112348的博客
10-31 1668
总时间限制: 1000ms 内存限制: 65535kB 描述 众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b*c，可以表示为如下的表达式树： + / \ a * / \ b c 现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的形式输出出来。 输入 输入分为三个部分。 第一部分为一行，即中缀表达式(长度不大于50)。中缀表达式可能含有小写字母代表变量（a-z），也可能含有运...
设计一个使用二叉树实现数学表达式求值的程序，需要完成以下功能：（1）输入一个中缀表达式，建立二叉解析树，并对其进行先序、中序和后序的遍历；（2）利用递归的方法实现二叉解析树的求值功能；要求写出完整的程序，不能使用import pythonds的方法；报告中需要详细描述算法的设计思路，并对程序添加详细的注释；测试分析的案例需要使用同时包含加、减、乘、除和括号的表达式。
06-01
好的，我会尽力回答你的问题。首先，我们需要了解中缀表达式的求值流程。中缀表达式是常见的数学表达式，例如 2 + 3 * 4，但是计算机并不...以上就是使用二叉树实现数学表达式求值的算法和代码实现，希望对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值