一、实验目的和要求 （源码在最后）
要求：
两种及以上存储结构（建议 顺序存储结构和链式存储结构各一）、两种及以上方法（建议 递归遍历和层次遍历方法各一）。分析各代码性能。
抽象数据类型（二叉树）独立模块实现。
其它要求同作业-01要求。
二、实验环境
软件环境：visual stdio 2017
硬件环境：①CPU：Intel（R）Core（TM）i7-8565U CPU @1.80Ghz
②内存：8.0GB
三、实验内容
设计算法并实现求解二叉树高度（深度）。
四、实验过程
4.1 任务定义和问题分析
本次实验需要解决的问题主要为一下三个问题：数据结构的构建，递归遍历的实现，层次遍历的实现。
4.2 数据结构的选择和概要设计
方案一：
顺序存储结构，用一个数组记录二叉树结点值，数组下标记录二叉树编号（下标从1开始用）。递归遍历直接递归，层次遍历直接按层以编号顺序将编号与值一并输出。最终求得高度。
方案二：
链式存储结构，用结构体记录二叉树各结点。递归遍历直接递归，层次遍历以队列为辅助工具，不断入队，出队，达到层次遍历的目的。最终求得高度。
4.3 详细设计
方案一：
①数据结构的构建：
设计成一个class,其中负责记录结点值的数组，其下标为1记录根值，一般的，对于整数i，第2i位（如果存在）为第i位左子结点，2i+1位（如果存在）为第i位右子结点。
②递归遍历的实现：
设计一个递归函数，传入参数为结点标记值i（缺省值为1）其终止条件为：第i位对应结点不存在，返回0。其他情况每次返回各子树的左子树长度和右子树长度的最大值+1。
int GetlengthByRecursion(int i = 1)
{
if (i > totalnum || array[i] == ' ') return 0;
return max(GetlengthByRecursion(2 * i), GetlengthByRecursion(2 * i + 1)) + 1;
}
③层次遍历的实现：
循环输出各层，即输出各层数组值,同时得到二叉树的高度。
方案二：
①数据结构的构建：
设计成一个struct，内有data记录结点值，leftson指针作为左儿子结点指针，rightson指针作为右儿子结点指针。
②递归遍历的实现：
设计一个递归函数，思路同方案一。
③层次遍历的实现：
先定义好一个队列（同样采用链式结构），该队列用来作为二叉树结点的储存结构。先让根结点入队，之后进入一个循环：以len记录当前队列长度，再次进入循环：循环从1->len,队列头元素出队，记为node，输出node结点的数据，再将node的左儿子、右儿子依次入队。
这样，一个大循环中的小循环便是以层的形式，输出一个二叉树。每进行一次这样的循环，二叉树的高度便+1。
五、测试及结果分析
5.1 实验数据
以该二叉树来测试算法是否有效。
5.2 结果及分析
（中序遍历，先序遍历，后序遍历，这些是实验中的中间产物，保留下来，没有去除）
实验后分析：在采用顺序结构存储二叉树时，具有明显的问题：若二叉树不是完全二叉树形式，为了保持结点之间的关系，不得不空出许多元素来，这就造成了空间的浪费。在极端情况下，仅有n个结点的二叉树，却需要2^n-1个元素空间，这显然是不能接受的。顺序存储结构的优点在于其遍历较快，当然，这也需要在二叉树是完全二叉树时才能体现出来。
而链式存储结构，我们不需要关心二叉树是否为完全二叉树，因为链式存储结构本身的递归特性，其对每一个结点的操作都是相同的。
因此，我认为，在建立一般的二叉树时采用链式结构较为方便，建立完全二叉树时采用顺序存储结构更为方便。
六、实验收获
通过本次实验，加深了我对二叉树的理解，让我学会了如何构建一个二叉树，同时也对顺序结构与链式结构的优缺点理解更深。编程水平也得到了一定的提升。
七、附录（源代码）
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
//顺序存储结构
template<typename T>
class SeqBT
{
public:
SeqBT(int totalnum)
{
if (totalnum > 0)
{
this->totalnum = totalnum;
array = new T[totalnum + 1];
memset(array, ' ', (totalnum + 1) * sizeof(T));
}
}
~SeqBT()
{
delete[]array;
}
void insert(int num, T data)
{
if (num <= totalnum)
array[num] = data;
}
int GetlengthByRecursion(int i = 1)
{
if (i > totalnum || array[i] == ' ') return 0;
return max(GetlengthByRecursion(2 * i), GetlengthByRecursion(2 * i + 1)) + 1;
}
int GetlengthByLevel()
{
int length = 0;
for (; pow(2.0, length+1) - 1 <= totalnum; length++)
{
cout << "第" << length + 1 << "层的元素为:";
for (int i = pow(2.0, length); i <= pow(2.0, length + 1) - 1; i++)
cout << i << ":" << array[i] << " ";
cout << endl;
}
return length;
}
private:
int totalnum;
T* array;
};
//链式存储结构
template<typename T>
struct TreeNode
{
T data;
TreeNode<T>* leftson;
TreeNode<T>* rightson;
TreeNode()
{
leftson = NULL;
rightson = NULL;
}
};
//二叉树结点链表（用于队列）
template<typename T>
struct Node
{
TreeNode<T>* data;
Node* next;
Node()
{
data = NULL;
next = NULL;
}
};
//层次遍历需要用到的队列(简单设计)
template<typename T>
class queue
{
public:
queue()
{
head = new Node<T>;
rear = head;
length = 0;
}
int getlength()
{
return length;
}
void push(TreeNode<T>* a)
{
Node<T>* s = new Node<T>;
rear->next = s;
s->data = a;
rear = s;
length++;
}
void pop(TreeNode<T>* & a)
{
Node<T>* s = new Node<T>;
s = head->next;
a = s->data;
head->next = s->next;
delete s;
if (head->next == NULL)
{
rear = head;
}
length--;
}
private:
Node<T>* head;
Node<T>* rear;
int length;
};
//中序遍历算法
template<typename T>
void Inorder(TreeNode<T>*tree)
{
if (tree == NULL) return;
if (tree->leftson != NULL)
Inorder(tree->leftson);
cout << tree->data << " ";
if (tree->rightson != NULL)
Inorder(tree->rightson);
}
//先序遍历算法
template<typename T>
void Preorder(TreeNode<T>*tree)
{
if (tree == NULL) return;
cout << tree->data << " ";
if (tree->leftson != NULL)
Preorder(tree->leftson);
if (tree->rightson != NULL)
Preorder(tree->rightson);
}
//后续遍历算法
template<typename T>
void Postorder(TreeNode<T>*tree)
{
if (tree == NULL) return;
if (tree->leftson != NULL)
Postorder(tree->leftson);
if (tree->rightson != NULL)
Postorder(tree->rightson);
cout << tree->data << " ";
}
//递归遍历求高度算法
template<typename T>
int GetlengthByRecursion(TreeNode<T>*tree)
{
if (tree == NULL)
return 0;
return max(GetlengthByRecursion(tree->leftson), GetlengthByRecursion(tree->rightson)) + 1;
}
//层次遍历求高度算法
template<typename T>
int GetlengthByLevel(TreeNode<T>* tree)
{
queue<T> Queue;
Queue.push(tree);
int length = 0;
while (Queue.getlength()!=0)
{
cout << "第" << length + 1 << "层元素:";
int len = Queue.getlength();
for (int i = 1; i <= len; i++)
{
TreeNode<T>* node;
Queue.pop(node);
cout << node->data << " ";
if (node->leftson != NULL) Queue.push(node->leftson);
if (node->rightson != NULL) Queue.push(node->rightson);
}
cout << endl;
length++;
}
return length;
}
int main()
{
//顺序存储结构的二叉树的创建
cout << "顺式存储结构：" << endl;
SeqBT<char> sequenceBT(15);
sequenceBT.insert(1, 'A');
sequenceBT.insert(2, 'B');
sequenceBT.insert(3, 'E');
sequenceBT.insert(4, 'C');
sequenceBT.insert(5, 'D');
sequenceBT.insert(7, 'F');
sequenceBT.insert(14, 'G');
//递归遍历
cout << "递归遍历求高度:" << endl;
cout << sequenceBT.GetlengthByRecursion() << endl;
//层次遍历
cout << "层次遍历求高度:" << endl;
cout << sequenceBT.GetlengthByLevel();
for (int i = 0; i <= 4; i++) cout << endl;
//链式存储结构的二叉树的创建
cout << "链式存储结构：" << endl;
TreeNode<char>A, B, C, D, E, F, G;
A.data = 'A';
B.data = 'B';
C.data = 'C';
D.data = 'D';
E.data = 'E';
F.data = 'F';
G.data = 'G';
A.leftson = &B;
A.rightson = &E;
B.leftson = &C;
B.rightson = &D;
E.rightson = &F;
F.leftson = &G;
TreeNode<char>*root = &A;
//中序遍历
cout << "中序遍历：";
Inorder(root);
cout << endl;
//先序遍历
cout << "先序遍历：";
Preorder(root);
cout << endl;
//后序遍历
cout << "后序遍历：";
Postorder(root);
cout << endl;
//递归遍历
cout << "递归遍历求得高度为：";
cout << GetlengthByRecursion(root) << endl;
//层次遍历
cout << "对二叉树进行层次遍历并得到高度：" << endl;
cout << GetlengthByLevel(root) << endl;
}