C++面向对象实现算术表达式树

已于 2025-07-17 23:56:17 修改
阅读量242 收藏 5
点赞数 3
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ 开发语言
于 2025-07-16 21:43:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tsnotary/article/details/149371163

        C++面向对象，实现算术表达式树的案例，来源于《C++沉思录》第八章，涉及数据抽象、继承、多态（动态绑定）、句柄，其中句柄的使用是核心，关于句柄的较为简单的文章链接点击这里，较为复杂的文章链接点击这里

        一、算术表达式树的创建、打印

        表达式(-5)*(3+4)对应的树如图，包括常数、一元运算符和二元运算符的结点，结点为图中的圆圈，“边”用箭头表示，一个结点或连接一个子结点、两个子结点或不连接子结点

        结点有三种形式：表示整数表达式，包含一个整数值，无子结点，另外两个分别表示一元表达式和二元表达式包含一个操作符，分别有一个或两个子结点，三种形式对应三个类

        三个类抽象出来一个结点概念，为它们的基类，即结点类，有子结点的类用包装基类指针的句柄表示“边”，使用句柄的作用就是隐藏继承层次，动态绑定，管理内存，避免结点复制

        基类代码

//基类Expr_node
class Expr_node{
    friend class Expr; //句柄类
	//因虚函数，重载<<的友元可以不在子类声明
	friend std::ostream& operator<<(std::ostream&,const Expr&);
    int use; //计数
protected:
    Expr_node():use(1) { } //默认构造，计数1
	virtual void  print(std::ostream&) const =  0;
	virtual ~Expr_node(){} //虚析构
};

        重载<<操作符函数代码（句柄类对象引用隐藏继承层次）

std::ostream& operator<<(std::ostream& o, const Expr& t)//句柄类对象
	t.p->print(o);
	return o;
}

       三个子类代码

//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{
	friend class Expr; //句柄类
	int n;
	Int_node(int k):n(k) { } //构造
	void print(std::ostream& o) const { 
		o << n; 
	}
};

//2、一元运算符结点类
class Unary_node:public Expr_node{
	friend class Expr; //句柄类
	std::string op; //操作符
	Expr t; //句柄对象，表示"边"，指向子结点
	Unary_node(const std::string& a, Expr t):op(a),t(t) { }
	void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
};

//3、二元运算符结点类
class Binary_node: public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr right;
	Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }
	void print(std::ostream& o)const{
		o << "(" << left << op << right << ")";
	}
};

        句柄类代码（包装基类指针，动态绑定，隐藏继承层次，引用计数避免复制）

class Expr{
	friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<
	Expr_node* p; //包装基类指针
public:
	//Expr():p(nullptr){ } //默认构造//析构需要判断
	Expr(int);                            //创建一个Int_node
	Expr(const std::string&, Expr);     //创建一个Unary_node
	Expr(const std::string&, Expr, Expr); //创建一个Binary_node
	//复制管理
	Expr(const Expr&);              //复制构造
	Expr& operator=(const Expr&);   //=运算符重载
	~Expr();                        //析构，释放内存
};
//句柄类构造函数，构造其包装的基类的3个子类对象
Expr::Expr(int n)
{
	p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{
	p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{
	p = new Binary_node(op,left, right);
}
//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{
	rhs.p->use++;
	if(--p->use==0)
		delete p;
	p = rhs.p;
	return *this;
}
Expr::~Expr()
{   //有默认构造，需要判断p是否为nullptr
    //if( p && --p->use==0 )//如果为nullptr中断
	if(--p->use==0)//计数为0删除
		delete p; 
}

        句柄的使用，所有对象只构造一次，句柄的复制只是复制基类指针，对象引用计数，并不复制对象，隐藏了继承层次，管理动态内存 

        主函数测试代码

#include <iostream>
#include <string>
int main()
{
	Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );
	std:: cout << t << std::endl;
	t = Expr("*",t,t);
	std:: cout << t <<std:: endl;
	return 0;
}

        完整测试代码（这里有个小插曲，重载<<，函数体少了一个大括号，报错无法构造对象！）

#include <iostream>
#include <string>

class Expr_node;//前置声明，因为下面的类包装了Expr_node*

class Expr{
	friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<
	Expr_node* p; //包装基类指针
public:
	Expr(int);                            //创建一个Int_node
	Expr(const std::string&, Expr);       //创建一个Unary_node
	Expr(const std::string&, Expr, Expr); //创建一个Binary_node
	//复制管理
	Expr(const Expr&);              //复制构造
	Expr& operator=(const Expr&);   //=运算符重载
	~Expr();                        //析构，释放内存
};

//基类Expr_node
class Expr_node{
    friend class Expr; //句柄类
	//因虚函数，重载<<的友元可以不在子类声明
	friend std::ostream& operator<<(std::ostream&,const Expr&);
    int use; //计数
protected:
    Expr_node():use(1) { } //默认构造，计数1
	virtual void  print(std::ostream&) const =  0;
	virtual ~Expr_node(){} //虚析构
};

//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{
	friend class Expr; //句柄类
	int n;
	Int_node(int k):n(k) { } //构造
	void print(std::ostream& o) const { 
		o << n; 
	}
};

//2、一元运算符结点类
class Unary_node:public Expr_node{
	friend class Expr; //句柄类
	std::string op; //操作符
	Expr t; //句柄对象，表示"边"，指向子结点
	Unary_node(const std::string& a, Expr t):op(a),t(t) { }
	void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
};

//3、二元运算符结点类
class Binary_node: public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr right;
	Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }
	void print(std::ostream& o)const{
		o << "(" << left << op << right << ")";
	}
};

//句柄类构造函数，构造其包装的基类的3个子类对象
Expr::Expr(int n)
{
	p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{
	p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{
	p = new Binary_node(op,left, right);
}
//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{
	rhs.p->use++;
	if(--p->use==0)
		delete p;
	p = rhs.p;
	return *this;
}
Expr::~Expr()
{
	if(--p->use==0)
		delete p; 
} 
//重载运算符<<
std::ostream& operator<<(std::ostream& o,const Expr&t)
{
	t.p->print(o);
	return o;
}

int main()
{
	Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );
	std:: cout << t << std::endl;
	t = Expr("*",t,t);
	std:: cout << t <<std:: endl;
	/* ((-5)*(3+4))
	   (((-5)*(3+4))*((-5)*(3+4))) */
	
	return 0;
}

        二、算术表达式树的计算

        要实现表达式的值，要求句柄类有个计算表达式值的函数eval，句柄Expr的eval函数可以将实际工作委托给组成Expr的结点。主函数如下

#include <iostream>
#include <string>
int main()
{
	Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );
	std:: cout << t << "=" << t.eval() << std::endl;
	t = Expr("*",t,t);
	std:: cout << t << "=" << t.eval() << std::endl;
	return 0;
}

       Expr句柄类添加的eval函数，因为委托给Expr_node，所以Expr_node这个基类需要增加一个纯虚函数eval

//句柄Expr类添加的函数
int eval()const {return p->eval(); } //工作委托组成Expr的结点
//Expr_node基类添加的纯虚函数
virtual int eval()const = 0;

        三个子类的eval函数

//1、包含一个整数，没有子结点的结点类
int eval() const { return n; }
//2、一元运算符结点类
int eval()const
{
	if( op=="-" )
		return -t.eval(); //叶子结点
	throw "error, bad op " + op + " in UnaryNode";
}
//3、二元运算符结点类
int eval()const
{
	int op1 = left.eval();
	int op2 = right.eval();
	if(op=="-") return op1 - op2;
	if(op=="+") return op1 + op2;
	if(op=="*") return op1 * op2;
	if(op=="/"&&op2!=0) return op1 / op2;
	throw "error, bad op " + op + " in BinaryNode";
}

        完整测试代码

#include <iostream>
#include <string>
#include <exception>
 
class Expr_node;//前置声明，因为下面的类包装了Expr_node*
 
class Expr{
	friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<
	Expr_node* p; //包装基类指针
public:
	Expr(int);                            //创建一个Int_node
	Expr(const std::string&, Expr);       //创建一个Unary_node
	Expr(const std::string&, Expr, Expr); //创建一个Binary_node
	//复制管理
	Expr(const Expr&);              //复制构造
	Expr& operator=(const Expr&);   //=运算符重载
	~Expr();                        //析构，释放内存
	//计算
	int eval()const;//函数实际工作委托结点，受托结点不完整，需要类外定义
};
 
//基类Expr_node
class Expr_node{
    friend class Expr; //句柄类
	//因虚函数，重载<<的友元可以不在子类声明
	friend std::ostream& operator<<(std::ostream&,const Expr&);
    int use; //计数
protected:
    Expr_node():use(1) { } //默认构造，计数1
	virtual void  print(std::ostream&) const =  0; //打印，纯虚函数
	virtual ~Expr_node(){} //虚析构
	virtual int eval()const = 0; //计算，纯虚函数
};
 
//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{
	friend class Expr; //句柄类
	int n;
	Int_node(int k):n(k) { } //构造
	void print(std::ostream& o) const { 
		o << n; 
	}
	int eval() const { return n; }
};
 
//2、一元运算符结点类
class Unary_node:public Expr_node{
	friend class Expr; //句柄类
	std::string op; //操作符
	Expr t; //句柄对象，表示"边"，指向子结点
	Unary_node(const std::string& a, Expr t):op(a),t(t) { }
	void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
	int eval()const
	{
		if( op=="-" )
			return -t.eval(); //叶子结点
		throw "error, bad op " + op + " in UnaryNode";
	}
};
 
//3、二元运算符结点类
class Binary_node: public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr right;
	Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }
	void print(std::ostream& o)const{
		o << "(" << left << op << right << ")";
	}
	int eval()const
	{
		int op1 = left.eval();
		int op2 = right.eval();
		if(op=="-") return op1 - op2;
		if(op=="+") return op1 + op2;
		if(op=="*") return op1 * op2;
		if(op=="/"&&op2!=0) return op1 / op2;
		throw "error, bad op " + op + " in BinaryNode";
	}
};
 
//句柄类构造函数，构造其包装的基类的3个子类对象
Expr::Expr(int n)
{
	p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{
	p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{
	p = new Binary_node(op,left, right);
}
//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{
	rhs.p->use++;
	if(--p->use==0)
		delete p;
	p = rhs.p;
	return *this;
}
Expr::~Expr()
{
	if(--p->use==0)
		delete p; 
} 
//重载运算符<<
std::ostream& operator<<(std::ostream& o,const Expr&t)
{
	t.p->print(o);
	return o;
}
//计算
int Expr::eval()const {return p->eval(); } 
 
int main()
{
	Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );
	std:: cout << t << "=" << t.eval() << std::endl;
	t = Expr("*",t,t);
	std:: cout << t << "=" << t.eval() << std::endl;
	/* ((-5)*(3+4))=-35
	   (((-5)*(3+4))*((-5)*(3+4)))=1225 */
	return 0;
}

        三、添加子类三元运算符类

        三元运算符类代码

class Ternary_node:public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr middle;
	Expr right;	
	Ternary_node(const std::string& a, Expr b, Expr c, Expr d):
		op(a),left(b),middle(c),right(d) {  }
	void print(std::ostream& o)const;
	int eval()const;	
};

void Ternary_node::print(std::ostream& o)const
{
	o << "(" << left << "?" << middle << ":" << right << ")";
}
int Ternary_node::eval()const
{
	if(left.eval())
		return middle.eval();
	else 
		return right.eval();
}

        句柄类Expr需要添加的构造函数

Expr(const std::string& op, Expr left, Expr middle, Expr right)
{
	p = new Ternary_node(op,left,middle,right);
}

        测试完整代码

#include <iostream>
#include <string>
#include <exception>
 
class Expr_node;//前置声明，因为下面的类包装了Expr_node*
 
class Expr{
	friend std::ostream& operator<<(std::ostream&,const Expr&);//重载输出操作符<<
	Expr_node* p; //包装基类指针
public:
	Expr(int);                                 //创建一个Int_node
	Expr(const std::string&, Expr);            //创建一个Unary_node
	Expr(const std::string&, Expr, Expr);      //创建一个Binary_node
	Expr(const std::string&, Expr, Expr, Expr);//创建一个Ternary_node
	//复制管理
	Expr(const Expr&);              //复制构造
	Expr& operator=(const Expr&);   //=运算符重载
	~Expr();                        //析构，释放内存
	//计算
	int eval()const;//函数实际工作委托结点，受托结点不完整，需要类外定义
};
 
//基类Expr_node
class Expr_node{
    friend class Expr; //句柄类
	//因虚函数，重载<<的友元可以不在子类声明
	friend std::ostream& operator<<(std::ostream&,const Expr&);
    int use; //计数
protected:
    Expr_node():use(1) { } //默认构造，计数1
	virtual void  print(std::ostream&) const =  0; //打印，纯虚函数
	virtual ~Expr_node(){} //虚析构
	virtual int eval()const = 0; //计算，纯虚函数
};
 
//1、包含一个整数，没有子结点的结点类
class Int_node:public Expr_node{
	friend class Expr; //句柄类
	int n;
	Int_node(int k):n(k) { } //构造
	void print(std::ostream& o) const { 
		o << n; 
	}
	int eval() const { return n; }
};
 
//2、一元运算符结点类
class Unary_node:public Expr_node{
	friend class Expr; //句柄类
	std::string op; //操作符
	Expr t; //句柄对象，表示"边"，指向子结点
	Unary_node(const std::string& a, Expr t):op(a),t(t) { }
	void print(std::ostream& o)const{ o << "(" << op << t << ")"; }	
	int eval()const
	{
		if( op=="-" )
			return -t.eval(); //叶子结点
		throw "error, bad op " + op + " in UnaryNode";
	}
};
 
//3、二元运算符结点类
class Binary_node: public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr right;
	Binary_node(const std::string&a, Expr b, Expr c):op(a),left(b),right(c) { }
	void print(std::ostream& o)const{
		o << "(" << left << op << right << ")";
	}
	int eval()const
	{
		int op1 = left.eval();
		int op2 = right.eval();
		if(op=="-") return op1 - op2;
		if(op=="+") return op1 + op2;
		if(op=="*") return op1 * op2;
		if(op=="/"&&op2!=0) return op1 / op2;
		throw "error, bad op " + op + " in BinaryNode";
	}
};
//4、三元运算符结点类
class Ternary_node:public Expr_node{
	friend class Expr;
	std::string op;
	Expr left;
	Expr middle;
	Expr right;
	
	Ternary_node(const std::string& a, Expr b, Expr c, Expr d):
		op(a),left(b),middle(c),right(d) {  }
	void print(std::ostream& o)const;
	int eval()const;	
};

void Ternary_node::print(std::ostream& o)const
{
	o << "(" << left << "?" << middle << ":" << right << ")";
}
int Ternary_node::eval()const
{
	if(left.eval())
		return middle.eval();
	else 
		return right.eval();
}
 
//句柄类构造函数，构造其包装的基类的4个子类对象
Expr::Expr(int n)
{
	p = new Int_node(n);
}
Expr::Expr(const std::string& op, Expr t)
{
	p = new Unary_node(op,t);
}
Expr::Expr(const std::string& op, Expr left, Expr right)
{
	p = new Binary_node(op,left, right);
}
Expr::Expr(const std::string& op, Expr left, Expr middle, Expr right)
{
	p = new Ternary_node(op,left,middle,right);
}

//复制管理
Expr::Expr(const Expr& t){ p = t.p; ++p->use; }; 
Expr& Expr::operator=(const Expr& rhs)
{
	rhs.p->use++;
	if(--p->use==0)
		delete p;
	p = rhs.p;
	return *this;
}
Expr::~Expr()
{
	if(--p->use==0)
		delete p; 
} 
//重载运算符<<
std::ostream& operator<<(std::ostream& o,const Expr&t)
{
	t.p->print(o);
	return o;
}
//计算
int Expr::eval()const {return p->eval(); } 
 
int main()
{
	Expr t = Expr("*",Expr("-",5),Expr("+",3,4) );
	std:: cout << t << "=" << t.eval() << std::endl;
	t = Expr("*",t,t);
	std:: cout << t << "=" << t.eval() << std::endl;
	/* ((-5)*(3+4))=-35
	   (((-5)*(3+4))*((-5)*(3+4)))=1225 */
	t = Expr("?:",Expr("-",3,5),Expr("+",5,6),Expr("*",7,8));
	std:: cout << t << "=" << t.eval() << std::endl;
	t = Expr("?:",Expr("-",3,3),Expr("+",5,6),Expr("*",7,8));
	std:: cout << t << "=" << t.eval() << std::endl;
	/* ((3-5)?(5+6):(7*8))=11
	   ((3-3)?(5+6):(7*8))=56 */
	return 0;
}

C++ - 表达式二叉树
biaogexf
04-20 2526
问题描述与解题思路与我之前用C语言写过的博客一模一样，这里这不过是用面向对象的思想以C++语言的方式再次呈现一遍。C语言版本：点击打开链接https://blog.csdn.net/y_16041527/article/details/79835727So......这里直接上C++的完整代码头文件声明：//BinaryTree.h #include &lt;iostream&gt; const...
c++ 数据结构 表达式树算法
09-10
此程序是用C++实现的，完全用模板结构实现的。绝对是值得查阅的。
C++前中后缀表达式转表达式二叉树
05-17
选择输入前中后缀表达式，建立表达式二叉树，再前序中序后序遍历二叉树，输出三种形式的表达式
C++实现表达式树
m0_51955470的博客
11-24 1800
代码如下: #include <iostream> #include <string> #include <stack> #include <queue> using namespace std; class Tree { private: class Node { public: char val; Node * left; Node *right; Node(char val):val(val),left(nullptr),rig
C++中缀表达式建立表达式树
xdpcxq的专栏
02-02 666
/最少两个字符'@' '#' '$' '%' 与一个字母的组合。//判断是否是随机数相关的变量，格式R[P1,P2]或R[P1]//没有逗号，取一个变量的随机数。//有逗号，取两个变量间的随机数。//最少三个字符'&' 数字 与一个字母的组合。//转化为合法的范围。if (chr == '@') //自己。//inNum标记当前是否可以输入操作数。//首字符必须是字母或者数字或下划线。//首字符必须是字母或者数字或下划线。//去掉头@ # $ %//判断是否是属性相关的变量。
面向对象的C++算术表达式计算器使用指南
### 描述知识点：面向对象设计与算术表达式树的构造 描述中提到了几个关键概念： 1. **C/C++编程语言**： C和C++是两种广泛使用的编程语言，C++是C语言的一个超集，在C的基础上添加了面向对象的特性。面向对象...
C++实现算术表达式计算并封装成DLL，支持C#与C++调用
#### C++ 算术表达式算法实现 算术表达式通常表示数学计算的表达式，例如加减乘除等。在计算机程序中处理算术表达式时，需要将这些表达式转换为机器能够理解和运算的形式。后序转中序是其中一种表达式的转换算法，...
c++面向对象程序设计第三版谭浩强教学大纲.pdf
12-04
"C++面向对象程序设计第三版谭浩强教学大纲.pdf" 本资源摘要信息涵盖了C++面向对象程序设计的基本概念、数据存储、程序设计初步、函数、数组、指针、用户自定义数据类型、类和对象的程序设计等方面的知识点。 第一...
C++实现高效算术表达式求值类
在C++中实现算术表达式的求值，一般会涉及以下几个步骤： 1. **词法分析（Lexical Analysis）**：将输入的算术表达式字符串分解为一个个有意义的记号（Token），例如数字、操作符等。这一步通常由编译原理中的词法...
Windows平台下Visual C++实现算术表达式求值
Visual C++支持多种编程范式，包括面向对象编程，泛型编程，模板编程等。 3. 算术表达式求值: 算术表达式求值是指计算一个算术表达式的值。算术表达式是由数字，变量，运算符（如+，-，*，/等），以及括号组成的...
c++ 计算表达式结果（二叉树、后缀表达式）
07-26
将中缀表达式转换为二叉树、后序遍历二叉树转为后缀表达式、计算后缀表达式
表达式树Expression tree
09-27
C++实现的表达式树。测试的组合有 3 4 + 2 * 2 3 4 * + x x - a b + * x 1 * x 3 + 2 * 3 4 5 * + 3 4 5 ^ + 3 4 5 ^ % 31 x + 42 5 ^ % xcc xc - aa bb + * x 1 % x ^ 10 + 可将上面字符复制到测试文件中，文件名写死在了程序中 可实现简单的优化.
C++ 不知树系列之表达式树
最新发布
y6123236的专栏
10-20 606
得到后缀表达式后，可以直接求值，其实求值过程中已经包括了构建了树的流程，只是没有明说出来。把后缀表达式映射成二叉树，其一，可以通过结构清晰看到后缀表达式的底层逻辑，其一可以基于树的算法直观易懂得到结果。再因节点是可以是复杂数据类型，可以在遍历树的过程中封装复杂的结果。无论如何，把一个抽象的问题变得能具体描述，对于解题是大有帮助的。
C++构建算术表达式二叉树
敢于知道,
11-10 2523
#include <iostream> #include <string> using namespace std; #define MaxSize 30 //树节点信息 struct TreeNode { char val; TreeNode *left; TreeNode *right; TreeNode(char x = '\0'...
表达式树C/C++
linyuan703的博客
07-26 1157
#include &lt;bits/stdc++.h&gt; using namespace std; typedef char Element; struct Node; typedef struct Node *BTree; struct Node{     Element data;     struct Node *lchild;     struct Node *rchild; };  ...
C++实现树 - 01 树的三种表示法
Newin2020的博客
05-01 4541
写在前面： 今天我们开始进入树的学习啦，在学习高级搜索树之前，我们先看看一些简单树的实现，先理解好概念，入门就很快了。 树的定义 之前我们学习的是线性表，也就是线性的存储结构。今天我们开始学习非线性的存储结构，树就是非线性的存储结构，它可以拥有一对多的元素。 ......
表达式·表达式树·表达式求值
热门推荐
魏莘墨的专栏
12-08 1万+
/* 表达式·表达式树·表达式求值 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65535kB 描述 众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b*c，可以表示为如下的表达式树： + / \ a * / \ b c 现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的
C++——表达式树与求值
Wannna的博客
11-25 2121
为实现相关功能，创建了以下四个头文件 1.创建二叉树的头文件(BiTree.h) #pragma once #include<iostream> #include"BiTree.h" using namespace std; typedef struct BiTNode//二叉树的结构体 { char data;//数据域 string number; struct BiTNo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值