《数据结构与算法》实验报告——二叉树的遍历
《数据结构》实验报告
| 学号： 2018329621200 |
机房号 10-414 |
姓名： 申屠志刚 |
| 日期： 2019/11/4 |
程序名： main.cpp |
|
| 实验内容： 二叉树的遍历 |
||
一、目的和要求（需求分析）：
1、掌握二叉树的存储结构以及二叉树的建立和操作。
2、输入一串表达式后，建立二叉树，并对其进行先序、中序和后序的遍历。
（输入表达式如此形式：a+b*c-d-e/f….；以#号结束。）
3、递归实现表达式运算。
二、程序设计的基本思想，原理和算法描述：
1、输入中缀表达式；
2、中缀表达式转化后缀表达式；
3、后缀表达式转化后缀表达式树；
4、递归实现表达式运算。
三、调试和运行程序过程中产生的问题及采取的措施：
1、中缀表达式建立表达式树比较繁琐；
措施：中缀表达式先转化后缀表达式；
2、判断存在括号的情况；
措施：利用栈；
3、多位数字的情况；
措施：atof函数。
四、源程序及注释：
Main.cpp
/*
*@Author: STZG
*@Language: C++
*/
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAX 100
//树结点的设计
typedef struct node
{
//数字和运算符
union{
char op;
int data;
};
struct node *lchild;
struct node *rchild;
}TreeNode;
//树栈的设计
typedef struct
{
TreeNode *buf[MAX];
int n;
}TreeStack;
//创建空栈
TreeStack *create_empty_stack()
{
TreeStack *pstack;
pstack = (TreeStack *)malloc(sizeof(TreeStack));
pstack->n = -1;
return pstack;
}
//入栈
int push_stack(TreeStack *p,TreeNode *data)
{
p->n ++;
p->buf[p->n] = data;
return 0;
}
//出栈
TreeNode *pop_stack(TreeStack *p)
{
TreeNode *data;
data = p->buf[p->n];
p->n --;
return data;
}
//判断空栈
int is_empty_stack(TreeStack *p)
{
if(p->n == -1)
{
return 1;
}else{
return 0;
}
}
//后缀表达式树的创建
TreeNode *create_express_tree(char *str,TreeStack *p)
{
int i = 0;
char dst[100];
TreeNode *current;
TreeNode *left,*right;
int len=strlen(str);
while(str[i])
{
if(str[i] == ' ')
{
i ++;
continue;
}
if(isdigit(str[i]))
{
sscanf(str+i,"%s",dst);
current = (TreeNode *)malloc(sizeof(TreeNode));
current->data = atof(dst);
current->lchild = current->rchild = NULL;
push_stack(p,current);
while (i+1 < len && isdigit(str[i+1])){++i;}
}else{
current = (TreeNode *)malloc(sizeof(TreeNode));
current->op = str[i];
right = pop_stack(p);
left = pop_stack(p);
current->lchild = left;
current->rchild = right;
push_stack(p,current);
}
/*
printf("%s\n",str);
if(current!=NULL)
printf("%d or %c\n",current->data,current->data);
*/
i ++;
}
return p->buf[p->n];
}
//打印结点
void print_node(TreeNode *p)
{
if(p->lchild == NULL && p->rchild == NULL)
{
printf("%d ",p->data);
}else{
printf("%c ",p->op);
}
return;
}
//访问结点
int vist_node(TreeNode *p)
{
print_node(p);
return 0;
}
//树的后序遍历
int PostOrder(TreeNode *p)
{
if(p != NULL)
{
PostOrder(p->lchild);//左
PostOrder(p->rchild);//右
vist_node(p);//根
}
return 0;
}
//树的中序遍历
int InOrder(TreeNode *p)
{
if(p != NULL)
{
InOrder(p->lchild);//左
vist_node(p);//根
InOrder(p->rchild);//右
}
return 0;
}
//树的前序遍历
int PreOrder(TreeNode *p)
{
if(p != NULL)
{
vist_node(p);//根
PreOrder(p->lchild);//左
PreOrder(p->rchild);//右
}
return 0;
}
char stack[500]; //定义顺序栈，其中top==0表示栈为空；
int top; //栈顶指针，为0表示栈为空；
char output[500], input[500]; //波兰式
int outLen;
int priority(char op) //判断运算符级别函数；其中* /的级别为2，+ -的级别为1；
{
if (op=='+' || op=='-')
return 1;
if (op=='*' || op=='/')
return 2;
else
return 0;
}
bool isOperator(char op) //判断输入串中的字符是不是操作符，如果是返回true
{
return (op=='+' || op=='-' || op=='*' || op=='/');
}
void rePolish(char *s,int len) //将一个中缀串转换为后缀串，
{
memset(output,'\0',sizeof output); //输出串
outLen = 0;
for (int i=0; i < len; ++i) //1）求输入串的逆序。
{
if (isdigit(s[i])) //经验见:http://blog.csdn.net/linraise/article/details/18566319#comments
{
output[outLen++] = s[i]; //3）假如是操作数，把它添加到输出串中。
while (i+1 < len && isdigit(s[i+1]))
{
output[outLen++] = s[i+1];
++i;
}
output[outLen++] = ' '; //空格隔开
}
if (s[i]=='(') //4）假如是闭括号，将它压栈。
{
++top;
stack[top] = s[i];
}
while (isOperator(s[i])) //5)如果是运算符，执行算法对应操作；
{
if (top==0 || stack[top]=='(' || priority(s[i]) > priority(stack[top])) //空栈||或者栈顶为)||新来的元素优先级更高
{
++top;
stack[top] = s[i];
break;
}
else
{
output[outLen++] = stack[top];
output[outLen++] = ' ';
--top;
}
}
if (s[i]==')') //6）假如是开括号，栈中运算符逐个出栈并输出，直到遇到闭括号。闭括号出栈并丢弃。
{
while (stack[top]!='(')
{
output[outLen++] = stack[top];
output[outLen++] = ' ';
--top;
}
--top; // 此时stack[top]==')',跳过)
}
//7）假如输入还未完毕，跳转到步骤2。
}
while (top!=0) //8）假如输入完毕，栈中剩余的所有操作符出栈并加到输出串中。
{
output[outLen++] = stack[top];
output[outLen++] = ' ';
--top;
}
}
double OP(double op1,double op2,char op)
{
double res = 0;
if (op=='+')
res = op1 + op2;
else if (op=='-')
res = op1 - op2;
else if (op=='*')
res = op1 * op2;
else if (op=='/')
res = op1 / op2;
return res;
}
double cSt1[200];
//波兰式的计算
double CalOrder(char *s) //波兰式需要用两个栈，逆波兰式只需要一个栈
{
char dst[80];
int top1=0, i;
for (i=0; s[i]; ++i)
{
if (s[i] && s[i] != ' ')
{
sscanf(s+i,"%s",dst);
if (isdigit(dst[0]))
{
++top1;
cSt1[top1] = atof(dst); //进栈
}
else
{
cSt1[top1-1] = OP(cSt1[top1-1], cSt1[top1], dst[0]);
// memcpy(cSt1[top1-1],DstBuf,sizeof DstBuf);
--top1; //操作数栈：出栈俩，进栈一
}
while (s[i] && s[i] != ' ')
++i;
}
}
return cSt1[1];
}
//树的计算
double CalOrder(TreeNode *p)
{
if(p->lchild != NULL&&p->rchild != NULL)
{
return OP(CalOrder(p->lchild) ,CalOrder(p->rchild), p->op);
}
return p->data;
}
int main()
{
TreeNode *thead;
TreeStack *pstack;
int i = 0;
while((input[i++] = getchar()) != '\n' && i < 100);
input[i-1] = 0;
printf("%s\n",input);
rePolish(input, strlen(input));
output[outLen-1] = '\0';
pstack = create_empty_stack();
thead = create_express_tree(output,pstack);
printf("PostOrder:: ");
PostOrder(thead);
printf("\n");
printf("InOrder:: ");
InOrder(thead);
printf("\n");
printf("PreOrder:: ");
PreOrder(thead);
printf("\n");
printf("CalOrder::");
printf("%f",CalOrder(output));
printf("\n");
printf("CalOrder::");
printf("%f",CalOrder(thead));
printf("\n");
return 0;
}
五、运行输出结果：
六、心得与体会：
1、掌握二叉树的存储结构以及二叉树的建立和操作。
2、输入一串表达式后，建立二叉树，并对其进行先序、中序和后序的遍历。
3、递归实现表达式运算。
4、理论上来讲, 一个中缀表达式是不能够转换出一个唯一的二叉树的,但是中缀算术表达式因为有运算符的优先级关系, 建立二叉树时, 需要所有的操作数都在叶子节点上, 所有的操作符都在父(根)节点上, 这个特征可以生成一个唯一的二叉树。
5、atof函数的运用。