课程名称:数据结构
实验项目名称:二叉树基本操作的实现
实验目的:
1.掌握树的基本操作—遍历。
实验要求:
1、 分别用递归和非递归的方法实现一棵树的三种遍历。
实验过程:
1、 创建一棵二叉树(二叉树如下图所示);
2、 用递归算法实现对该树的三种遍历;
3、 用非递归算法实现对该树的三种遍历;
4、 输入选项:0或1,0为递归遍历,1为非递归遍历。
5、 根据输入的选项,分别调用递归或非递归算法输出先序、中序、后序遍历序列。
实验报告中给出先序和后序遍历的非递归实现算法代码。
实验结果:
1、输入:ABD##E##CF#G###(创建二叉树)
2、输入:0(递归算法)
3、输出: 先序遍历:ABDECFG
中序遍历:DBEAFGC
后序遍历:DEBGFCA
4、输入:1(非递归实现)
5、输出: 先序遍历:ABDECFG
中序遍历:DBEAFGC
后序遍历:DEBGFCA
实验分析:
1.分析递归与非递归实现的相同点及不同点;
2.列举调试运行过程中出现的错误并分析原因。
要求:
(1) 程序要添加适当的注释,程序的书写要采用缩进格式。
(2) 程序要具在一定的健壮性,即当输入数据非法时,程序也能适当地做出反应。
(3) 程序要做到界面友好,在程序运行时用户可以根据相应的提示信息进行操作。
(4) 上传源程序到课堂派。顺序表的源程序保存为TraversalBTree.cpp。
#include <bits/stdc++.h>
using namespace std;
#define Maxsize 50
typedef char ElemType;
typedef struct BiTNode* ElemTypes;
const char* str = "ABD##E##CF#G###";
int index = 0;
//创建二叉树
typedef struct BiTNode {
ElemType data;
struct BiTNode* lchild;
struct BiTNode* rchild;
}BiTNode;
// 创建栈
typedef struct {
struct BiTNode* data[Maxsize];
int top;
}StackBiTNode;
//初始化栈
void initStack(StackBiTNode* &s) {
s = (StackBiTNode*)malloc(sizeof(StackBiTNode));
s->top = -1;
}
//入栈
void Push(StackBiTNode*& s, ElemTypes t) {
if (s->top >= Maxsize)
return;
else {
s->top++;
s->data[s->top] = t;
}
}
//出栈
void Pop(StackBiTNode*& s, ElemTypes &r) {
if (s->top == -1)
return;
else {
r = s->data[s->top];
s->top--;
}
}
// 判断栈是否为空
bool StackEmpty(StackBiTNode* s) {
return(s->top == -1);
}
// 获取栈顶元素
struct BiTNode* GetElemType(StackBiTNode* s) {
return s->data[s->top];
}
//先序遍历创建二叉树
void PreCreateBiTNode(BiTNode* &B) {
char ch = str[index++];
if (ch == '#')
B = NULL;
else {
B = (BiTNode*)malloc(sizeof(BiTNode));
B->data = ch;
PreCreateBiTNode(B->lchild);
PreCreateBiTNode(B->rchild);
}
}
//先序递归遍历二叉树
void PreOrderBiTNode(BiTNode* B) {
if (B == NULL)
return;
else {
cout << B->data;
PreOrderBiTNode(B->lchild);
PreOrderBiTNode(B->rchild);
}
}
//中序递归遍历二叉树
void MidOrderBiTNode(BiTNode* B) {
if (B == NULL)
return;
else {
MidOrderBiTNode(B->lchild);
cout << B->data;
MidOrderBiTNode(B->rchild);
}
}
//后序遍历递归实现
void PostOrderBiTNode(BiTNode* B) {
if (B == NULL)
return;
else {
PostOrderBiTNode(B->lchild);
PostOrderBiTNode(B->rchild);
cout << B->data;
}
}
//先序遍历非递归实现
void PreOrderBiTNode1(BiTNode* B) {
StackBiTNode* S;
struct BiTNode* e;
initStack(S);
Push(S, B);
while (!StackEmpty(S)) {
Pop(S, e);
B = e;
cout << e->data;
if (B->rchild) {
Push(S, B->rchild);
}
if (B->lchild) {
Push(S, B->lchild);
}
}
}
//中序遍历非递归
BiTNode* GoForBiTNode(BiTNode* B, StackBiTNode* S) {
if (!B)
return NULL;
while (B->lchild) {
Push(S, B);
B = B->lchild;
}
return B;
}
void MidOrderBiTNode1(BiTNode* B) {
StackBiTNode *S;
initStack(S);
struct BiTNode* e;
BiTNode* t = GoForBiTNode(B, S);
while (t) {
cout << t->data;
if (t->rchild) {
t = GoForBiTNode(t->rchild, S);
}
else if (!StackEmpty(S)) {
Pop(S, e);
t = e;
}
else {
t = NULL;
}
}
}
//后序遍历递归实现
void PostOrderBiTNode1(BiTNode* B) {
StackBiTNode *S;
struct BiTNode* e;
initStack(S);
bool flag;
BiTNode* p, * r;
p = B;
do {
while (p != NULL) {
Push(S, p);
p = p->lchild;
}
r = NULL;
flag = true;
while (!StackEmpty(S) && flag) {
p = GetElemType(S);
if (p->rchild == r) {
cout << p->data;
Pop(S, e);
p = e;
r = p;
}
else {
p = p->rchild;
flag = false;
}
}
} while (!StackEmpty(S));
cout << endl;
}
int main() {
StackBiTNode* s;
BiTNode* B;
initStack(s);
PreCreateBiTNode(B); //创建二叉树
cout <<"请输入您的选择 0 或者 1 ,0 代表递归遍历,1 代表非递归遍历"<<endl;
int op;
cin >>op;
while(op!=0&&op!=1)
{
cout <<"请输入正确的选择指令:" ;
cin >>op;
}
if(op==0)
{
cout << "*************__二叉树递归遍历__*****************"<<endl;
cout << "先序遍历:";
PreOrderBiTNode(B);
cout << endl;
cout << "中序遍历:";
MidOrderBiTNode(B);
cout << endl;
cout << "后序遍历:";
PostOrderBiTNode(B);
cout << endl;
}
else
{
cout << "*************__二叉树非递归遍历__*****************" << endl;
cout << "先序遍历:";
PreOrderBiTNode1(B);
cout << endl;
cout << "中序遍历:";
MidOrderBiTNode1(B);
cout << endl;
cout << "后序序遍历:";
PostOrderBiTNode1(B);
cout << endl;
}
system("pause");
return 0;
}