二叉树应用——计算表达式

最新推荐文章于 2023-03-22 09:00:00 发布
最新推荐文章于 2023-03-22 09:00:00 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： Data Structure 文章标签： tree class null delete string 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkay_wong/article/details/6644579
版权

由于时间比较匆忙，只实现了计算单个数字的，计算有十位或者更高位的还没去实现，之前用栈做的就可以，这里用二叉树做的，一开始把数据定为char类型，所以后来也就没去改它，就先实现了只有个位数的情况下的表达式的计算，更高位的表达式的计算，就是将数据的类型定位string类型，然后在数字组装和压栈的时候改些东西就好，这次由于重点是通过输入一个表达式，并建立起相对应的表达树，所以那里不想去深究。下面是代码，运算符号的优先级的判断，是用了栈的的结构特点，下一篇日记会贴出，只有栈和数组实现的表达式的计算，那个可以计算高位。

文件“tree.h”

#include<iostream>
#include<string>
#include<ctype.h>
using namespace std;

template<class T>
class My_stack;

template<class T>
class Node		//结点类
{
private:
	T data;
	Node<T> *next;
public:
	Node()
	{
		next=NULL;
	}
	Node(T d)
	{
		data=d;
		next=NULL;
	}
	friend My_stack<T>;
};

template<class T>
class My_stack
{
private:
	Node<T> *head;
public:
	My_stack()
	{
		head=new Node<T>();
	}
	
	~My_stack()
	{
		clean();
		delete head;
	}

	bool empty() const
	{
		return (head->next==0);
	}

	int size() const
	{
		int length=0;
		Node<T> *p=head->next;
		while(p)
		{
			length++;
			p=p->next;
		}
		return length;
	}

	void push(T d)	//入栈
	{
		Node<T> *p=new Node<T>(d);
		p->next=head->next;
		head->next=p;
	}

	T top()	//返回栈顶元素
	{
		if(empty())
		{
			cout<<"stack is empty."<<endl;
			exit(1);
		}
		Node<T> *p=head->next;
		T temp=p->data;
		return temp;
	}

	void pop()	//弹出栈顶元素
	{
		Node<T> *p=head->next;
		head->next=p->next;
		delete p;
	}

	void clean()	//清除整个栈
	{
		Node<T> *p=head->next;
		while(p)
		{
			head->next=p->next;
			delete p;
			head->next=p;
		}
	}
};

class BinTree;

class BinNode 
{
private:
	char data;
	BinNode *lchild;
	BinNode *rchild;
	friend BinTree;
};

class BinTree
{
private:
	BinNode *root;
	int pos;
	char str[255];
public:
	BinTree()
	{
		root=0;
		pos=0;
		str[0]='\0';
	}

	BinNode *Get_Root()
	{
		return root;
	}

	char *Get_str()
	{
		str[pos]='\0';
		return str;
	}

	void Create_Expression_Tree(BinNode *&r)	//建表达树
	{
		My_stack<char> digit;//暂存数字
		My_stack<char> opetor;//暂存操作符
		My_stack<BinNode *> node;//暂存结点
		
		char str[255];
		cout<<"输入表达式：";
		cin>>str;
		int i=0;
		char a,b;
		BinNode *p1,*p2,*p3;

		while(str[i]!='\0')
		{
			if(isdigit(str[i]))
			{
				digit.push(str[i]);
			}
			else
			{
				switch(str[i])
				{
				case '(': opetor.push(str[i]); break;
				case '*':
				case '/':
					if( !opetor.empty() && ( opetor.top()=='*' || opetor.top()=='/' ) )
					{
						p1=new BinNode;
						if(!opetor.empty())
						{
							p1->data=opetor.top();
							opetor.pop();
						}
						else
							cout<<"operator stack is empty"<<endl;
						if(!digit.empty()) //当数字栈中还有数字时
						{
							a=digit.top();
							digit.pop();
							p2=new BinNode;
							p2->data=a;
							p2->lchild=p2->rchild=0;
							if(!digit.empty())
							{
								b=digit.top();
								digit.pop();
								p3=new BinNode;
								p3->data=b;
								p3->lchild=p3->rchild=0;
								p1->lchild=p3;
								p1->rchild=p2;
							}
							else
							{
								if(!node.empty())
								{
									p3=new BinNode;
									p3=node.top();
									node.pop();
								}
								p1->lchild=p3;
								p1->rchild=p2;
							}
							node.push(p1);
						}
						else//当数字栈为空时，运算符号是作为两个式子运算结果的运算
						{
							p2=node.top();
							node.pop();
							p3=node.top();
							node.pop();
							p1->lchild=p3;
							p1->rchild=p2;
							node.push(p1);
						}
						opetor.push(str[i]);
					}
					else
						opetor.push(str[i]);
					break;
				case '+':
				case '-':
					while( (!opetor.empty()) && (opetor.top()!='(') )//加减的运算优先级最低，在他之前的所以运算符号都要出栈
					{
						p1=new BinNode;
						p1->data=opetor.top();
						opetor.pop();
						if(!digit.empty())
						{
							a=digit.top();
							digit.pop();
							p2=new BinNode;
							p2->data=a;
							p2->lchild=p2->rchild=0;
							if( !digit.empty() )
							{
								b=digit.top();
								digit.pop();
								p3=new BinNode;
								p3->data=b;
								p3->lchild=p3->rchild=0;
								p1->lchild=p3;
								p1->rchild=p2;
							}
							else
							{
								if(!node.empty())
								{
									p3=new BinNode;
									p3=node.top();
									node.pop();
								}
								p1->lchild=p3;
								p1->rchild=p2;
							}
							node.push(p1);
						}
						else
						{
							p2=node.top();
							node.pop();
							p3=node.top();
							node.pop();
							p1->lchild=p3;
							p1->rchild=p2;
							node.push(p1);
						}
					}
					opetor.push(str[i]);
					break;
				case ')':
					while( !opetor.empty() && opetor.top()!='(' )
					{
						p1=new BinNode;
						p1->data=opetor.top();
						opetor.pop();
						if(!digit.empty())
						{
							a=digit.top();
							digit.pop();
							p2=new BinNode;
							p2->data=a;
							p2->lchild=p2->rchild=0;
							if(!digit.empty())
							{
								b=digit.top();
								digit.pop();
								p3=new BinNode;
								p3->data=b;
								p3->lchild=p3->rchild=0;
								p1->lchild=p3;
								p1->rchild=p2;
							}
							else
							{
								if(!node.empty())
								{
									p3=new BinNode;
									p3=node.top();
									node.pop();
								}
								p1->lchild=p3;
								p1->rchild=p2;
							}
							node.push(p1);
						}
					}
					if(!opetor.empty())
						opetor.pop();
				}
			}
			i++;
		}
		while(!opetor.empty()) //表达式扫描完以后，将剩下的运算符号栈的元素，一一取出作为双亲结点进行继续建树
		{
			p1=new BinNode;
			p1->data=opetor.top();
			opetor.pop();
			if(!digit.empty())
			{
				a=digit.top();
				digit.pop();
				p2=new BinNode;
				p2->data=a;
				p2->lchild=p2->rchild=0;
				if(!digit.empty())
				{
					b=digit.top();
					digit.pop();
					p3=new BinNode;
					p3->data=b;
					p3->lchild=p3->rchild=0;
					p1->lchild=p3;
					p1->rchild=p2;
					node.push(p1);
				}
				else
				{
					if(!node.empty())
					{
						p3=new BinNode;
						p3=node.top();
						node.pop();
					}
					p1->lchild=p3;
					p1->rchild=p2;
					node.push(p1);
				}
			}
			else
			{			
				p2=new BinNode;
				p3=new BinNode;
				p2=node.top();
				node.pop();
				p3=node.top();
				node.pop();
				p1->lchild=p3;
				p1->rchild=p2;
				r=p1;
			}	
		}
		if(node.size()==1)//运算符号栈为空后，如果node栈只剩下一个元素，那么它就是根节点
		{
			r=node.top();
			node.pop();
		}
		root=r;
		cout<<"建树完成"<<endl;
	}

	void PostOrder_Traverse(BinNode *p)  //将中缀表达式转为后缀表达式
	{
		if(p)
		{
			PostOrder_Traverse(p->lchild);
			PostOrder_Traverse(p->rchild);
			str[pos]=p->data;
			pos++;
		}
	}
	
	void Count(char *str)
	{
		My_stack<int> s;//暂存中间结果
		cout<<"__计算表达式__"<<endl;
		int i=0,a,b;
		while(str[i]!='\0')
		{
			if(isdigit(str[i]))
			{
				int q=str[i]-'0';
				s.push(q);
			}
			else
			{
				switch(str[i])
				{
				case '+':
					if(!s.empty())
					{
						a=s.top();
						s.pop();
						b=s.top();
						s.pop();
						a=a+b;
						s.push(a);
					}
					break;
				case '-':
					if(!s.empty())
					{
						a=s.top();
						s.pop();
						b=s.top();
						s.pop();
						a=b-a;
						s.push(a);
					}
					break;
				case '*':
					if(!s.empty())
					{
						a=s.top();
						s.pop();
						b=s.top();
						s.pop();
						a=a*b;
						s.push(a);
					}
					break;
				case '/':
					if(!s.empty())
					{
						a=s.top();
						s.pop();
						b=s.top();
						s.pop();
						a=b/a;
						s.push(a);
					}
				}//end_switch
			}//end_else
			i++;
		}//end_while
		a=s.top();
		s.pop();
		cout<<"计算结果为："<<a<<endl;
	}

};


测试函数"main.cpp"

#include"tree.h"

int main()
{
	BinNode *root;
	BinTree tree;

	root=tree.Get_Root();
	tree.Create_Expression_Tree(root);

	char *str;
	tree.PostOrder_Traverse(root);

	str=tree.Get_str();
	int i=0;
	while(str[i]!='\0')
	{
		cout<<str[i]<<' ';
		i++;
	}
	cout<<endl;
	
	tree.Count(str);

	return 0;
}


输入 6+5*9-7/(3+4)

生成的二叉树如下所示：

输出结果：

输入表达式：6+5*9-7/(3+4)
建树完成
5 9 * 6 + 3 4 + 7 / -
__计算表达式__
计算结果为：50
Press any key to continue

 

最近也领悟到，当你调试一段比较长的代码时，如果你静下心来，你会发现，你为了跟踪某一段代码，可以想出很多很奇怪又很简单的方法，当错误都清理完后，那种成就感也是不言而喻的

JKay_Wong
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++用二叉树表示代数表达式_表达式求值（二叉树方法/C++语言描述）（一）
weixin_30018111的博客
02-06 1482
使用二叉树对算数表达式(以下简称为表达式)进行求值，实质上是将表达式转换为二叉树，对其进行后序遍历，得到后缀表达式的同时可以求得表达式的值。转换和求值的过程也需要借助数据结构栈的帮助。二叉树数据结构需要声明2个类，二叉树节点类(BinaryTreeNode)和二叉树类(BinaryTree)，这两个类都是模板类：#ifndef BINARYTREE_H#define BINARYTREE_Htem...
3011基于二叉树的表达式求值
qq_51135645的博客
11-12 4833
描述 输入一个表达式（表达式中的数均为小于10的正整数），利用二叉树来表示该表达式，创建表达式树，然后利用二叉树的遍历操作求表达式的值。 输入 多组数据。每组数据一行，为一个表达式，表达式以‘=’结尾。当输入只有一个“=”时，输入结束。 输出 每组数据输出一行，为表达式的值。 输入样例 1 2*(2+5)= 1+2= = 输出样例 1 14 3 前言 对于这个题，我看到很多人的做法是用栈去代替递归的过程。你光用栈也能算出答案，题目让我们用二叉树算，...
数据结构基础17：二叉树应用之算术表达式求值
何哥的博客
02-01 1万+
前言：二叉树的一种应用是无歧义地表示代数、关系或逻辑表达式。在上个世纪20年代初期，波兰的逻辑学家发明了一种命题逻辑的特殊表示方法，允许从公式中删除所有括号，称之为波兰表示法。但是，与原来带括号的公式相比，使用波兰表示法降低了公式的可读性，没有得到广泛的使用。在计算机出现后，这一表示法就很有用了，特别是用于编写编译器和解释器。用户输入的待求表达式，也就是中缀表达式，对于人来说，这个很好理解，但是对...
数据结构与算法——二叉树+带你实现表达式树（附源码）
热爱编程的小K的博客
03-22 1725
数据结构与算法——无序二叉树，先中后遍历，查找，插入，思想，图解，表达式树一应具有，带你深入浅出了解二叉树
栈的应用2——中缀表达式和后缀表达式的转换
筱羊冰冰
07-17 296
中缀后缀 日常生活中，我们都是使用中缀表达式，如8*（5+3）这样的，这样的式子可以画成一个二叉树，而二叉树的遍历方式有三种，分别对应着三种表达式方式。 （感觉说多了，再说后面二叉树没东西讲了） 所以上面的式子可以写成8 5 3+ * ，虽然看着很诡异，但是要知道，对于计算机来说，看中缀表达式比看十进制难受多了（栈的应用1——数制转换），因为： 后缀表达式可以避免括号 游戏规则 在这道题里面，可以输入大小写的单字母变量，以及双目四则运算（加减乘除）还有括号，目的是将这个转换成一个后缀表达式，以去掉括号。 先
实验五——二叉树及其应用
m0_63944500的博客
12-21 218
根据两篇博客代码启发而得
栈的应用(3)——中缀表达式转后缀表达式并求值 python实现
cy15625010944的博客
04-28 1459
引言 输入运算表达式，仅由数字、+、-、*、/、()组成，没有空格，要求求其值， 中缀表达式：通常看到的表达式中，操作符介于操作数中间的表示法，如A+B,BC,A+BC(容易混淆）。为了避免混淆，引入优先级或者括号来定义顺序。(A+B)C 前缀表达式：将操作移动到前面的表示法，如+AB， * +ABC 后缀表达式：将操作移动到后面的表示法，如AB+，AB+C 因此，(A+B)*C转化为AB+C ...
二叉树在java中的应用_数据结构(Java)——二叉树的应用
weixin_42518480的博客
02-13 605
忙碌是一种幸福，让我们没时间体会痛苦；奔波是一种快乐，让我们真实地感受生活；疲惫是一种享受，让我们无暇空虚。1.表达式的二叉树求解1.1 构建表达式树表达式树扩展了LinkedBinaryTree类，提供了一个构造函数，用于把表达式树合成一棵新树，还提供了evaluate方法，用于一旦表达式树构造好之后可以对其进行递归计算。package ds.java.ch10;import ds.java.c...
【数据结构(初稿)】树和二叉树总结——基本知识要点汇总
bay_Tong桐小白的博客
07-02 6925
树和二叉树基本知识要点汇总，包括树和二叉树的基本概念、树、二叉树、森林的遍历算法、树与二叉树森林的相互联系与互相转换、二叉树线索化、哈夫曼编码、并查集等内容
二叉树应用——计算表达式[参照].pdf
10-12
二叉树应用——计算表达式计算 二叉树是一种常用的数据结构，它可以用于表示复杂的计算表达式。二叉树的结构由节点组成，每个节点都可以有左右两个子节点。这种数据结构可以用于计算复杂的表达式，因为它可以将...
利用二叉树实现多项式计算
04-14
#### 计算表达式树的值 `cal()`函数遍历整个表达式树，从叶子节点开始，逐步向上计算各节点的值。这一过程同样利用了递归的思想，确保了计算的正确性。 ### 五、综合应用 通过以上分析可以看出，本文介绍了一种...
二叉树遍历的几种方式示例
最新发布
06-10
例如，如果二叉树表示一个计算表达式，后序遍历可以按正确的顺序计算表达式的值。 这三种遍历方式均基于深度优先搜索（Depth-First Search, DFS）算法。DFS是一种在图或树中探索路径的方法，它尽可能深地搜索树的...
二叉树建立遍历
01-03
后序遍历在计算表达式树等场景中很有用。对于这个例子，后序遍历的顺序是“1,3,2,5,4”。 在`数据结构.cpp`文件中，可能包含了实现这些操作的C++代码。通常，二叉树节点会定义为一个结构体或类，包含数据域（存储...
数据结构课程设计——二叉树
03-03
这些遍历方法各有其应用场景，例如，前序遍历常用于复制二叉树，中序遍历在二叉搜索树中用于排序，后序遍历则可用于计算节点值的某种组合。 复制二叉树通常采用递归算法，对每个节点，先复制其左子树，再复制其右子...
平衡二叉树（AVL树）的基本操作（附有示意图）
热门推荐
Kay's space
08-10 2万+
平衡二叉树关于树的深度是平衡的，具有较高的检索效率。平衡二叉树或是一棵空树，或是具有下列性质的二叉排序树：其左子树和右子树都是平衡二叉树，而且左右子树深度之差绝对值不超过1. 由此引出了平衡因子（balance factor）的概念，bf定义为该结点的左子树的深度减去右子树的深度（有些书是右子树深度减去左子树深度，我是按照左子树减去右子树来计算的，下面的代码也是这样定义的），所以平衡二叉树的结点的
图的几种存储方式
Kay's space
08-05 2万+
之前几天把数据结构扔在一边，在看离散数学的图论部分，看了大部分，最后还是觉得纯数学的，有一些可能现在我刚接触图还不会觉得有什么用，所以就选择性的跳过一些，现在也决定先放下书，回到数据结构上，开始图的部分的学习。 图的存储通用的存储方式有邻接矩阵表示法、邻接表表示法。为方便有向图
Hash表（C++实现）
Kay's space
08-20 1万+
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,
求AOE网的关键路径
Kay's space
08-18 1万+
以边表示活动，以顶点表示事件的有向网称为AOE(activity on edge)网.AOE网是一个 有向无环图，权值表示活动持续的时间。可以用AOE网来估计工程完成的时间。由于工程 只有一个开始点和一个完成点，所以在无环路的条件下，网中只有一个入度为0的点和一 个出度为0
中缀表达式到二叉树转换及计算
课程设计的目标是读取一个中缀表达式，检查其合法性，将其转化为二叉树，并通过后根遍历计算表达式的值。设计要求中提到的合法表达式包括加减乘除运算符、括号、整数以及空格或制表符。 二叉树在这里起着至关重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值