数据结构实验：顺序存储完全二叉树先、中、后序遍历

实验内容及要求：

输入一个字符串，存储于一维数组。以该一维数组作为完全二叉树的存储结构，实现先、中、后序遍历，输出遍历结果。

将该完全二叉树转换为二叉链表存储结构，然后基于二叉链表存储结构再次进行先、中、后序遍历并输出遍历结果。

实验目的：掌握完全二叉树的顺序存储与链式存储结构以及遍历算法。

数据结构设计简要描述：

1：顺序存储：一维数组作为完全二叉树的存储结构

2：链式存储：

typedef struct BitNode{

char data; //结点的值

struct BitNode *lchild=NULL, *rchild=NULL; //左右孩子

}BitNode, *BiTree;

算法设计简要描述：

遍历二叉树算法采用递归形式。

其中根据完全二叉树的性质5设计了一维数组的递归算法。

 链表形式存储的二叉树递归算法比较直观不再描述。

输入/输出设计简要描述：

    根据提示输入一个字符串，分别输出两种存储结构下先、中、后序遍历的结果，每个字符由一个空格隔开。

输入与输出有文字提示。

代码：

//1输入一个字符串，存储于一维数组。以该一维数组作为完全二叉树的存储结构，实现先、中、后序遍历，输出遍历结果
//2将该完全二叉树转换为二叉链表存储结构，然后基于二叉链表存储结构再次进行先、中、后序遍历并输出遍历结果


#include 
#include
#define OK true
#define ERROR false
#define N 100

using namespace std;
typedef struct BitNode{
char data; //结点的值
struct BitNode *lchild=NULL, *rchild=NULL; //左右孩子
}BitNode, *BiTree;

//顺序存储
void PreTravel(char* arr, int parentindex, int len);//先序遍历的递归
void InTravel(char* arr, int parentindex, int len);//中序遍历的递归实现
void PostTravel(char* arr, int parentindex, int len);//后序遍历的递归实现
//链式存储
void visit(BiTree bt);// 访问元素（输出）
void preorder(BiTree bt);//先序
void inorder(BiTree bt);//中序
void postorder(BiTree bt);//后序
BiTree CreateTree(char* data, int i, int n);//顺序转链式
/*


*/
void trans(BiTree bit, char* arr,int len, int parentindex)//转化
{
	if (arr == NULL && len <= 0)
		return;
	BiTree bt = bit;

	if (parentindex <= len-1&& arr[parentindex]!='\0')
	{
		BiTree p1 = bt;
		bt->data = arr[parentindex];
		//cout << p1->data << " ";

		if (parentindex * 2 + 1 < len)//注意有左右孩子的时候才创建结点！！！！！！！！！！（全栽在这里！！！）
		{
        bt = new BitNode;
		p1->lchild = bt;
        trans(bt,arr, len, parentindex*2+1);
		if (parentindex * 2 + 2 < len)
		{
			bt = new BitNode;
			p1->rchild = bt;
			trans(bt, arr, len, parentindex * 2 + 2);
		}
		}

	}
}

int main()
{
	char arr[N] = { " " };
	string str{ "" };
	cout << "请输入一个字符串：" << endl;
	cin >> str;
	int len = str.length();
	int i = 0;
	//arr[0] = '0';
	for ( i = 0; i < len; i++)
	{
		arr[i] = str[i];
	}
	arr[i] = '\0';
	//
	BiTree bt = new BitNode;
	//trans(bt, arr, len, 0);
	//preorder(bt);
    //
    cout << "顺序存储： "<lchild = bt->rchild = NULL;
	bt->data = data[i];
	if (2 * i <= n && data[2 * i] != '0')
		bt->lchild = CreateTree(data, 2 * i, n);
	if (2 * i + 1 <= n && data[2 * i + 1] != '0')
		bt->rchild = CreateTree(data, 2 * i + 1, n);
	return bt;
}
void visit(BiTree bt)// 访问元素（输出）
{
	cout << bt->data<< " ";
}
void preorder(BiTree bt)//先序
{

	if (bt)
	{
		visit(bt); //访问结点
		preorder(bt->lchild); //先序访问左子树
		preorder(bt->rchild);//先序访问右子树
	}

}
void inorder(BiTree bt)//中序
{

	if (bt)
	{
		inorder(bt->lchild);
		visit(bt);
		inorder(bt->rchild);
	}
}
void postorder(BiTree bt)//后序
{
	if (bt)
	{
		postorder(bt->lchild);
		postorder(bt->rchild);
		visit(bt);
	}
}


//先序遍历的递归
void PreTravel(char* arr, int parentindex, int len)
{
	if (arr == NULL && len <= 0)
		return;
	if (parentindex <= len)
	{
		cout << arr[parentindex] << " ";
		PreTravel(arr, parentindex * 2 , len);
		PreTravel(arr, parentindex * 2 + 1, len);
	}
}


//中序遍历的递归实现
void  InTravel(char* arr, int parentindex, int len)
{
	if (arr == NULL && len <= 0)
		return;
	if (parentindex <= len)
	{
		 InTravel(arr, parentindex * 2, len);
		cout << arr[parentindex] << " ";
		 InTravel(arr, parentindex * 2 + 1, len);
	}
	else
		return;
		return;
	 InTravel(arr, 0, len);

}
//后序遍历的递归实现
void PostTravel(char* arr, int parentindex, int len)
{
	if (arr == NULL && len <= 0)
		return;
	if (parentindex <= len)
	{
		PostTravel(arr, parentindex * 2 , len);
		PostTravel(arr, parentindex * 2 + 1, len);
		cout << arr[parentindex] <<" ";
	}
}

/*
void trans(BiTree bit, char* arr,int len, int parentindex)//转化
{
	BiTree bt = bit;
	if (arr == NULL && len <= 0)
		return;
	if (parentindex <= len - 1)
	{
		BiTree p1 = bt;
		bt->data = arr[parentindex];
		//cout << p1->data << " ";


		bt = new BitNode;
		p1->lchild = bt;

		trans(bt,arr, len, parentindex*2+1);


		bt = new BitNode;
		p1->rchild = bt;

		trans(bt, arr, len, parentindex * 2 + 2);


	}
}

*/