二叉树的应用----表达式树

最新推荐文章于 2023-11-30 22:14:33 发布
最新推荐文章于 2023-11-30 22:14:33 发布
阅读量321 收藏 2
点赞数 2
分类专栏： 树 二叉树 文章标签： 二叉树 表达式树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43212582/article/details/101220713
版权

文章目录

何为表达式树

1
上图 1 ^1 1就是一个表达式树（手动滑稽）
下面我会给出把中缀表达式（字符串）转化成表达式树的代码

表达式树实现

作为二叉树的一个应用，这里就用二叉树这种数据结构来实现~

这里有一个重要的知识点，在利用指针实现的二叉树中，叶节点（叶结点）与非叶节点是否使用相同的定义十分重要。使用相同的类可以简化实现，但是可能导致空间上的浪费。

有一些应用只需要叶结点存储数据，还有一些应用要求分支结点（非叶节点）与叶结点存储不同类型的数据。
代码（1） 2 ^2 2用同样的方式实现叶子节点和非叶节点
代码（2） 2 ^2 2用不同的方式实现叶子节点和非叶节点

（感觉（1）不好理解的话可以先看（2））

（1）

// Node implementation with simple inheritance
class VarBinNode { // Node  base class基类
public:
virtual ˜VarBinNode() {}
virtual bool isLeaf() = 0; // Subclasses must implement
};
class LeafNode : public VarBinNode { // Leaf node叶子结点
private:
Operand var; // Operand value
public:
LeafNode(const Operand& val) { var = val; } // Constructor
bool isLeaf() { return true; } // Version for LeafNode
Operand value() { return var; } // Return node value
};
class IntlNode : public VarBinNode { // Internal node非叶子结点
private:
VarBinNode* left; // Left child
VarBinNode* right; // Right child
Operator opx; // Operator value
public:
IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r)
{ opx = op; left = l; right = r; } // Constructor

bool isLeaf() { return false; } // Version for IntlNode

VarBinNode* leftchild() { return left; } // Left child

VarBinNode* rightchild() { return right; } // Right child

Operator value() { return opx; } // Value

};
void traverse(VarBinNode *root) { // Preorder traversal
if (root == NULL) return; // Nothing to visit

if (root->isLeaf()) // Do leaf node
cout << "Leaf: " << ((LeafNode *)root)->value() << endl;

else { // Do internal node

cout << "Internal: "

<< ((IntlNode *)root)->value() << endl;

traverse(((IntlNode *)root)->leftchild());

traverse(((IntlNode *)root)->rightchild());

} }

（2）

#include<iostream>
using namespace std;
#define Operand char
#define Operator char
//Node implementation with the composite design pattern 复合设计模式
class VarBinNode {		//Node  base class  基类
public:
	virtual ~VarBinNode(){}
	virtual bool isLeaf() = 0;
	virtual void traverse() = 0;
};

class LeafNode :public VarBinNode {		//Leaf node 叶子结点
private:
	Operand var;		//Operand value 运算数

public:
	LeafNode(const Operand& val) { var = val; }
	bool isLeaf() { return true; }
	Operand value() { return var; }	//Return node value
	void traverse() {	//叶子结点的遍历
		cout << "Leaf:" << value() << endl;
	}
};

class IntlNode :public VarBinNode {	//Internal node 非叶子节点
private:
	VarBinNode* lc;		//Left child 左孩子
	VarBinNode* rc;		//Right child 右孩子
	Operator opx;		//Operator value 运算符号

public:
	IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r) {
		opx = op; lc = l; rc = r;
	}
	bool isLeaf() { return false; }
	VarBinNode* left() { return lc; }	//Return left child左孩子
	VarBinNode* right() { return rc; }	//Return right child右孩子
	Operator value() { return opx; }		//Return operator value 运算符号

	void traverse() {		//非叶子结点的遍历
		cout << "Internal:" << value() << endl;
		if (left() != NULL)left()->traverse();
		if (right() != NULL)right()->traverse();
	}
};

//Do a preorder traversal先序遍历
void traverse(VarBinNode* root) {
	if (root != NULL)root->traverse();
}

之后再用上面任意一种完成表达式树的构建 3 ^3 3（这里用（2））

#include<iostream>
using namespace std;
#define Operand char
#define Operator char
//Node implementation with the composite design pattern 复合设计模式
class VarBinNode {		//Node base class  基类
public:
	virtual ~VarBinNode() {}
	virtual bool isLeaf() = 0;
	virtual void traverse() = 0;
};

class LeafNode :public VarBinNode {		//Leaf node 叶子结点
private:
	Operand var;		//Operand value 运算数

public:
	LeafNode(const Operand& val) { var = val; }
	bool isLeaf() { return true; }
	Operand value() { return var; }	//Return node value
	void traverse() {	//叶子结点的遍历
		cout << "Leaf:" << value() << endl;
	}
};

class IntlNode :public VarBinNode {	//Internal node 非叶子节点
private:
	VarBinNode* lc;		//Left child 左孩子
	VarBinNode* rc;		//Right child 右孩子
	Operator opx;		//Operator value 运算符号

public:
	IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r) {
		opx = op;lc = l; rc = r;
	}
	bool isLeaf() { return false; }
	VarBinNode* left() { return lc; }	//Return left child左孩子
	VarBinNode* right() { return rc; }	//Return right child右孩子
	Operator value() { return opx; }		//Return operator value 运算符号

	void traverse() {		//非叶子结点的遍历
		cout << "Internal:" << value() << endl;
		if (left() != NULL)
		left()->traverse();
		if (right() != NULL)
		right()->traverse();
	}
};

//Do a preorder traversal先序遍历
void traverse(VarBinNode* root) {
	if (root != NULL)root->traverse();
}

class Expressiontree {		//表达式树
private:
	VarBinNode* Root;		//Tree root 树根
public:
	Expressiontree(Operand op) {		//Leaf constructor 叶子结点的构造函数
		Root = new LeafNode(op);
	}
	//Intlnode constructor  非叶子节点的构造函数
	Expressiontree(const Operator& op, Expressiontree* l, Expressiontree* r) {
		Root = new IntlNode(op, l->Root, r->Root);
	}
	Expressiontree(VarBinNode*& node) {
		Root = node;
	}
	void traversetree() {		//遍历表达式树
		traverse(Root);
	}
	VarBinNode* getRoot() {		//获取树根结点
		return Root;
	}
	~Expressiontree(){}
};

Expressiontree* buildtree(string s, int l, int r) {		
	//在创建树的时候，如果孩子节点为空，让它指向emptynode节点
	if (r < l)
		return NULL;
	//上面这个判断条件没有必要，因为不会出现这种情况，除非错误输入，比如只输入了: "()"或者"2+"
	int c1 = -1, c2 = -1;
	int flag = 0;
	if (r == l) {			//叶子结点
		return new Expressiontree(s[r]);
	}
	for (int i = l; i <= r; ++i) {
		if (s[i] == '(')
			++flag;
		else if (s[i] == ')')
			--flag;
		else if (s[i] == '+' || s[i] == '-') {
			if (flag == 0) {		//说明这里的加减号在括号外，可以拿来做根结点
				c1 = i;
			}
		}
		else if (s[i] == '*' || s[i] == '/') {
			if (flag == 0) {
				c2 = i;
			}
		}
	}
	if (c1 < 0)c1 = c2;	//如果括号外面没有加减号，用乘除号代替
	if (c1 < 0)return buildtree(s, l + 1, r - 1);
	Expressiontree* left = buildtree(s, l, c1 - 1);
	Expressiontree* right = buildtree(s, c1 + 1, r);
	Expressiontree* op = new Expressiontree(s[c1], left, right);
	return op;
}

void deletetree(IntlNode*tree) {		//删除表达式树，释放空间
	if (tree->left() != NULL) {
		if (tree->left()->isLeaf() == false) {
			deletetree((IntlNode*)tree->left());
		}
		else
			delete tree->left();
	}
	if (tree->right() != NULL) {
		if (tree->right()->isLeaf() == false) {
			deletetree((IntlNode*)tree->right());
		}
		else
			delete tree->right();
	}
	delete tree;
}

int main() {
	string expression = "4*x*(2*x+a)-c";
	//构建表达式树
	Expressiontree* expressiontree = buildtree(expression, 0, expression.size() - 1);
	expressiontree->traversetree();		//遍历表达式树
	deletetree((IntlNode*)expressiontree->getRoot());		//释放空间
}

然后有两个概念需要提及：

  • 前缀表达式
    它将运算符写在前面，操作数写在后面。例如，- 1 + 2 3，它等价于1-(2+3)。

  • 后缀表达式
    和前面相反，操作数在前，运算符在后，
    例如，(2+3)*5,它等价于23+5 *

接着，还是这个图，
1先序遍历（先根后左再右）就可以得到我们想要的前缀表达式

后序遍历（先左后右再根）就可以得到我们想要的后缀表达式

（2）代码 ：先序遍历结果
2
后序遍历代码：（在（2）基础上加了一个traverse2()方法）

#include<iostream>
using namespace std;
#define Operand char
#define Operator char
//Node implementation with the composite design pattern 复合设计模式
class VarBinNode {		//Node base class  基类
public:
	virtual ~VarBinNode() {}
	virtual bool isLeaf() = 0;
	virtual void traverse() = 0;	//用来先序遍历
	virtual void traverse2() = 0;	//用来后序遍历
};

class LeafNode :public VarBinNode {		//Leaf node 叶子结点
private:
	Operand var;		//Operand value 运算数

public:
	LeafNode(const Operand& val) { var = val; }
	bool isLeaf() { return true; }
	Operand value() { return var; }	//Return node value
	void traverse() {	//叶子结点的遍历
		cout << "Leaf:" << value() << endl;
	}
	void traverse2() {	//叶子结点的遍历
		cout << "Leaf:" << value() << endl;
	}
};

class IntlNode :public VarBinNode {	//Internal node 非叶子节点
private:
	VarBinNode* lc;		//Left child 左孩子
	VarBinNode* rc;		//Right child 右孩子
	Operator opx;		//Operator value 运算符号

public:
	IntlNode(const Operator& op, VarBinNode* l, VarBinNode* r) {
		opx = op;lc = l; rc = r;
	}
	bool isLeaf() { return false; }
	VarBinNode* left() { return lc; }	//Return left child左孩子
	VarBinNode* right() { return rc; }	//Return right child右孩子
	Operator value() { return opx; }		//Return operator value 运算符号

	void traverse() {		//非叶子结点的遍历
		cout << "Internal:" << value() << endl;
		if (left() != NULL)
		left()->traverse();
		if (right() != NULL)
		right()->traverse();
	}
	void traverse2() {		//非叶子结点的遍历
		if (left() != NULL)left()->traverse2();
		if (right() != NULL)right()->traverse2();
		cout << "Internal:" << value() << endl;
	}
};

//Do a preorder traversal先序遍历
void traverse(VarBinNode* root) {
	if (root != NULL)root->traverse();
}
//Do a postorder traversal后序遍历
void traverse2(VarBinNode* root) {
	if (root != NULL)root->traverse2();
}

class Expressiontree {		//表达式树
private:
	VarBinNode* Root;		//Tree root 树根
public:
	Expressiontree(Operand op) {		//Leaf constructor 叶子结点的构造函数
		Root = new LeafNode(op);
	}
	//Intlnode constructor  非叶子节点的构造函数
	Expressiontree(const Operator& op, Expressiontree* l, Expressiontree* r) {
		Root = new IntlNode(op, l->Root, r->Root);
	}
	Expressiontree(VarBinNode*& node) {
		Root = node;
	}
	void traversetree() {		//遍历表达式树，先序
		traverse(Root);
	}
	void traversetree2() {		//遍历表达式树，后序
		traverse2(Root);
	}
	VarBinNode* getRoot() {		//获取树根结点
		return Root;
	}
	~Expressiontree(){}
};

Expressiontree* buildtree(string s, int l, int r) {		
	//在创建树的时候，如果孩子节点为空，让它指向emptynode节点
	if (r < l)
		return NULL;
	//上面这个判断条件没有必要，因为不会出现这种情况，除非错误输入，比如只输入了: "()"或者"2+"
	int c1 = -1, c2 = -1;
	int flag = 0;
	if (r == l) {			//叶子结点
		return new Expressiontree(s[r]);
	}
	for (int i = l; i <= r; ++i) {
		if (s[i] == '(')
			++flag;
		else if (s[i] == ')')
			--flag;
		else if (s[i] == '+' || s[i] == '-') {
			if (flag == 0) {		//说明这里的加减号在括号外，可以拿来做根结点
				c1 = i;
			}
		}
		else if (s[i] == '*' || s[i] == '/') {
			if (flag == 0) {
				c2 = i;
			}
		}
	}
	if (c1 < 0)c1 = c2;	//如果括号外面没有加减号，用乘除号代替
	if (c1 < 0)return buildtree(s, l + 1, r - 1);
	Expressiontree* left = buildtree(s, l, c1 - 1);
	Expressiontree* right = buildtree(s, c1 + 1, r);
	Expressiontree* op = new Expressiontree(s[c1], left, right);
	return op;
}

void deletetree(IntlNode*tree) {		//删除表达式树，释放空间
	if (tree->left() != NULL) {
		if (tree->left()->isLeaf() == false) {
			deletetree((IntlNode*)tree->left());
		}
		else
			delete tree->left();
	}
	if (tree->right() != NULL) {
		if (tree->right()->isLeaf() == false) {
			deletetree((IntlNode*)tree->right());
		}
		else
			delete tree->right();
	}
	delete tree;
}

int main() {
	string expression = "4*x*(2*x+a)-c";
	//构建表达式树
	Expressiontree* expressiontree = buildtree(expression, 0, expression.size() - 1);
	expressiontree->traversetree2();		//遍历表达式树
	deletetree((IntlNode*)expressiontree->getRoot());		//释放空间
}

后序遍历结果：
3---------------------------

表达式树优化

代码优化：
在非叶节点traverse()方法中，我们看到每次递归遍历前，都要判断左右子节点是否为空，当树的深度增加时，这造成的时间开销是呈指数增长的，因此我们最好把这两个判断条件给去掉。

（不过因为这里情况特殊，即我们的表达式树一定是一个满二叉树（二元运算符肯定对应了两个操作数），所以可以大胆地去掉判断条件，不过这样还是不好，如果我们的输入出现差错，就有可能导致程序崩溃，因为使用了空指针）

优化实现

Reference

1 ^1 1《数据结构与算法分析（C++版）（第三版）》P103

2 ^2 2《数据结构与算法分析（C++版）（第三版）》P104,P105

3 ^3 3表达式树与前中后缀表达式

_kirakira_
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树与二叉树的应用⭐
weixin_44049337的博客
09-17 624
树、森林、平衡二叉树、二叉查找树、ASL/WPL、树的应用总体框架习题难题总结归纳树、森林树与二叉树的应用⭐⭐ 总体框架 习题难题总结归纳 树、森林 P167 T4 因此每次加入非叶子节点就会使得叶子数新增(k-1)个 因此m个非叶子节点 就会有 1+(k-1)m个叶子结点，而加一是非空至少有一个根结点 ①结点数最多的时候是每一个结点都向外扩展k个孩子，那么就是满k叉树，总数为=1+k+k2+k3+…kh-1=(kh-1)/(k-1) ②最少的情况就是每一层只有一个结点向外扩展k个孩子，则其他结点都是
二叉树的应用——二叉排序树、选择树、判定树
筱羊冰冰
08-05 5921
堆
表达式二叉树
12-01
程序根据后缀表达式建立二叉树，建立过程中用到了栈，并分别采取递归和非递归的方法，对二叉树进行了先序、中序、后续遍历。
表达式二叉树（简要）
YUYZHE的博客
11-13 592
数据结构课程实验c++表达式二叉树
二叉表达式树
yzd111的博客
11-30 694
这与二叉树的结构十分类似，我们可以用根节点表示运算符，使用左右子节点表示操作数，因此我们可以使用二叉树作为表达式的存储结构。对于一颗表达式二叉树，按照前，中，后三种遍历的方式分别可以得到前缀表达式，中缀表达式，后缀表达式。从右向左读取表达式，当遇到操作数时放入栈中，遇到运算符则取出栈顶的两个操作数，构建一个新的子树放入栈中。从左向右读取表达式，当遇到操作数时放入栈中，遇到运算符则取出栈顶的两个操作数，构建一个新的子树放入栈中。将取出的栈顶元素依次于 A 中的元素进行构建子树，每构建一个子树就放回 A 中。
二叉树 - 表达式二叉树（C语言）
biaogexf
04-06 1万+
问题描述：表达式可以用表达式二叉树来表示。对于简单的四则运算表达式，请实现以下功能。 （1）对于任意给出的前缀表达式（不带括号）、中缀表达式（可以带括号）或后缀表达式（不带括号），能够在计算机内部构造出一颗表达式二叉树，并且以图示显示出来（字符图或图形的形式）。 （2）对于构造好的内部表达式二叉树、按照用户的要求，输出相应的前缀表达式（不带括号）、中缀表达式（可以带括号，但不允许冗余括号）或后缀表...
二叉树-基于Objective-C的完全二叉树实现的优先队列.zip
最新发布
04-26
这种数据结构广泛应用于各种算法和数据存储中，如搜索、排序、表达式求值等。Objective-C是苹果平台上的主要编程语言，它基于C语言并加入了面向对象的特性，使得构建复杂的数据结构如二叉树更为方便。 在这个项目中...
二叉树--城市数据库.rar_数据结构 二叉树
09-24
5. **应用**：二叉树在实际问题中广泛应用，例如文件系统的目录结构、数据库索引、表达式求解、编译器的语法分析等。在本例中，二叉树被用作城市数据库的基础，可能用于存储城市的地理信息、人口统计数据、行政划分...
cpp-二叉树以及二叉排序树的实现
08-16
这些遍历方法在实际问题中有着广泛的应用，如表达式树的解析、文件系统的访问等。 接下来，我们讨论二叉排序树（Binary Search Tree，BST），它是一种特殊的二叉树。在二叉排序树中，对于任何节点，其左子树的所有...
二叉树（C语言）以及构建表达式树
06-03
二叉树的C语言实现 构建表达式树，分别前序遍历、中序遍历、后序遍历表达式树 同事在main文件中，有测试代码。
表达式求值，用二叉树
06-22
表达式求值，用二叉树来表示以后，进行遍历求解。
二叉树遍历问题-二叉树遍历问题
11-12
- 后序遍历常用于计算表达式树、释放二叉树的内存或计算某个节点的子树大小。 二叉树遍历的实现通常使用递归和迭代两种方式。递归方法直观且易于理解，但当树的深度很大时可能导致栈溢出。迭代方法则通过使用栈或...
CSP-J模拟赛：真题复现
08-02
- 树的遍历：中序遍历是二叉树遍历的一种，输出节点顺序不同。 - 排序算法：快速排序、冒泡排序、基数排序和选择排序是常见的排序算法，其中快速排序和选择排序是关键字排序。 - 递归与动态规划：递归常用于解决...
简单算术表达式二叉树的构建和求值 (数据结构)
热门推荐
Wu_yongtao的博客
12-03 1万+
简单算术表达式二叉树的构建和求值 (数据结构) 文章目录简单算术表达式二叉树的构建和求值 (数据结构)题目要求思考过程二叉树的特点思路分析代码实现运算结果总结 题目要求 先用二叉树来表示一个简单算术表达式，树的每一个结点包括一个运算符或运算数。在简单算术表达式中只包含 加 减 乘 除 和一位正整数且格式正确（不包括括号），并且要按照先乘除后加减的原则构造二叉树，下图所示为 “1+2*3-4/5” 代数表达式对应的二叉树，然后由对应的二叉树计算该表达式的值。 先用二叉树来表示一个简单算术表达式，树的每一个结
二叉树的三种遍历的应用（表达式，求深度，叶子数，结点数，二叉树的建立，复制）...
diaoyanqin5061的博客
04-02 1076
表达式的表示 如图所示的二叉树表达式：a+b*(c-d)-e/f 若先序遍历此二叉树,按访问结点的先后次序将结点排列起来,其先序序列为: (波兰式,前缀表达式) -+a*b-cd/ef 按中序遍历,其中序序列为：a+b*c-d-e/f (中缀表达式) 按后序遍历,其后序序列为：abcd-*+ef/-(逆波兰式，后缀表达式) 注：人喜欢中缀形式的算术表达式,对于计算机,...
前缀、中缀、后缀表达式（逆波兰表达式）
技术积累，技术分享
01-04 726
前缀表达式 1、什么是前缀表达式？ 前缀表达式又称为波兰表达式，前缀表达式的运算符位于操作数之前 举例说明： (3+4)×5-6对应的前缀表达式就是-×+3456 2、前缀表达式的计算机求值 从右至左扫描表达式，遇到数字时，将数字压入栈中，遇到运算符时，弹出栈顶的两个数，运算符对他们做相应的计算（栈顶元素和次顶元素），并将结果入栈；重复上述过程知道扫描至表达式的最左端，最后运算的出的结果即为表达式的结果 举例说明： 中缀表达式 1、什么时中缀表达式？ 中缀表达式就是常见的运算表达式，如(3+4)×5-6
（数据结构）简单算术表达式二叉树的构建和求值
GHY
12-08 6631
简单算术表达式二叉树的构建和求值
计算机专业英语-chapter-04.ppt
12-21
栈是一种后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等场景。队列则是一种先进先出（FIFO）的数据结构，常见于任务调度、打印队列等应用。而树是一种非线性的数据结构，能够表示层次关系，如文件系统、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值