北京理工大学数据结构实验报告 简易计算器(二叉树)

数据结构实验报告三

——简易计算器（二叉树）

姓名：任子龙学号：1120140167 班级：05111451 一、需求分析

（1）问题描述

由键盘输入一算术表达式，以中缀形式输入，试编写程序将中缀表达式转换成一棵二叉表达式树，通过对该二叉树的后序遍历求出计算表达式的值。

（2）基本要求

a．要求对输入的表达式能判断出是否合法，不合法要有错误提示信息。

b．将中缀表达式转换成二叉表达式树。

c．后序遍历求出表达式的值。

（3）数据结构与算法分析

一棵表达式树，它的树叶是操作数，如常量或变量名字，而其他的结点为操作符。

a．建立表达式树。二叉树的存储可以用顺序存储也可用链式存储。当要创建二叉树时，先从表达式尾部向前搜索，找到第一个优先级最低的运算符，建立以这个运算符为数据元素的根结点。注意到表达式中此运算符的左边部分对应的二叉绔为根结点的左子树，右边部分对应的是二叉绔为根结点的右子树，根据地这一点，可用递归调用自己来完成对左右子树的构造。

b．求表达式的值。求值时同样可以采用递归的思想，对表达式进行后序遍历。先递归调用自己计算左子树所代表的表达式的值，再递归调用自己计算右子树代表的表达式的值，最后读取根结点中的运算符，以刚才得到的左右子树的结果作为操作数加以计算，得到最终结果。

（4）测试

a.加减运算

输入：6+9-5 输出：10

b.乘除运算

输入：5.6*2.7/2 输出：7.56

c.四则混合运算

输入：(2+3)*8-3/2 输出：23.5

d.非法输入

输入：（5+6（*5 输出：括号不匹配！

1.2问题分析

与之前利用栈实现计算器功能不同，本实验采取的方法是：将中缀表达式转换成一棵二叉表达式树，通过对该树的后序遍历求出计算表达式的值。所以，实验的重点是如何“将中缀表达式转换成一棵二叉表达式树”；

如上图所示，该二叉表达式树表示的是计算式（5+2）*3。可以看出，操作数均为叶子结点，其它结点为操作符；构建二叉树的整体思路是：（1）将中缀表达式转化为后缀表达式；（2）利用（1）中的后缀表达式，在此基础上构建二叉表达式树。

最后的求值，可以通过递归调用函数，后序遍历二叉树来完成。

二、概要设计

2.1抽象数据类型定义

本程序主要用到的数据结构是二叉链表，所以先行定义链表结点，其中每一个节点包含两个数据域和两个指针域，数据域分别存放char 型变量和float型变量，相对应是运算符和操作数；指针域分别指向两个左右孩子。

struct node{

char data;

float number;

struct node *left;

struct node *right;

};

另外，考虑到程序还需转换后缀表达式，所以又建立了另一种结点类型变量，并定义其类型的数组array[20]：

struct oprtnumber{

char sign; //存放符号型变量

float number; //存放浮点数

}array[20];

2.2主程序流程

主函数流程如下：

int main()

{

char *b,a[100],*t;

b=convert(); //中缀表达式转为反序后缀表达式

do

{ 完成反序后缀式的逆向；

}

T=create(T,a); //create()函数创建二叉链表

postordertraverse(T);//后序遍历进行计算

输出结果；

} //main

2.3程序模块调用关系

具体关系如下图所示：

三、详细设计

3.1主函数的具体过程

int main()

{ struct node *T;

flag=0;

T=(struct node *)malloc(sizeof(struct node));

char *b,a[100],*t;

int i; b=convert(); //中缀表达式转为反序后缀表达式

for(t=b;*t!='\0';t++);

i=0;

do

{ t--;

a[i]=*t; i++;

}

while(t!=b);

a[i]='\0';//完成反序后缀式的逆向

T=create(T,a); //create()函数创建二叉链表

postordertraverse(T);//后序遍历进行计算

printf("%g",result); //输出结果

return 0;

} //main

3.2其它函数的具体实现

char *convert();

//将运算式转换成逆后缀序列，并将该序列作为返回值；

首先输入运算式，判断是否为数字，将数字存入数组的数值域，并用符号代替数值，产生新的用符号表示的运算式。

然后用字符优先算法将算式转换为逆后缀式，将数组首地址传回给主函数。并且在输入不合法时给予错误提示。

struct node *create(struct node *T,char d[]);

//建立二叉链表，并返回根结点

void postordertraverse(struct node *e);

//进行后序遍历,运用了递归的思想，实际上调用operation函数进行计算

float operation(float a,float b,char c);

//四则运算函数，主要实现运算功能

int in(char c);

//判断是否为运算符，是运算符返回1

部分函数的代码如下：

（1）create函数

struct node *create(struct node *T,char d[])

{ //建立二叉链表，并返回根结点

int i;

if(d[w]>='A'&&d[w]<='Z')

{T->data=d[w];

for(i=0;array[i].sign!='\0';i++)

{if(array[i].sign==d[w])

{ T->number=array[i].number;break;} }

T->left=NULL; T->right=NULL; w++;

}

else{

if(flag==0)flag=1;

else

T=(struct node *)malloc(sizeof(struct node ));

(T)->data=d[w];

w++;

T->left=(struct node *)malloc(sizeof(struct node ));

T->right=(struct node *)malloc(sizeof(struct node ));

T->right=create((T)->right,d);

T->left=create((T)->left,d);

}

return T;

} //create

（2）operation函数

float operation(float a,float b,char c)

{ //四则运算函数，主要实现运算功能

switch(c) {

case '+':return a+b;

case '-':return a-b;

case '*':return a*b;

case '/':return a/b;

default :printf("运算符错误！\n"); exit(0);

} }//operation

（3）in函数

int in(char c)

{ //判断是否为运算符，是运算符返回1；否则返回0 if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')')

return 1;

else return 0;

}//in

四、调试分析

4.1难点以及困难

1.由于本次试验做过堆栈式计算器，思维存在惯性，打不开新思路；

2.建立二叉链表是最重要的环节，而在这之前，必须先得到后缀表达式，由于之前没有接触过后缀表达式，从而给变成造成了困难。即涉及char型和float型变量统一化，又有算符优先级的判别。

3.二叉链表的建立，要利用好优先级，以及注意操作数为叶子节点这一特点。

4.2经验与体会

1.算式计算的问题是一个非常经典的题目。之前用栈来实现的。但是用栈来实现是一个非常麻烦的过程，第一要解决算式判断，是否为符合规则的算式，第二要由中缀表达式转化为后缀表达式。这两个部分是栈实现计算算式表达式的比较复杂的地方。不仅如此，栈实现里面的各种运算符的优先级，各种条件判断，可以说是麻烦的要命。相比之下，用二叉树免除了算式表达式的检查过程。并不是不需要检查，而是检查的过程就包含在创建二叉树的过程。认真分析，我们会发现，所有的叶子结点必须是操作数结点，而所有的非叶子结点必须是运算符结点，否则表达式的结构一点不正确，创建二叉树的过程就可以对表达式经行检查。

2.总结一句就是：好的数据结构能事半功倍，要培养善于发现的思维，当有某个思路然后去实现它，另外要积累经验。好好理解数据结构！

五、测试结果

1.加减运算

输入：6+9-5 输出：10

2.乘除运算

输入：5.6*2.7/2 输出：7.56

3.四则混合运算

输入：(2+3)*8-3/2 输出：23.5

4.非法输入

输入：（5+6（*5 输出：括号不匹配！

六、附录

#include

#include

#include

#include

struct node{

char data;

float number;

struct node *left;

struct node *right;

};

struct oprtnumber{

char sign;

float number;

}array[20];

/*函数声明*/

char *convert();//将运算式转换成逆后缀序列

struct node *create(struct node *T,char d[]);//建立二叉链表

void postordertraverse(struct node *e);//进行后序遍历

float operation(float a,float b,char c); //四则运算函数

int in(char c);//判断是否为运算符，是运算符返回1

/*定义全局变量*/

int w,flag;

float result=0;

float operation(float a,float b,char c)

{ switch(c) {

case '+':return a+b;

case '-':return a-b;

case '*':return a*b;

case '/':return a/b;

default :printf("运算符错误！"); exit(0);

} }

struct node *create(struct node *T,char d[])

{ int i;

if(d[w]>='A'&&d[w]<='Z')

{T->data=d[w];

for(i=0;array[i].sign!='\0';i++)

{if(array[i].sign==d[w])

{ T->number=array[i].number;break;} }

T->left=NULL; T->right=NULL; w++;

}

else{

if(flag==0)flag=1;

else

T=(struct node *)malloc(sizeof(struct node ));

(T)->data=d[w];

w++;

T->left=(struct node *)malloc(sizeof(struct node ));

T->right=(struct node *)malloc(sizeof(struct node ));

T->right=create((T)->right,d);

T->left=create((T)->left,d);

}

return T;

}

char *convert()

{ w=0; char *a,*b;

bool jud(char stack[], int n);

char str[100],str1[100];

char exp[100];

char stack[100];

char ch;

int flag=1;

unsigned int zs;

int i=0,j=0,t=0,top=0,k=0,l=0;

printf(" ****************************************************** \n");

printf(" * * \n");

printf(" * 简易计算器（二叉树版）*\n");

printf(" * * \n");

printf(" ****************************************************** \n");

printf(" *使用说明* \n");

printf(" I.输入法为英文输入法\n");

printf(" II.支持小数运算，但不支持负数运算\n");

printf(" \n请输入表达式:");

scanf("%s",str1);

for(i=0;str1[i]!='\0';i++)

{b=&str1[i];

if(in(str1[i])!=1&&(i==0&&(in(str1[0])==0))||(i!=0&&in(str1[i-1])==1&&in(str1[i])==0)) {array[k].number=atof(b);

array[k].sign=k+65;

str[l]=array[k].sign;

k++;l++; }

else if(in(str1[i])==1){ str[l]=str1[i];l++;} }

array[k].sign='\0';

str[l]='\0';

i=0;k=0;l=0;

zs=strlen(str);

str[zs]='#';

ch=str[i];

while(ch!='#'){

if(ch>='A'&&ch<='Z')

{ exp[t]=ch; t++; }

else if(ch=='(')

{ top++;

stack[top]=ch;

k++; }

else if(ch=='^')

{ exp[t]=ch; t++; }

else if(ch==')') {

if(top!=0) {

if(jud(stack,top))

{

while(stack[top]!='(')

{

exp[t]=stack[top];

top--; t++; }

top--;

l++; }

else {

printf("括号不匹配!\n");

flag=0;

break;

}

}

else

{ printf("括号不匹配!\n");

flag=0;

break;

} }

else if(ch=='+'||ch=='-'){

while(top!=0&&stack[top]!='(')

{ exp[t]=stack[top];

top--;

t++; }

top++;

stack[top]=ch; }

else if(ch=='*'||ch=='/')

{ while(stack[top]=='*'||stack[top]=='/')

{ exp[t]=stack[top];

top--;

t++;

}

top++;

stack[top]=ch; }

else{ printf("第%d个数开始出错!\n",i+1);

flag=0;

break; }

i++;

ch=str[i]; }

if(k!=l) {

printf("括号不匹配!\n");

flag=0; }

else if

(str[zs-1]=='+'||str[zs-1]=='-'||str[zs-1]=='*'||str[zs-1]=='/')

{ printf("该式不是中缀表达式!\n");

flag=0; }

if(flag!=0){ while(top!=0){ exp[t]=stack[top];

t++;

top--;

}

}

exp[t]='\0';

a=&exp[0];

return a; }

bool jud(char stack[] ,int n)

{ int i;

for( i = 0;i

{ if(stack[i]=='(')

{ return true; break; }

} }

void postordertraverse(struct node *e)

{ if(e->left!=NULL&&e->right!=NULL)

if((e->left->data=='+'||e->left->data=='-'||

e->left->data=='*'||e->left->data=='/'||

e->right->data=='+'||e->right->data=='-'||

e->right->data=='*'||e->right->data=='/')||

(e->left->data>='A'&&e->left->data<='Z'&&e->right->data>='A'&&e->right->data<='Z'))

{ postordertraverse(e->left);

postordertraverse(e->right);

e->number=operation(e->left->number,e->right->number,e->data);

e->data='a';

result=e->number;

}

}

int main()

{ struct node *T;

flag=0;

T=(struct node *)malloc(sizeof(struct node));

char *b,a[100],*t;

int i; b=convert();

for(t=b;*t!='\0';t++);

i=0;

do

{ t--;

a[i]=*t; i++;

}

while(t!=b);

a[i]='\0';//完成反序后缀式的逆向

T=create(T,a); //create()函数创建二叉链表

printf("\n");

postordertraverse(T);//后序遍历进行计算

printf("%g",result); //输出结果

return 0;

}