国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案

合集下载

数据结构树和二叉树实验报告

实验题目
树和二叉树
小组合作
否
姓名
班级
学号
一、实验目的
(1)掌握树的相关概念,包括树、结点的度、树的度、分支结点、叶子结点、儿子结点、双亲结点、树的深度、森林等定义。
(2)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。
(3)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码产生方法。
二．实验环境
return 0;
}
假设二叉树采用二叉树链式存储结构，设计一个算法输出从根结点到每个叶子结点的路径之逆（因为树中路径是从根结点到其他结点的结点序列，就是求叶子结点及其双亲结点、该双亲结点的双亲结点，直到根结点的序列，或者说求叶子结点及其所有祖先结点的序列）。要求采用后根遍历非递归算法。
#include "stdafx.h"
AllPath1(b);
return 0;
}
设计一个算法将二叉树的顺序存储结构转换成二叉链式存储结构。
#include "stdafx.h"
#include "exam7-14.cpp"
int main(int argc, char* argv[])
{
int i,n=10;
BTNode *b;
SqBTree a;
#include "exam7-12.cpp"
int main(int argc, char* argv[])
{
BTNode *b;
CreateBTNode(b,"A(B(D(,G)),C(E,F))");
printf("b:");DispBTNode(b);printf("\n");

数据结构实验报告(四)

《数据结构》实验报告班级：学号：姓名：实验四二叉树的基本操作实验环境：Visual C++实验目的：1、掌握二叉树的二叉链式存储结构；2、掌握二叉树的建立，遍历等操作。

实验内容：通过完全前序序列创建一棵二叉树，完成如下功能：1)输出二叉树的前序遍历序列；2)输出二叉树的中序遍历序列；3)输出二叉树的后序遍历序列；4)统计二叉树的结点总数；5)统计二叉树中叶子结点的个数；实验提示：//二叉树的二叉链式存储表示typedef char TElemType;typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;一、程序源代码#include <stdio.h>#include <stdlib.h>#define MAXSIZE 30typedef char ElemType;typedef struct TNode *BiTree;struct TNode {char data;BiTree lchild;BiTree rchild;};int IsEmpty_BiTree(BiTree *T) { if(*T == NULL)return 1;elsereturn 0;}void Create_BiTree(BiTree *T){char ch;ch = getchar();//当输入的是"#"时，认为该子树为空if(ch == '#')*T = NULL;//创建树结点else{*T = (BiTree)malloc(sizeof(struct TNode)); (*T)->data = ch; //生成树结点//生成左子树Create_BiTree(&(*T)->lchild);//生成右子树Create_BiTree(&(*T)->rchild);}}void TraverseBiTree(BiTree T) { //先序遍历if(T == NULL)return;else {printf("%c ",T->data);TraverseBiTree(T->lchild);TraverseBiTree(T->rchild);}}void InOrderBiTree(BiTree T) { //中序遍历if(NULL == T)return;else {InOrderBiTree(T->lchild);printf("%c ",T->data);InOrderBiTree(T->rchild);}}void PostOrderBiTree(BiTree T) {if(NULL == T)return;else {InOrderBiTree(T->lchild);InOrderBiTree(T->rchild);printf("%c ",T->data);}}int TreeDeep(BiTree T) {int deep = 0;if(T){int leftdeep = TreeDeep(T->lchild);int rightdeep = TreeDeep(T->rchild);deep = leftdeep+1 > rightdeep+1 ? leftdeep+1 : rightdeep+1;}return deep;}int Leafcount(BiTree T, int &num) {if(T){if(T->lchild ==NULL && T->rchild==NULL){num++;printf("%c ",T->data);}Leafcount(T->lchild,num);Leafcount(T->rchild,num);}return num;}void LevelOrder_BiTree(BiTree T){//用一个队列保存结点信息,这里的队列采用的是顺序队列中的数组实现 int front = 0;int rear = 0;BiTree BiQueue[MAXSIZE];BiTree tempNode;if(!IsEmpty_BiTree(&T)){BiQueue[rear++] = T;while(front != rear){//取出队头元素，并使队头指针向后移动一位tempNode = BiQueue[front++];//判断左右子树是否为空,若为空，则加入队列 if(!IsEmpty_BiTree(&(tempNode->lchild))) BiQueue[rear++] = tempNode->lchild;if(!IsEmpty_BiTree(&(tempNode->rchild))) BiQueue[rear++] = tempNode->rchild;printf("%c ",tempNode->data);}}}int main(void){BiTree T;BiTree *p = (BiTree*)malloc(sizeof(BiTree));int deepth,num=0 ;Create_BiTree(&T);printf("先序遍历二叉树:\n");TraverseBiTree(T);printf("\n");printf("中序遍历二叉树:\n");InOrderBiTree(T);printf("\n");printf("后序遍历二叉树:\n");PostOrderBiTree(T);printf("\n层次遍历结果：");LevelOrder_BiTree(T);printf("\n");deepth=TreeDeep(T);printf("树的深度为:%d",deepth);printf("\n");printf("树的叶子结点为:");Leafcount(T,num);printf("\\n树的叶子结点个数为:%d",num);return 0;}二、运行结果(截图)三、遇到的问题总结通过死循环的部分可以看出，在判断时是不能进入结点为空的语句中的，于是从树的构建中寻找问题，最终发现这一条语句存在着问题：这里给T赋值为空，也就是给整个结构体地址赋值为空，但是我们的目的是给该结构体中的内容，即左孩子的地址指向的内容赋为空。

数据结构_二叉排序树实验报告

签名：
日期：
实验成绩：
批阅日期：
【本文档内容可以自由复制内容或自由编辑修改内容期待你的好评和关注，我们将会做得更好】
五、概要设计
为了实现上述操作，应以构造体为存储构造。实现如下：
struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
}BSTNode,*BSTree;
1、根本操作：
〔1〕struct node
{
int key;//关键字的值
struct node *lchild,*rchild;//左右指针
2、输出的形式：建立好的排序二叉树的中序遍历结果。
3、程序所能到达的功能：能够通过键盘输入建立二叉排序树，并在建立完立即在屏幕显示中序遍历结果的程序
4、测试数据：输入45 24 53 12 28 90并用空格将数隔开，以0作为完毕符，如：
输入45 24 53 12 28 90
输出的中序遍历结果为：12 24 28 45 53 90
}BSTNode,*BSTree;
void InsertBST(BSTree *bst,int key) //二叉排序树的插入结点
{
BSTree s;
if(*bst==NULL)
{
s=(BSTree)malloc(sizeof(BSTNode));
s->key=key;
s->lchild=NULL;
{
if(bt!=NULL)
{
inorder(bt->lchild);
printf("%3d",bt->key) ;
inorder(bt->rchild);

数据结构上机实验报告(二叉树染色问题)

数据结构上机实验报告题目：二叉树染色问题学生姓名：学生学号：学院名称：计算机学院专业：计算机科学与技术时间：目录第一章，需求分析31.1 原题描述31.2 详细问题的解决方案31.2.1 解决方案要求31.2.2 各个环节功能要求3第二章，概要设计52.1 抽象数据类型52.2 主要算法描述52.3 算法分析7第三章，详细设计83.1 程序代码8第四章，调试分析10第五章，测试分析11第六章，未来展望与思考12第一章需求分析1.1 原题描述一棵二叉树可以按照如下规则表示成一个由0、1、2组成的字符序列，我们称之为“二叉树序列S”：例如，下图所表示的二叉树可以用二叉树序列S=21200110来表示现在要对一棵二叉树的节点进行染色。

每个节点可以被染成红色、绿色或蓝色。

并且，一个节点与其子节点的颜色必须不同，如果该节点有两个子节点，那么这两个子节点的颜色也必须不相同。

给定一棵二叉树的二叉树序列，请求出这棵树中最多和最少有多少个点能够被染成绿色。

1.2详细问题的解决方案1.2.1 解决方案要求输入参数:输入数据由多组数据组成。

每组数据仅有一行，不超过10000个字符，表示一个二叉树序列。

输出参数：对于每组输入数据，输出仅一行包含两个整数，依次表示最多和最少有多少个点能够被染成绿色。

1.2.2 参考样例Sample Input1122002010Sample Output5 21.2.3 各个环节功能要求表1-2.1环节功能函数功能注意条件及限制规则CreatBitree() 先序建立二叉树字符’2’字符’1’字符’0’三种情况：,2，有左右子树；1，有左子树右空；0，左右子树为空PreOrder() 先序遍历二叉树以T是否为空遍历二叉树补充正文：由于只有三种颜色，可以用数字2,1,0分别表示，先序建立二叉树，将二叉树每个结点与其左孩子强行交叉赋值2与1（有右孩子的则赋予与结点和左孩子不同的值），即为按优先顺序2,1,0给节点赋值。

实验报告(二叉树)

实验报告课程：数据结构（c语言）实验名称：二叉树的构建、基本操作和遍历系别：数字媒体技术实验日期：专业班级：媒体161 组别：无：学号：实验报告容验证性实验一、预习准备：实验目的：1、熟练掌握二叉树的结构特性，熟悉二叉树的各种存储结构的特点及适用围；2、熟练掌握二叉树的遍历方法及遍历算法；3、掌握建立哈夫曼树和哈夫曼编码的方法及带权路径长度的计算。

实验环境：Widows操作系统、VC6.0实验原理：1.定义：树：树(tree)是n(n>0)个结点的有限集T，其中，有且仅有一个特定的结点，称为树的根(root)。

当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2,……Tm，其中每一个集合本身又是一棵树，称为根的子树(subtree)二叉树：二叉树是n(n>=0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成。

哈夫曼树: 最优二叉树——赫夫曼树设有n个权值{w1,w2,……wn}，构造一棵有n个叶子结点的二叉树，每个叶子的权值为wi,则wpl最小的二叉树叫Huffman树。

2. 特点：树：树中至少有一个结点——根树中各子树是互不相交的集合二叉树：每个结点至多有二棵子树(即不存在度大于2的结点)二叉树的子树有左、右之分，且其次序不能任意颠倒哈夫曼树：一棵有n个叶子结点的Huffman树有2n-1个结点采用顺序存储结构——动态分配数组存储3. 表示：遍历二叉树：先序遍历：先访问根结点,然后分别先序遍历左子树、右子树中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树后序遍历：先后序遍历左、右子树，然后访问根结点按层次遍历：从上到下、从左到右访问各结点构造Huffman 树的方法——Huffman 算法（1) 根据给定的n 个权值{w1,w2,……wn}，构造n 棵只有根结点的二叉树，令起权值为wj ；(2) 在森林中选取两棵根结点权值最小的树作左右子树，构造一棵新的二叉树，置新二叉树根结点权值为其左右子树根结点权值之和；(3) 在森林中删除这两棵树，同时将新得到的二叉树加入森林中重复上述两步，直到只含一棵树为止，这棵树即哈夫曼树。

数据结构实验报告二叉树

return s;
}
void dispbtnode1(btnode *b)
{
btnode *st[maxsize],*p;
int level[maxsize][2],top=-1,n,i,width=4;
char type;
if(b!=NULL)
{
top++;
st[top]=b;
level[top][0]=width;
level[top][0]=n+width;
level[top][1]=1;
}
if(p->lchild!=NULL)
{
top++;
st[top]=p->lchild;
level[top][0]=n+width;
level[top][1]=0;
}
}
}
}
2）先序，中序、后序遍历功能实现，因为想自己更能读懂理解程序，没有使用递归算法。
}
btnode *rchildnode(btnode *p)
{
return p->rchild ;
}
btnode * revers(btnode *b)//交换左右子树
{
if(b!=NULL)
{
if(b->rchild !=NULL||b->lchild !=NULL)
{
btn;lchild );
（3）根据二叉树的基本运算，设计先序遍历和中序遍历（或者中序遍历和后序遍历），确定二叉树的算法。
（4）在不改变原有二叉树结构的条件下，将二叉树左右孩子进行交换，并采用凹入表示法和括号表示法输出原有二叉树及交换子树后的二叉树。

数据结构实验报告4(电大)

实验报告四图的存储方式和应用（学科：数据结构）姓名单位班级学号实验日期成绩评定教师签名批改日期实验名称：实验四图的存储方式和应用4.1建立图的邻接矩阵【问题描述】根据图中顶点和边的信息编制程序建立图的邻接矩阵。

【基本要求】（1）程序要有一定的通用性。

（2）直接根据图中每个结点与其他结点的关联情况输入相关信息，程序能自动形成邻接矩阵【测试用例】【实现提示】（1）对图的顶点编号。

（2）在上图中，以顶点1为例，因为顶点2,3,4与顶点1关联，可以输入信息1 2 3 4，然后设法求出与顶点1关联的结点，从而求得邻接矩阵中相应与顶点1的矩阵元素。

实验图4-1【实验报告内容】设计程序代码如下:#include<stdio.h>#define MaxVertexNum 5#define MaxEdgeNum 20#define MaxValue 1000typedef int VertexType;typedef VertexType vexlist [MaxVertexNum];typedef int adjmatrix [MaxVertexNum] [MaxVertexNum];void Createl(vexlist Gv,adjmatrix GA,int n,int e){int i,j,k,w;printf("输入%d个顶点数据\n",n);for(i=0;i<n;i++) scanf("%d",&Gv[i]);for(i=0;i<n;i++)for(j=0;j<n;j++){if(i==j) GA[i][j]=0;else GA[i][j]=MaxValue;}Printf（“输入一条边的两端点序号i和j及边上的权w\n”）;printf("输入%d条无向带权边\n",e);for(k=1;k<=e;k++){scanf("%d%d%d",&i,&j,&w);GA[i][j]=GA[j][i]=w;}}void main(){vexlist vl;adjmatrix a;Createl(vl,a,5,8);}。

数据结构二叉树实验报告

数据结构二叉树实验报告二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。

本文将介绍二叉树的定义、基本操作以及一些常见的应用场景。

一、二叉树的定义和基本操作二叉树是一种特殊的树形结构，它的每个节点最多有两个子节点。

一个节点的左子节点称为左子树，右子节点称为右子树。

二叉树的示意图如下：```A/ \B C/ \D E```在二叉树中，每个节点可以有零个、一个或两个子节点。

如果一个节点没有子节点，我们称之为叶子节点。

在上面的示例中，节点 D 和 E 是叶子节点。

二叉树的基本操作包括插入节点、删除节点、查找节点和遍历节点。

插入节点操作可以将一个新节点插入到二叉树中的合适位置。

删除节点操作可以将一个指定的节点从二叉树中删除。

查找节点操作可以在二叉树中查找指定的节点。

遍历节点操作可以按照一定的顺序遍历二叉树中的所有节点。

二、二叉树的应用场景二叉树在计算机科学中有着广泛的应用。

下面将介绍一些常见的应用场景。

1. 二叉搜索树二叉搜索树是一种特殊的二叉树，它的每个节点的值都大于其左子树中的节点的值，小于其右子树中的节点的值。

二叉搜索树可以用来实现快速的查找、插入和删除操作。

它在数据库索引、字典等场景中有着重要的应用。

2. 堆堆是一种特殊的二叉树，它的每个节点的值都大于或小于其子节点的值。

堆可以用来实现优先队列，它在任务调度、操作系统中的内存管理等场景中有着重要的应用。

3. 表达式树表达式树是一种用来表示数学表达式的二叉树。

在表达式树中，每个节点可以是操作符或操作数。

表达式树可以用来实现数学表达式的计算，它在编译器、计算器等场景中有着重要的应用。

4. 平衡二叉树平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1。

平衡二叉树可以用来实现高效的查找、插入和删除操作。

它在数据库索引、自平衡搜索树等场景中有着重要的应用。

三、总结二叉树是一种常用的数据结构，它在计算机科学中有着广泛的应用。

本文介绍了二叉树的定义、基本操作以及一些常见的应用场景。

数据结构二叉树的实验报告

数据结构实验报告1. 实验目的和内容：掌握二叉树基本操作的实现方法2. 程序分析2.1存储结构链式存储2．程序流程2.3关键算法分析算法一：Create(BiNode<T>* &R,T data[],int i,int n)【1】算法功能：创建二叉树【2】算法基本思想：利用顺序存储结构为输入，采用先建立根结点，再建立左右孩子的方法来递归建立二叉链表的二叉树【3】算法空间时间复杂度分析：O(n)【4】代码逻辑：如果位置小于数组的长度则{ 创建根结点将数组的值赋给刚才创建的结点的数据域创建左子树，如果当前结点位置为i,则左孩子位置为2i创建右子树，如果当前结点位置为i,则右孩子位置为2i+1}否则R为空算法二：CopyTree(BiNode<T>*sR,BiNode<T>* &dR)）【1】算法功能：复制构造函数【2】算法基本思想：按照先创建根结点，再递归创建左右子树的方法来实现。

【3】算法空间时间复杂度分析：O（n)【4】代码逻辑:如果源二叉树根结点不为空则{创建根结点调用函数自身，创建左子树调用函数自身，创建右子树}将该函数放在复制构造函数中调用，就可以实现复制构造函数算法三：PreOrder(BiNode<T>*R)【1】算法功能：二叉树的前序遍历【2】算法基本思想：这个代码用的是优化算法，提前让当前结点出栈。

【3】算法空间时间复杂度分析：O（n）【4】代码逻辑（伪代码）如果当前结点为非空，则{访问当前结点当前结点入栈将当前结点的左孩子作为当前结点}如果为空{则栈顶结点出栈则将该结点的右孩子作为当前结点}反复执行这两个过程，直到结点为空并且栈空算法四：InOrder(BiNode<T>*R)【1】算法功能：二叉树的中序遍历【2】算法基本思想：递归【3】算法空间时间复杂度分析：未知【4】代码逻辑：如果R为非空：则调用函数自身遍历左孩子访问该结点再调用自身访问该结点的右孩子算法五：LevelOrder(BiNode<T>*R)【1】算法功能：二叉树的层序遍历【2】算法基本思想：【3】算法空间时间复杂度分析：O（n）【4】代码逻辑（伪代码）：如果队列不空{对头元素出队访问该元素若该结点的左孩子为非空，则左孩子入队；若该结点的右孩子为非空，则右孩子入队；}算法六：Count(BiNode<T>*R)【1】算法功能：计算结点的个数【2】算法基本思想：递归【3】算法空间时间复杂度分析：未知【4】代码逻辑：如果R不为空的话{调用函数自身计算左孩子的结点数调用函数自身计算右孩子的结点数}template<class T>int BiTree<T>::Count(BiNode<T>*R){if(R==NULL)return 0;else{int m=Count(R->lchild);int n=Count(R->rchild);return m+n+1;}}算法七：Release(BiNode<T>*R)【1】算法功能：释放动态内存【2】算法基本思想：左右子树全部释放完毕后再释放该结点【3】算法空间时间复杂度分析：未知【4】代码逻辑：调用函数自身，释放左子树调用函数自身，释放右子树释放根结点释放二叉树template<class T>void BiTree<T>::Release(BiNode<T>*R) {if(R!=NULL){Release(R->lchild);Release(R->rchild);delete R;}}template<class T>BiTree<T>::~BiTree(){Release(root);}int main(){BiTree<int> BTree(a,10);BiTree<int>Tree(BTree);BTree.PreOrder(BTree.root);cout<<endl;Tree.PreOrder(Tree.root);cout<<endl;BTree.InOrder(BTree.root);cout<<endl;Tree.InOrder(Tree.root);cout<<endl;BTree.PostOrder(BTree.root);cout<<endl;Tree.PostOrder(Tree.root);cout<<endl;BTree.LevelOrder(BTree.root);cout<<endl;Tree.LevelOrder(Tree.root);cout<<endl;int m=BTree.Count(BTree.root);cout<<m<<endl;return 0;}3.测试数据：int a[10]={1,2,3,4,5};1 2 4 5 31 2 4 5 34 25 1 34 5 2 3 11 2 3 4 554.总结：4.1:这次实验大多用了递归的算法，比较好理解。

数据结构实验报告-树(二叉树)

实验5：树（二叉树）（采用二叉链表存储）一、实验项目名称二叉树及其应用二、实验目的熟悉二叉树的存储结构的特性以及二叉树的基本操作。

三、实验基本原理之前我们都是学习的线性结构，这次我们就开始学习非线性结构——树。

线性结构中结点间具有唯一前驱、唯一后继关系，而非线性结构中结点的前驱、后继的关系并不具有唯一性。

在树结构中，节点间关系是前驱唯一而后继不唯一，即结点之间是一对多的关系。

直观地看，树结构是具有分支关系的结构（其分叉、分层的特征类似于自然界中的树）。

四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和预定义2.创建二叉树3.前序遍历4.中序遍历5.后序遍历6.总结点数7.叶子节点数8.树的深度9.树根到叶子的最长路径10.交换所有节点的左右子女11.顺序存储12.显示顺序存储13.测试函数和主函数对二叉树的每一个操作写测试函数，然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序，代码见“实验完整代码”。

实验完整代码：#include <bits/stdc++.h>using namespace std;#define MAX_TREE_SIZE 100typedef char ElemType;ElemType SqBiTree[MAX_TREE_SIZE];struct BiTNode{ElemType data;BiTNode *l,*r;}*T;void createBiTree(BiTNode *&T){ElemType e;e = getchar();if(e == '\n')return;else if(e == ' ')T = NULL;else{if(!(T = (BiTNode *)malloc(sizeof (BiTNode)))){cout << "内存分配错误!" << endl;exit(0);}T->data = e;createBiTree(T->l);createBiTree(T->r);}}void createBiTree2(BiTNode *T,int u) {if(T){SqBiTree[u] = T->data;createBiTree2(T->l,2 * u + 1);createBiTree2(T->r,2 * u + 2); }}void outputBiTree2(int n){int cnt = 0;for(int i = 0;cnt <= n;i++){cout << SqBiTree[i];if(SqBiTree[i] != ' ')cnt ++;}cout << endl;}void preOrderTraverse(BiTNode *T) {if(T){cout << T->data;preOrderTraverse(T->l);preOrderTraverse(T->r);}}void inOrderTraverse(BiTNode *T) {if(T){inOrderTraverse(T->l);cout << T->data;inOrderTraverse(T->r);}}void beOrderTraverse(BiTNode *T){if(T){beOrderTraverse(T->l);beOrderTraverse(T->r);cout << T->data;}}int sumOfVer(BiTNode *T){if(!T)return 0;return sumOfVer(T->l) + sumOfVer(T->r) + 1;}int sumOfLeaf(BiTNode *T){if(!T)return 0;if(T->l == NULL && T->r == NULL)return 1;return sumOfLeaf(T->l) + sumOfLeaf(T->r);}int depth(BiTNode *T){if(!T)return 0;return max(depth(T->l),depth(T->r)) + 1;}bool LongestPath(int dist,int dist2,vector<ElemType> &ne,BiTNode *T) {if(!T)return false;if(dist2 == dist)return true;if(LongestPath(dist,dist2 + 1,ne,T->l)){ne.push_back(T->l->data);return true;}else if(LongestPath(dist,dist2 + 1,ne,T->r)){ne.push_back(T->r->data);return true;}return false;}void swapVer(BiTNode *&T){if(T){swapVer(T->l);swapVer(T->r);BiTNode *tmp = T->l;T->l = T->r;T->r = tmp;}}//以下是测试程序void test1(){getchar();cout << "请以先序次序输入二叉树结点的值，空结点用空格表示:" << endl; createBiTree(T);cout << "二叉树创建成功!" << endl;}void test2(){cout << "二叉树的前序遍历为:" << endl;preOrderTraverse(T);cout << endl;}void test3(){cout << "二叉树的中序遍历为:" << endl;inOrderTraverse(T);cout << endl;}void test4(){cout << "二叉树的后序遍历为:" << endl;beOrderTraverse(T);cout << endl;}void test5(){cout << "二叉树的总结点数为：" << sumOfVer(T) << endl;}void test6(){cout << "二叉树的叶子结点数为：" << sumOfLeaf(T) << endl; }void test7(){cout << "二叉树的深度为：" << depth(T) << endl;}void test8(){int dist = depth(T);vector<ElemType> ne;cout << "树根到叶子的最长路径:" << endl;LongestPath(dist,1,ne,T);ne.push_back(T->data);reverse(ne.begin(),ne.end());cout << ne[0];for(int i = 1;i < ne.size();i++)cout << "->" << ne[i];cout << endl;}void test9(){swapVer(T);cout << "操作成功!" << endl;}void test10(){memset(SqBiTree,' ',sizeof SqBiTree);createBiTree2(T,0);cout << "操作成功!" << endl;}void test11(){int n = sumOfVer(T);outputBiTree2(n);}int main(){int op = 0;while(op != 12){cout << "-----------------menu--------------------" << endl;cout << "--------------1：创建二叉树--------------" << endl;cout << "--------------2：前序遍历----------------" << endl;cout << "--------------3：中序遍历----------------" << endl;cout << "--------------4：后序遍历----------------" << endl;cout << "--------------5：总结点数----------------" << endl;cout << "--------------6：叶子节点数--------------" << endl;cout << "--------------7：树的深度----------------" << endl;cout << "--------------8：树根到叶子的最长路径----" << endl;cout << "--------------9：交换所有节点左右子女----" << endl;cout << "--------------10：顺序存储---------------" << endl;cout << "--------------11：显示顺序存储-----------" << endl;cout << "--------------12：退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl;if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1();break;case 2:test2();break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:cout << "测试结束!" << endl;break;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果测试用例：1.创建二叉树（二叉链表形式）2.前序遍历3.中序遍历4.后序遍历5.总结点数6.叶子结点数7.树的深度8.树根到叶子的最长路径9.交换所有左右子女10.顺序存储七、思考讨论题或体会或对改进实验的建议通过这次实验，我掌握了二叉树的顺序存储和链式存储，体会了二叉树的存储结构的特性，掌握了二叉树的树上相关操作。

国开电大数据结构(本)形考作业4参考答案

国开电大数据结构(本)形考作业4参考答案1.对于二分查找，要求线性表必须以顺序存储方式，并且数据元素有序。

2.在采用顺序查找方法查找长度为n的线性表时，每个元素的平均查找长度为(n+1)/2.3.对于一个长度为10的有序表，按折半查找对该表进行查找，在等概率情况下查找成功的平均比较次数为29/10.4.已知一个有序表为{11,22,33,44,55,66,77,88,99}，则顺序查找元素55需要比较5次。

5.对于数据{53,30,37,12,45,24,96}，从空二叉树开始逐个插入数据来形成二叉排序树，若希望高度最小，应该选择的序列是37,24,12,30,53,45,96.6.对于顺序存储的有序表{5,12,20,26,37,42,46,50,64}，若采用折半查找，则查找元素26的比较次数是4次。

7.在所有的排序方法中，关键字比较的次数与记录初始排列秩序无关的是直接选择排序。

8.插入排序是一种将未排序序列中的元素依次取出与已经排好序的序列中的元素作比较，将其放入已排序序列的正确位置上的排序方法。

9.归并排序是一种依次将每两个相邻的有序表合并成一个有序表的排序方法。

10.交换排序是一种当两个元素出现逆序的时候就交换位置的排序方法。

if(kkey)p=p->left;elseif(k>p->key)p=p->right;elsereturn (p);return (NULL);答案】：(NULL)，(p->key)题目26.1) 对关键字序列(36,69,46,28,30,74)采用快速排序，以第一个关键字为分割元素，经过一次划分后的结果序列为正确答案：C。

28，30，46，36，69，74改写后：对关键字序列(36,69,46,28,30,74)进行快速排序，以第一个关键字36为分割元素，经过一次划分后的结果序列为28，30，46，36，69，74.2) 用冒泡法对上述序列排序，经两趟冒泡的结果序列为正确答案：A。

数据结构实验报告(二叉树的基本操作)

else if((root->LChild==NULL)&&(root->RChild==NULL)) LeafNum=1;
else LeafNum=LeafCount(root->LChild)+LeafCount(root->RChild);
//叶子数为左右子树数目之和
return LeafNum;
printf("\n菜单选择\n\n");
printf(" 1.树状输出二叉树2.先序遍历二叉树\n");
printf(" 3.中序遍历二叉树4.后序遍历二叉树\n");
printf(" 5.输出叶子结点6.输出叶子结点的个数\n");
printf(" 7.输出二叉树的深度8.退出\n");
printf("\n----------------------------------------------------------------------\n");
{
printf("\n\n");
j=j+1; k=0;
while(k<nlocate)
{
printf(" ");
k++;
}
}
while(k<(nlocate-1))
{
printf(" ");
k++;
}
printf("%c",bt->data );
q.front=q.front+1;
if(bt->LChild !=NULL)//存在左子树，将左子树根节点入队列

数据结构之二叉树编程实验报告

实验报告：二叉树题目：建立一棵二叉树，数据以字符串形式从键盘输入，在此二叉树上完成：（1）前序、中序、后序遍历（2）求出叶子数（3）求树高（4）左右子树交换，输出交换后的前序、中序遍历序列分析：建树：输入的字符串序列为带有空节点的前序遍历序列（空节点用*表示）。

①：前序，中序，后序遍历：递归遍历②：求叶子数：当一个节点的左右孩子都是NULL时，此节点即为叶子节点。

③：求树高当前节点的树高等于其左右孩子树高大的加1。

④：左右子树交换：对于每个节点，将其左右孩子交换，再递归对其左右子树交换。

测试结果：附：源码#include <iostream>#include <stdlib.h>using namespace std;struct Bintree{char data;Bintree* lchild;Bintree* rchild;};Bintree *head;int sp;/* 已知一棵二叉树的前序序列，建立这棵树*/ void CreateTree(Bintree *&p,char a[]){Bintree *temp;if(a[sp]!=0){if(a[sp]=='*'){p=NULL;sp++;return ;}p=new Bintree;p->data=a[sp++];CreateTree(p->lchild,a);CreateTree(p->rchild,a);}else p=NULL;}/* 求一棵树的高度*/int Depth(Bintree *&t){int lh , rh ;if( t == NULL ){return 0 ;}else{lh = Depth( t->lchild ) ;rh = Depth( t->rchild ) ;return ( lh > rh ? lh : rh ) + 1 ;}}/* 将二叉树的左右子树互换*/ void Exchange1(Bintree *&t){Bintree *temp;if(t){Exchange1(t->lchild);Exchange1(t->rchild);temp=t->lchild;t->lchild=t->rchild;t->rchild=temp;}}/* 按照前序递归遍历二叉树*/ void Preorder1(Bintree *&t){if(t!=NULL){printf("%c",t->data);Preorder1(t->lchild);Preorder1(t->rchild);}}/* 按照中序递归遍历二叉树*/ void Inorder1(Bintree *&t){if(t!=NULL){Inorder1(t->lchild);printf("%c",t->data);Inorder1(t->rchild);}}/* 按照后序递归遍历二叉树*/void Posorder1(Bintree *&t){if(t!=NULL){Posorder1(t->lchild);Posorder1(t->rchild);printf("%c",t->data);}}/* 递归法求叶子结点个数*/int Leaves_Num1(Bintree *&t){if(t){if(t->lchild==NULL&&t->rchild==NULL){return 1;}return Leaves_Num1(t->lchild)+Leaves_Num1(t->rchild);}return 0;}/*******************************************/int main (){char a[100];memset(a,0,sizeof(a));cout<<"输入带有空节点的前序遍历序列（空节点用*表示）"<<endl;cin>>a;sp=0;CreateTree(head,a);cout<<"前序遍历："<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历："<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历："<<endl;Posorder1(head);cout<<endl;cout<<"叶子数："<<Leaves_Num1(head)<<endl;cout<<"树高："<<Depth(head)<<endl;cout<<"左右子树交换后"<<endl;Exchange1(head);cout<<"前序遍历："<<endl;Preorder1(head);cout<<endl;cout<<"中序遍历："<<endl;Inorder1(head);cout<<endl;cout<<"后序遍历："<<endl;Posorder1(head);cout<<endl;return 0;}。

国开数据结构(本)数据结构课程实验报告

国开数据结构(本)数据结构课程实验报告1. 实验目的本次实验的主要目的是通过实际操作，掌握数据结构的基本概念、操作和应用。

通过对实验内容的了解和实际操作，达到对数据结构相关知识的深入理解和掌握。

2. 实验工具与环境本次实验主要使用C++语言进行编程，需要搭建相应的开发环境。

实验所需的工具和环境包括：C++编译器、集成开发环境(IDE)等。

3. 实验内容本次实验主要包括以下内容：3.1. 实现顺序存储结构的线性表3.2. 实现链式存储结构的线性表3.3. 实现栈和队列的顺序存储结构和链式存储结构3.4. 实现二叉树的顺序存储结构和链式存储结构3.5. 实现图的邻接矩阵和邻接表表示4. 实验步骤实验进行的具体步骤如下：4.1. 实现顺序存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.2. 实现链式存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.3. 实现栈和队列的顺序存储结构和链式存储结构- 定义数据结构- 实现入栈、出栈、入队、出队操作4.4. 实现二叉树的顺序存储结构和链式存储结构- 定义数据结构- 实现插入、删除、查找等操作4.5. 实现图的邻接矩阵和邻接表表示- 定义数据结构- 实现插入、删除、查找等操作5. 实验结果与分析通过对以上实验内容的实现和操作，得到了以下实验结果与分析： 5.1. 顺序存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.2. 链式存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.3. 栈和队列的顺序存储结构和链式存储结构- 实现了栈和队列的入栈、出栈、入队、出队操作- 通过实验数据进行性能分析，得出了相应的性能指标5.4. 二叉树的顺序存储结构和链式存储结构- 实现了二叉树的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.5. 图的邻接矩阵和邻接表表示- 实现了图的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标6. 总结与展望通过本次数据结构课程的实验，我们深入了解并掌握了数据结构的基本概念、操作和应用。

数据结构实验报告—二叉树

《算法与数据结构》课程实验报告一、实验目的1、实现二叉树的存储结构2、熟悉二叉树基本术语的含义3、掌握二叉树相关操作的具体实现方法二、实验内容及要求1. 建立二叉树2. 计算结点所在的层次3. 统计结点数量和叶结点数量4. 计算二叉树的高度5. 计算结点的度6. 找结点的双亲和子女7. 二叉树前序、中序、后序遍历的递归实现和非递归实现及层次遍历8. 二叉树的复制9. 二叉树的输出等三、系统分析（1）数据方面：该二叉树数据元素采用字符char型，并且约定“#”作为二叉树输入结束标识符。

并在此基础上进行二叉树相关操作。

（2）功能方面：能够实现二叉树的一些基本操作，主要包括：1.采用广义表建立二叉树。

2.计算二叉树高度、统计结点数量、叶节点数量、计算每个结点的度、结点所在层次。

3.判断结点是否存在二叉树中。

4.寻找结点父结点、子女结点。

5.递归、非递归两种方式输出二叉树前序、中序、后序遍历。

6.进行二叉树的复制。

四、系统设计（1）设计的主要思路二叉树是的结点是一个有限集合，该集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树、互不相交的二叉树组成。

根据实验要求，以及课上老师对于二叉树存储结构、基本应用的讲解，同时课后研究书中涉及二叉树代码完成二叉树模板类，并将所需实现各个功能代码编写完成，在建立菜单对功能进行调试。

（2）数据结构的设计二叉树的存储结构有数组方式和链表方式。

但用数组来存储二叉树有可能会消耗大量的存储空间，故在此选用链表存储，提高存储空间的利用率。

根据二叉树的定义，二叉树的每一个结点可以有两个分支，分别指向结点的左、右子树。

因此，二叉树的结点至少应包括三个域，分别存放结点的数据，左子女结点指针，右子女结点指针。

这将有利于查找到某个结点的左子女与右子女，但要找到它的父结点较为困难。

该实验采取二叉链表存储二叉树中元素，具体二叉树链表表示如下图所示。

图1二叉树的链表表示（3）基本操作的设计二叉树关键主要算法：利用广义表进行二叉树的建立。

数据结构树和二叉树实验报告

else
{
p=FindNode(b->lchild,x);
if (p!=NULL)
return p;
else
return FindNode(b->rchild,x);
}
}
BTNode *LchildNode(BTNode *p)
{
return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
printf("(");
DispBTNode(b->lchild);
if (b->rchild!=NULL) printf(",");
DispBTNode(b->rchild);
printf(")");
}
}
}
int BTWidth(BTNode *b)
{
struct
{
int lno;
BTNode *p;
(9)掌握并查集的相关概念与算法。
(10)灵活掌握运用二叉树这种数据结构解决一些综合应用问题。
二、实验项目摘要
1.编写一程序,实现二叉树的各种基本运算,并在此基础上设计一个主程序完成如下功能:
（1）输出二叉树b;
（2）输出H结点的左、右孩子结点值;
（3）输出二叉树b的深度;
（4）输出二叉树b的宽度;
while (i<=rear)
{
n=0;
while (i<=rear && Qu[i]、lno==lnum)
{
n++;i++;
}
lnum=Qu[i]、lno;

2020年国家开放大学电大《数据结构》实验报告

数据结构形成性考核册实验名称：实验一线性表线性表的链式存储结构【问题描述】某项比赛中，评委们给某参赛者的评分信息存储在一个带头结点的单向链表中，编写程序：（1）显示在评分中给出最高分和最低分的评委的有关信息（姓名、年龄、所给分数等）。

（2）在链表中删除一个最高分和一个最低分的结点。

（3）计算该参赛者去掉一个最高分和一个最低分后的平均成绩。

【基本要求】（1）建立一个评委打分的单向链表；（2）显示删除相关结点后的链表信息。

（3）显示要求的结果。

【实验步骤】（1）运行PC中的Microsoft Visual C++ 6.0程序，（2）点击“文件”→“新建”→对话窗口中“文件”→“c++ Source File”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”，（3）输入程序代码，程序代码如下:#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <iostream.h>#include <conio.h>#define NULL 0#define PWRS 5 //定义评委人数struct pw //定义评委信息{ char name[6];float score;int age;};typedef struct pw PW;struct node //定义链表结点{struct pw data;struct node * next;};typedef struct node NODE;NODE *create(int m); //创建单链表int calc(NODE *h); //计算、数据处理void print(NODE *h); //输出所有评委打分数据void input(NODE *s);//输入评委打分数据void output(NODE *s);//输出评委打分数据void main(){NODE *head;float ave=0;float sum=0;head=create(PWRS);printf("所有评委打分信息如下:\n");print(head);//显示当前评委打分calc(head);//计算成绩printf("该选手去掉1 最高分和1 最低分后的有效评委成绩:\n");print(head);//显示去掉极限分后的评委打分}void input(NODE *s){printf("请输入评委的姓名: ");scanf("%S",&s->);printf("年龄: ");scanf("%d",&s->data.age);printf("打分: ");scanf("%f",&s->data.score);printf("\n");}void output(NODE *s){printf("评委姓名: %8s ,年龄: %d,打分: %2.2f\n",s->,s->data.age,s->data.score); }NODE *create(int m){NODE *head,*p,*q;int i;p=(NODE*)malloc(sizeof(NODE));head=p;q=p;p->next=NULL;for(i=1;i<=m;i++){p=(NODE*)malloc(sizeof(NODE));input(p);p->next=NULL;q->next=p;q=p;}return (head);}void print(NODE *h){ for(int i=1;((i<=PWRS)&&(h->next!=NULL));i++){h=h->next;output(h); }printf("\n");}int calc(NODE *h){NODE *q,*p,*pmin,*pmax;float sum=0;float ave=0;p=h->next; //指向首元结点pmin=pmax=p; //设置初始值sum+=p->data.score;p=p->next;for(;p!=NULL;p=p->next){if(p->data.score>pmax->data.score) pmax=p;if(p->data.score<pmin->data.score) pmin=p;sum+=p->data.score;}cout<<"给出最高分的评委姓名："<<pmax-><<"年龄："<<pmax->data.age<<"分值："<<pmax->data.score<<endl;cout<<"给出最低分的评委姓名："<<pmin-><<"年龄："<<pmin->data.age<<"分值："<<pmin->data.score<<endl;printf("\n");sum-=pmin->data.score;sum-=pmax->data.score;for (q=h,p=h->next;p!=NULL;q=p,p=p->next){if(p==pmin){q->next=p->next; p=q;}//删除最低分结点if(p==pmax) {q->next=p->next; p=q;}//删除最高分结点}ave=sum/(PWRS-2);cout<<"该选手的最后得分是："<<ave<<endl;return 1;}程序运行结果如下:线性表的顺序存储结构【问题描述】用顺序表A记录学生的信息，编写程序：（1）将A表分解成两个顺序表B和C，使C表中含原A表中性别为男性的学生，B表中含原表中性别为女性的学生，要求学生的次序与原A表中相同。

国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案

《数据结构》课程实验报告
（实验4二叉树）
学生姓名
学号
班级
指导老师
实验名称
实验成绩
实验报告
实ቤተ መጻሕፍቲ ባይዱ
验
概
述
实验目的：
（1）根据数组tree，建立与该二叉树对应的链式存储结构。
（2）对该二叉树采用中序遍历法显示遍历结果。
实验要求：
（1）在主函数中，通过键盘输入建立设定的完全二叉树的顺序存储结构。
（2）设计子函数，其功能为将顺序结构的二叉树转化为链式结构。
（2）中序遍历采用递归算法，即中序遍历左子树、访问根结点、中序遍历右子树。
实
验
内
容
程序代码：
/*实验3.1二叉树的顺序存储结构和链式存储结构*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
/*二叉树链式存储结构结点定义*/
typedef struct BTreeNode
指
导
教
师
评
语
指导教师日期
（3）设计子函数，其功能为对给定二叉树进行中序遍历，显示遍历结果。
（4）通过实例判断算法和相应程序的正确性。
实验基本原理：
（1）顺序存储的二叉树转化为链式存储结构，采用递归算法，递归函数的形式为Creab(tree,n,i,b)，其中形参：tree为顺序存储二叉树的数组，n为二叉树的结点数，i是二叉树某结点在数组tree中的下标（初始值为1），b为要建立的链式存储二叉树结点指针。转化时，首先建立*b结点，将tree[i]的值赋给*b的数据域，再调用递归函数分别构造左子树和右子树。