课程名称：数据结构

实验项目名称：二叉树基本操作的实现

实验目的：

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;
}