【数据结构】实验报告10 顺序、链式存储结构的二叉树递归遍历、层次遍历求高度

一、实验目的和要求（源码在最后）

要求：
两种及以上存储结构（建议顺序存储结构和链式存储结构各一）、两种及以上方法（建议递归遍历和层次遍历方法各一）。分析各代码性能。
抽象数据类型（二叉树）独立模块实现。
其它要求同作业-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;}