数据结构实验报告-二叉树的存储结构的实现与应用

已于 2023-04-11 15:33:25 修改
阅读量2.9k 收藏 31
点赞数 2
文章标签： 数据结构 算法
于 2023-04-10 21:57:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51122012/article/details/130070700
版权
该文详细介绍了二叉树的抽象数据类型定义，包括初始化、创建、查找、遍历等基本操作，并提供了C++代码实现。此外，还涵盖了二叉树的层次遍历、非递归遍历以及二叉树子树交换的算法。最后，讨论了哈夫曼编码的构建与打印编码的回溯法策略。
摘要由CSDN通过智能技术生成

实验目的

熟悉二叉树结点的结构和对二叉树的基本操作。

掌握对二叉树每一种操作的具体实现。

学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

在二叉树基本操作的基础上掌握二叉树的应用。

实验要求

1． 独立完成；

2． 程序调试正确，有执行结果。

3． 程序是自己开发的，在运行结果界面上输出显示姓名。

  1. 基础题：

按照教材中关于二叉树的抽象数据类型定义，采用二叉链表存储结构，编程实现二叉树的各种基本操作，并通过主函数调用，简单测试各基本函数的正确性。

比如：二叉树的基本操作可包括：

(1) void InitBT( BTreeNode *&BT ) //初始化二叉树BT

(2) void CreateBT( BTreeNode *&BT, char *a )

//根据字符串a所给出二叉树的描述，建立二叉链表存储结构

(3) int EmptyBT( BTreeNode *BT)

//检查二叉树BT是否为空，空返回1，否则返回0

(4) int DepthBT( BTreeNode *BT) //求二叉树BT的深度并返回该值

(5) int NodeCount(BTreeNode *BT) //求二叉树BT的总结点个数

(6) void PreOrder( BTreeNode *BT) //先序遍历递归算法

(7) void InOrder( BTreeNode *BT) //中序遍历递归算法

(8) void PostOrder( BTreeNode *BT) //后序遍历递归算法

(9) int FindBT( BTreeNode *BT, ElemType x)

//查找二叉树BT中值为x的结点，若查找成功返回1，否则返回0

(10)void DestroyBT( BTreeNode *&BT ) //销毁二叉树BT

2．应用题

(1)采用二叉链表存储结构，完成二叉树的层次遍历，先序遍历的非递归算法和中序遍历的非递归算法。

(2)采用二叉链表存储结构，交换二叉树中每个结点的左孩子和右孩子。

(3)哈夫曼编码器
给定n（n=5,n=8,n=15,n=27）个字符在某个系统中出现的概率，以该n个概率做叶子结点的权值，根据Huffman算法，构造一棵哈夫曼树，给n个字符编码

3
【实验内容】1.需求分析

按照上机实验报告模板格式，写出二叉链表存储结构的二叉树的上机实验的需求分析。（不要用上传附件形式）

正确答案：

我的答案：

特性

二叉树中每个结点最多有两棵子树；二叉树每个结点的度小于等于2

子树有左右之分，不能颠倒——有序树

二叉树是递归结构，在二叉树的定义中又用到了二叉树的概念

在树型结构中，二叉树的结构最简单，规律性最强；

可以证明，所有树都能转为唯一对应的二叉树。二叉树也能转换成树或森林。

普通树（多叉树）若不转化为二叉树，则运算很难实现。

4
【实验内容】2.概要设计

按照上机实验报告模板，写出二叉树的抽象数据类型定义ADT，其他模块(如果有)和函数的功能说明，本程序包含的函数列表，函数之间的调用关系。（不要用上传附件形式，调用关系可上传图片）

正确答案：

我的答案：

ADT BinaryTree {

数据对象：D 是具有相同特性的数据元素的集合。

数据关系：

 若D为空集，则称为空树。

  否则: 

  (1) 在D中存在唯一的称为根的数据元素 root；

  (2) 当n > 1时，其余结点可分为2个互不相交的有限集T1、T2，其中每一个子集本身又是一棵符合本定义的二叉树，T1称为根 root 的左子树，T2称为根 root 的右子树。

基本操作：

初始化操作

InitBiTree (&T)操作结果：构造空二叉树 T。

CreateBiTree (&T, definition)初始条件：definition 给出二叉树 T 的定义。

操作结果：按 definition 构造二叉树 T。

结构销毁操作

DestroyBiTree (&T);

初始条件：二叉树 T 存在。

操作结果：销毁二叉树 T 。

Root ( T )

初始条件：二叉树 T 存在。

操作结果：返回二叉树T的根结点。

Value ( T, e )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：返回e的值。

Parent ( T, e )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：若e是T的非根结点，则返回它的双亲，

否则返回“空”。

LeftChild ( T, e )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：返回 e 的左孩子。若 e 无左孩子，

则返回"空"。

RightChild ( T, e )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：返回 e 的右孩子。若 e 无右孩子，

                则返回"空" 。

LeftSibling ( T, e )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：返回 e 的左兄弟。若 e 是其双亲的

                左孩子或无左兄弟，则返回“空”。

RightSibling ( T, e )

初始条件：二叉树 T 存在， e 是 T 中某个结点。

操作结果：返回 e 的右兄弟。若 e 是其双亲的

                右孩子或无右兄弟，则返回"空"。

BiTreeEmpty (T);

初始条件：二叉树 T 存在。

操作结果：若T为空二叉树，则返回 TRUE，否则

返回 FALSE。

BiTreeDepth (T)

初始条件：二叉树 T 存在。

操作结果：返回 T 的深度。

PreOrderTraverse (T)——根左右（先序遍历）

初始条件：二叉树 T 存。

操作结果：先序遍历 T，对每个结点访问一次。

InOrderTraverse (T)——左根右（中序遍历）

初始条件：二叉树 T 存在。

操作结果：中序遍历 T，对每个结点访问一次。

PostOrderTraverse (T)——左右根（后序遍历）

初始条件：二叉树 T 存在。

操作结果：后序遍历 T，对每个结点访问一次。

LevelOrderTraverse (T)——（层次遍历）

初始条件：二叉树 T 存在。

操作结果：层序遍历 T，对每个结点访问一次。

Assign (&T, &e, value )

初始条件：二叉树 T 存在，e 是 T 中某个结点。

操作结果：结点 e 赋值为 value。

ClearBiTree ( &T )

初始条件：二叉树 T 存在。

操作结果：将二叉树 T 清为空树。

InsertChild ( &T, p, LR, c )

初始条件：二叉树 T 存在，p 指向 T 中某个结点，LR 为 0 或 1，非空二叉树 c 与 T 不相交且右子树为空。

操作结果：根据 LR 为 0 或 1，插入 c 为 T 中 p 所指结点的左或右子树。p 所指结点原有左或右子树成为 c 的右子树。

DeleteChild (&T, p, LR);

初始条件：二叉树 T 存在，p 指向 T 中某个结点，LR 为 0 或 1。

操作结果：根据 LR 为 0 或 1，删除 T 中 p 所指结点的左或右子树。

6
【实验内容】3.详细设计

按照上机实验报告模板，写出二叉链表存储结构的上机实验的详细设计部分：

1）实现概要设计中定义的所有的数据类型；

2）对每个操作对应的各个函数给出详细的伪码。

3）对主程序和其他模块(如果有)也写出详细的伪码；

4）分析各个函数的时间复杂度和空间复杂度。(递归的除外)

二叉树的基本操作

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef struct binode{
	char data;
	struct binode *rchild,*lchild;
}binode,*bitree;
void init(bitree &B)  //初始化 
{
	B=NULL;
}
bool empty(bitree B)  //判断是否为空树 
{
	if(B==NULL) return true;
	return false;
} 
void creast(bitree &B)  //树的创建 
{
	char a;
	scanf("%c",&a);
	if(a=='#')  B=NULL;
	else 
	{
		B=new binode;
		if(B==NULL) exit(-2);
		B->data=a;
		creast(B->lchild);
		creast(B->rchild);
	}
}
int find1(bitree B,char a)   //判断树中是否有该数有为1无为0 
{
	int i;
	if(B==NULL) return 0;
	else if(B->data==a) return 1;
	else {
		i=find1(B->lchild,a);
		if(i!=1) return i;
		else
		{
			return find1(B->rchild,a);
		}
	}
}
bitree find2(bitree B,char a)  //找到对应节点并返回结点指针 
{
	bitree p;
	if(B==NULL) return 0;
	else if(B->data==a) return B;
	else
	{
		p=find2(B->lchild,a);
		if(p!=NULL) return p;
		else return find2(B->rchild,a);
	}
}
int depth(bitree B)  //输出树的深度 
{
	if(B==NULL) return 0;
	else 
	{
		int depthl=depth(B->lchild);
		int depthr=depth(B->rchild);
		return 1+max(depthl,depthr);
	}
} 
int node(bitree B)  //统计树的节点数 
{
	int sum1=0,sum2=0;
	if(B==NULL) return 0;
	else
	{
		sum1=node(B->lchild);
		sum2=node(B->rchild);
		return sum1+sum2+1;
	}
}
void destory(bitree &B)  //摧毁树 
{
	if(B!=NULL) 
	{
		destory(B->lchild);
		destory(B->rchild);
		delete B;
		B=NULL;
	}
}
void xxbl(bitree B) //先序遍历 
{
	if(B!=NULL)
	{
		cout<<B->data<<" ";
		xxbl(B->lchild);
		xxbl(B->rchild);
	}
}
void zxbl(bitree B)  //中序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	    cout<<B->data<<" ";
		xxbl(B->rchild);
	}
}
void hxbl(bitree B) //后序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	  	xxbl(B->rchild);
	    cout<<B->data<<" ";
 	}
}
void jh(bitree root)  //交换左右子树 
{
    if(root==NULL) return;
    else
    {
        bitree temp=root->lchild;
        root->lchild=root->rchild;
        root->rchild=temp;
        jh(root->lchild);
        jh(root->rchild);
    }
}
int main()
{
	bitree mytree,yourtree;
	init(mytree);
	init(yourtree);
/*	creast(mytree);
	xxbl(mytree);
	cout<<endl;	
	jh(mytree);
	xxbl(mytree);*/
    cout<<"树已初始化"<<endl;
	 cout<<"创建树,'#'结束"<<endl;
	creast(mytree);
	if(empty(mytree)) 
	{
		cout<<"树为空树，重新创建"<<endl;
		creast(mytree);
	}
	else{
		cout<<"二叉树非空"<<endl;
	}
	cout<<"先序遍历：";
	xxbl(mytree);
	cout<<endl;
	cout<<"中序遍历：";
	zxbl(mytree);
	cout<<endl;
	cout<<"后序遍历：";
	hxbl(mytree); 
	cout<<endl;
	cout<<"该树的深度："<<depth(mytree)<<endl;
	cout<<"该树所有结点数为："<<node(mytree)<<endl;
	char a;
	cout<<"输入一个字符进行查找"<<endl;
	cin>>a;
    if(find1(mytree,a)) 
	{
		cout<<"存在该字符"<<endl;
	    bitree p;
	    p=find2(mytree,a);
		cout<<p->data;	    
	}
    else  cout<<"不存在该字符"<<endl;
    destory(mytree);
	cout<<"程序结束摧毁树"<<endl; 
	cout<<"数据结构小二班11号刘志江"<<endl;
	return 0;
}

二叉树的遍历

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef struct binode{
	char data;
	struct binode *rchild,*lchild;
}binode,*bitree;
void init(bitree &B)  //初始化 
{
	B=NULL;
}
bool empty(bitree B)  //判断是否为空树 
{
	if(B==NULL) return true;
	return false;
} 
void creast(bitree &B)  //树的创建 
{
	char a;
	scanf("%c",&a);
	if(a=='#')  B=NULL;
	else 
	{
		B=new binode;
		if(B==NULL) exit(-2);
		B->data=a;
		creast(B->lchild);
		creast(B->rchild);
	}
}
int find1(bitree B,char a)   //判断树中是否有该数有为1无为0 
{
	int i;
	if(B==NULL) return 0;
	else if(B->data==a) return 1;
	else {
		i=find1(B->lchild,a);
		if(i!=1) return i;
		else
		{
			return find1(B->rchild,a);
		}
	}
}
bitree find2(bitree B,char a)  //找到对应节点并返回结点指针 
{
	bitree p;
	if(B==NULL) return 0;
	else if(B->data==a) return B;
	else
	{
		p=find2(B->lchild,a);
		if(p!=NULL) return p;
		else return find2(B->rchild,a);
	}
}
int depth(bitree B)  //输出树的深度 
{
	if(B==NULL) return 0;
	else 
	{
		int depthl=depth(B->lchild);
		int depthr=depth(B->rchild);
		return 1+max(depthl,depthr);
	}
} 
int node(bitree B)  //统计树的节点数 
{
	int sum1=0,sum2=0;
	if(B==NULL) return 0;
	else
	{
		sum1=node(B->lchild);
		sum2=node(B->rchild);
		return sum1+sum2+1;
	}
}
void destory(bitree &B)  //摧毁树 
{
	if(B!=NULL) 
	{
		destory(B->lchild);
		destory(B->rchild);
		delete B;
		B=NULL;
	}
}
void xxbl(bitree B) //先序遍历 
{
	if(B!=NULL)
	{
		cout<<B->data<<" ";
		xxbl(B->lchild);
		xxbl(B->rchild);
	}
}
void zxbl(bitree B)  //中序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	    cout<<B->data<<" ";
		xxbl(B->rchild);
	}
}
void hxbl(bitree B) //后序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	  	xxbl(B->rchild);
	    cout<<B->data<<" ";
 	}
}
void jh(bitree root)  //交换左右子树 
{
    if(root==NULL) return;
    else
    {
        bitree temp=root->lchild;
        root->lchild=root->rchild;
        root->rchild=temp;
        jh(root->lchild);
        jh(root->rchild);
    }
}
int main()
{
	bitree mytree,yourtree;
	init(mytree);
	init(yourtree);
/*     creast(mytree);
	xxbl(mytree);
	cout<<endl;	
	jh(mytree);
	xxbl(mytree);*/
    cout<<"树已初始化"<<endl;
	 cout<<"创建树,'#'结束"<<endl;
	creast(mytree);
	if(empty(mytree)) 
	{
		cout<<"树为空树，重新创建"<<endl;
		creast(mytree);
	}
	else{
		cout<<"二叉树非空"<<endl;
	}
	cout<<"先序遍历：";
	xxbl(mytree);
	cout<<endl;
	cout<<"中序遍历：";
	zxbl(mytree);
	cout<<endl;
	cout<<"后序遍历：";
	hxbl(mytree); 
	cout<<endl;
	cout<<"该树的深度："<<depth(mytree)<<endl;
	cout<<"该树所有结点数为："<<node(mytree)<<endl;
	char a;
	cout<<"输入一个字符进行查找"<<endl;
	cin>>a;
    if(find1(mytree,a)) 
	{
		cout<<"存在该字符"<<endl;
	    bitree p;
	    p=find2(mytree,a);
		cout<<p->data;	    
	}
    else  cout<<"不存在该字符"<<endl;
    destory(mytree);
	cout<<"程序结束摧毁树"<<endl; 
	cout<<"数据结构小二班11号刘志江"<<endl;
	return 0;
}

二叉树的子树交换

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef struct binode{
	char data;
	struct binode *rchild,*lchild;
}binode,*bitree;
void init(bitree &B)  //初始化 
{
	B=NULL;
}
bool empty(bitree B)  //判断是否为空树 
{
	if(B==NULL) return true;
	return false;
} 
void creast(bitree &B)  //树的创建 
{
	char a;
	scanf("%c",&a);
	if(a=='#')  B=NULL;
	else 
	{
		B=new binode;
		if(B==NULL) exit(-2);
		B->data=a;
		creast(B->lchild);
		creast(B->rchild);
	}
}
int find1(bitree B,char a)   //判断树中是否有该数有为1无为0 
{
	int i;
	if(B==NULL) return 0;
	else if(B->data==a) return 1;
	else {
		i=find1(B->lchild,a);
		if(i!=1) return i;
		else
		{
			return find1(B->rchild,a);
		}
	}
}
bitree find2(bitree B,char a)  //找到对应节点并返回结点指针 
{
	bitree p;
	if(B==NULL) return 0;
	else if(B->data==a) return B;
	else
	{
		p=find2(B->lchild,a);
		if(p!=NULL) return p;
		else return find2(B->rchild,a);
	}
}
int depth(bitree B)  //输出树的深度 
{
	if(B==NULL) return 0;
	else 
	{
		int depthl=depth(B->lchild);
		int depthr=depth(B->rchild);
		return 1+max(depthl,depthr);
	}
} 
int node(bitree B)  //统计树的节点数 
{
	int sum1=0,sum2=0;
	if(B==NULL) return 0;
	else
	{
		sum1=node(B->lchild);
		sum2=node(B->rchild);
		return sum1+sum2+1;
	}
}
void destory(bitree &B)  //摧毁树 
{
	if(B!=NULL) 
	{
		destory(B->lchild);
		destory(B->rchild);
		delete B;
		B=NULL;
	}
}
void xxbl(bitree B) //先序遍历 
{
	if(B!=NULL)
	{
		cout<<B->data<<" ";
		xxbl(B->lchild);
		xxbl(B->rchild);
	}
}
void zxbl(bitree B)  //中序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	    cout<<B->data<<" ";
		xxbl(B->rchild);
	}
}
void hxbl(bitree B) //后序遍历 
{
	if(B!=NULL)
	{
		xxbl(B->lchild);
	  	xxbl(B->rchild);
	    cout<<B->data<<" ";
 	}
}
void jh(bitree root)  //交换左右子树 
{
    if(root==NULL) return;
    else
    {
        bitree temp=root->lchild;
        root->lchild=root->rchild;
        root->rchild=temp;
        jh(root->lchild);
        jh(root->rchild);
    }
}
int main()
{
	bitree mytree,yourtree;
	init(mytree);
	init(yourtree);
     creast(mytree);
	xxbl(mytree);
	cout<<endl;	
	jh(mytree);
	xxbl(mytree);
    /*cout<<"树已初始化"<<endl;
	 cout<<"创建树,'#'结束"<<endl;
	creast(mytree);
	if(empty(mytree)) 
	{
		cout<<"树为空树，重新创建"<<endl;
		creast(mytree);
	}
	else{
		cout<<"二叉树非空"<<endl;
	}
	cout<<"先序遍历：";
	xxbl(mytree);
	cout<<endl;
	cout<<"中序遍历：";
	zxbl(mytree);
	cout<<endl;
	cout<<"后序遍历：";
	hxbl(mytree); 
	cout<<endl;
	cout<<"该树的深度："<<depth(mytree)<<endl;
	cout<<"该树所有结点数为："<<node(mytree)<<endl;
	char a;
	cout<<"输入一个字符进行查找"<<endl;
	cin>>a;
    if(find1(mytree,a)) 
	{
		cout<<"存在该字符"<<endl;
	    bitree p;
	    p=find2(mytree,a);
		cout<<p->data;	    
	}
    else  cout<<"不存在该字符"<<endl;
    destory(mytree);
	cout<<"程序结束摧毁树"<<endl; */
	cout<<"数据结构小二班11号刘志江"<<endl;
	return 0;
}

哈夫曼

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//Huffman树的节点类
typedef struct Node
{
    char value;               //结点的字符值   
    int weight;               //结点字符出现的频度
    Node *lchild,*rchild;     //结点的左右孩子
}Node;

//自定义排序规则，即以vector中node结点weight值升序排序
bool ComNode(Node *p,Node *q)
{
    return p->weight<q->weight;
}

//构造Huffman树，返回根结点指针
Node* BuildHuffmanTree(vector<Node*> vctNode)
{
    while(vctNode.size()>1)                            //vctNode森林中树个数大于1时循环进行合并
    {
        sort(vctNode.begin(),vctNode.end(),ComNode);   //依频度高低对森林中的树进行升序排序

        Node *first=vctNode[0];    //取排完序后vctNode森林中频度最小的树根
        Node *second=vctNode[1];   //取排完序后vctNode森林中频度第二小的树根
        Node *merge=new Node;      //合并上面两个树
        merge->weight=first->weight+second->weight;
        merge->lchild=first;
        merge->rchild=second;

        vector<Node*>::iterator iter;
        iter=vctNode.erase(vctNode.begin(),vctNode.begin()+2);    //从vctNode森林中删除上诉频度最小的两个节点first和second
        vctNode.push_back(merge);                                 //向vctNode森林中添加合并后的merge树
    }
    return vctNode[0];            //返回构造好的根节点
}

//用回溯法来打印编码
void PrintHuffman(Node *node,vector<int> vctchar)
{
    if(node->lchild==NULL && node->rchild==NULL)
    {//若走到叶子节点，则迭代打印vctchar中存的编码
        cout<<node->value<<": ";
        for(vector<int>::iterator iter=vctchar.begin();iter!=vctchar.end();iter++)
            cout<<*iter;
        cout<<endl;
        return;
    }
    else
    {
        vctchar.push_back(1);     //遇到左子树时给vctchar中加一个1
        PrintHuffman(node->lchild,vctchar);
        vctchar.pop_back();       //回溯，删除刚刚加进去的1
        vctchar.push_back(0);     //遇到左子树时给vctchar中加一个0
        PrintHuffman(node->rchild,vctchar);
        vctchar.pop_back();       //回溯，删除刚刚加进去的0

    }
}

int main()
{
    cout<<"请输入要编码的字符,并以空格隔开（个数任意）："<<endl;
    vector<Node*> vctNode;        //存放Node结点的vector容器vctNode
    char ch;                      //临时存放控制台输入的字符
    while((ch=getchar())!='\n')
    {
        if(ch==' ')continue;      //遇到空格时跳过，即没输入一个字符空一格空格
        Node *temp=new Node;
        temp->value=ch;
        temp->lchild=temp->rchild = NULL;
        vctNode.push_back(temp);  //将新的节点插入到容器vctNode中
    }

    cout<<endl<<"请输入每个字符对应的频度，并以空格隔开："<<endl;
    for(int i=0;i<vctNode.size();i++)
        cin>>vctNode[i]->weight;

    Node *root = BuildHuffmanTree(vctNode);   //构造Huffman树，将返回的树根赋给root
    vector<int> vctchar;
    PrintHuffman(root,vctchar);
cout<<"数据结构小二班11号刘志江"<<endl;
    system("pause");
}

实验截图
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
11
【实验内容】7.小结

即心得体会，包括对算法的讨论、分析，改进设想和其它经验教训等 。

正确答案：

我的答案：

在对于树的各种基本操作时要清晰的知道停止树的条件

在对树的左右子树的交换时可以另加一棵树，也可以在原树上进行交换。

在树的大多数操作中都采用了递归的算法

永远acl
关注
数据结构实验报告——二叉树
11-14
数据结构实验报告，二叉树实验报告。采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作
数据结构二叉树实验报告
01-04
数据结构二叉树实验报告
数据结构实验：树和二叉树（附c++源码：前序、后序、中序遍历、层次遍历、结点数）
最新发布
sherry__yuzu的博客
08-06 631
1.编写函数，输入字符序列，建立二叉树的二叉链表。 2.编写函数，实现二叉树的中序递归遍历算法。(最好也能实现前缀和后缀遍历算法) 3.编写函数，实现二叉树的中序非递归遍历算法。 4.编写函数，借助队列实现二叉树的层次遍历算法。 5.编写函数，求二叉树的高度。 6.编写函数，求二叉树的结点个数。 7.编写函数，求二叉树的叶子个数。 8.编写函数，交换二叉树每个结点的左子树和右子树。 9.编写一个主函数，在主函数中设计一个简单的菜单，分别调试上述算法。
《数据结构》实验报告五：二叉树
热门推荐
Amentos的博客
10-30 1万+
《数据结构》实验报告：二叉树基本概念 + 结点总数 + 叶子结点数 + 二叉树深度 + 中序非递归遍历 算法实现
数据结构二叉树（实训报告）
weixin_33750452的博客
05-30 1095
#include<stdio.h> #include<stdlib.h> typedef char TElemType; typedef struct node{ TElemType data; //结点数据 struct node *lchild,*rchild; //左右子女指针 }BinTNode, *BinTree...
数据结构实验报告-二叉树23.doc
07-28
数据结构实验报告-二叉树 本实验报告的主要目的是熟练掌握树的基本概念、二叉树的基本操作及在链式存储结构上的实现，并掌握二叉树的生成、遍历及求深度等算法。同时，掌握运用递归方式描述算法及编写递归 C 程序的...
数据结构实验报告-二叉树11.doc
07-28
《数据结构实验报告-二叉树11》 在数据结构的学习中，二叉树是一种基本且重要的非线性数据结构。本实验报告主要围绕二叉树的建立与应用展开，旨在让学生熟悉树的基本概念，了解树的存储结构，并通过实践掌握二叉树...
数据结构实验报告-二叉树7.doc
07-28
数据结构实验报告-二叉树7.doc 本实验报告的主要内容是关于二叉树的建立、遍历和深度统计。下面是实验报告中的关键知识点： 一、递归法建立二叉树 在实验报告中，我们使用递归法来建立二叉树。递归法是一种经典的...
数据结构实验报告-二叉树19.doc
07-28
数据结构实验报告-二叉树19.doc 本实验报告主要讲述二叉树的建立与应用，旨在使学生熟练掌握树的基本概念、二叉树的基本操作及在链式存储结构上的实现，并掌握二叉树的生成、遍历及求深度等算法。 一、目的 本次...
数据结构实验报告-二叉树21.doc
07-28
数据结构实验报告-二叉树21 本实验报告的主要目的是为了熟练掌握树的基本概念、二叉树的基本操作及在链式存储结构上的实现，并且掌握二叉树的生成、遍历及求深度等算法。此外还要掌握运用递归方式描述算法及编写...
数据结构二叉树的基本操作实验报告
12-27
问题描述：采用二叉链表作为存储结构，完成图1的二叉树的建立和遍历操作。 基本要求： （1）基于先序遍历的构造算法。输入是二叉树的先序序列，但必须在其中加入虚结点以示空指针的位置。假设虚结点输入时用空格字符表示。 （2）利用中序顺序遍历所建的二叉树，将遍历结果打印输出。
数据结构树和二叉树实验报告
12-14
(1)掌握树的相关概念,包括树、结点的度、树的度、分支结点、叶子结点、儿子结点、双亲结点、树的深度、森林等定义。 (2)掌握二叉树的概念,包括二叉树、满二叉树和完全二叉树的定义。 (3)掌握哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码产生方法。
数据结构试验3-二叉树实验报告含源码
03-08
数据结构实验报告，二叉树。需要的请放心下载！
二叉树实验报告
06-24
二叉树的实验报告，内有完整的二叉树实验的代码，用C++实现的
数据结构 建立二叉树二叉链表存储结构实现有关操作 实验报告
03-12
建立二叉树的二叉链表存储结构实现以下操作(选择其中的两个做) (1)输出二叉树 (2)先序遍历二叉树 (3) 中序遍历二叉树 (4)后序遍历二叉树 (5)层次遍历二叉树
数据结构实验报告，二叉树的基本操作（C语言）
VLOKL的博客
03-31 6241
数据结构实验报告，二叉树的基本操作（C语言）
数据结构实验报告-实现二叉树的基本操作-用顺序存储和链式存储结构
11-06
参考资料：《数据结构》(C语言版)严蔚敏&&吴伟民&&米宁著 要求选用顺序存储结构和二叉链表存储结构实现抽象数据类型二叉树的基本操作。有个亮点是利用字符在dos界面显示二叉树的结构形态。 里面包含了完整的源程序和实验报告文档。 实验报告包含了完整的步骤包括： 一.抽象数据类型二叉树的定义 二.存储结构定义（包括顺序存储和二叉链表）及各基本操作的实现 三.测试方案。包括详细的测试函数 四.测试结果。对所有操作的测试过程中二叉树的变化截图。 五.二叉树各基本操作时间复杂度与存储结构特点分析及对算法的改进设想。 六.实验总结和体会 实现的基本操作如下： InitBiTree(&T) DestroyBiTree(&T) CreateBiTree(&T) ClearBiTree(&T) BiTreeEmpty(T) BiTreeDepth(T) Root(T) Value(T,e) Assign(T,&e,value) Parent(T,e) LeftChild(T,e) RightChild(T,e) LeftSibling(T,e) RightSibling(T,e) InsertChild(T,p,LR,c) DeleteChild(T,p,LR) PreOrderTraverse(T,Visit()) InOrderTraverse(T,Visit()) PostOrderTraverse(T,Visit()) LevelOrderTraverse(T,Visit()) 下载清单： Base.h //全局常量、公共变量、公共函数等 BiTree.h //二叉链表二叉树实现 BiTree_Main.cpp //二叉链表二叉树测试程序 SqBiTree.h //顺序存储二叉树实现 SqBiTree_Main.cpp //顺序存储二叉树测试程序 抽象数据类型实现-二叉树-实验报告.doc
数据结构树的操作实验报告
09-09
一、实验目的： 理解二叉树特别是完全二叉树的性质，掌握二叉树的存储结构（二叉链表）；熟练掌握二叉树的常用操作算法（初始化、插入结点、删除结点、遍历等）；初步掌握二叉树的应用。 二、实验内容： 要求采用二叉链表作为存储结构，完成二叉树的建立，前序、中序和后序遍历的操作，求所有叶子及结点总数的操作等。 具体要求如下： ①给出基于二叉链表的二叉树类的定义； ②给出二叉树初始化（构造函数）的实现； ③给出二叉树三种遍历算法的递归实现； ④二叉树先序遍历的非递归算法实现； ⑤利用二叉树的遍历算法求二叉树的结点数、二叉树的叶结点数、二叉树的高度； ⑥二叉树的撤销删除 三、实验步骤： 1、需求分析： 本演示程序用JAVA编写，完成树的生成，任意位置的插入、删除，以及遍历二叉树中的结点，查找和修改树中元素的值。 ① 输入的形式和输入值的范围：插入元素时需要输入插入的位置和元素的值；删除元素时输入删除元素的位置；遍历时采用三种遍历方法中的一种遍历方法；修改操作时需要输入的元素的值；查找操作时，需要找到要查找元素的位置。在所有输入中，元素的值都是整数。 ② 输出的形式：在所有四种操作中都显示操作是否正确以及操作后树中的内容。其中删除操作后显示删除的元素的值，遍历二叉树中的元素，查找操作、修改操作后显示修改的值。 ③ 程序所能达到的功能：完成树的生成（通过插入操作）、插入、删除、遍历、查找、修改操作。 ④ 测试数据： A． 树中已有以50,25,75,12,37,43,30,33,87,93,97为关键字的结点 B． 插入操作中依次输入10，20，30，40，50，60，70，80，90，100十个数 C． 删除操作中输入10删除值为10的元素 D． 查找操作中输入20，30，40，50返回这个元素在树中的位置 2．概要设计： 1）为了实现上述程序功能，需要定义树的抽象数据类型： public int iData; public double dData; public Node leftChild; public Node rightChild; private Node root;int value; private Node getSuccessor； 基本操作：{ Tree () 操作结果：构造一个空的二叉树 insert () 初始条件：是否存在一个空二叉树 操作结果：往二叉树中插入数值 delete () 初始条件：存在一非空的二叉树 操作条件：将二叉树中的元素删除 displayTree () 初始条件：存在一非空的树 操作条件：显示非空树中的所有元素的值 getString () 初始条件：存在一非空的二叉树 操作结果：返回整个字符串的数值 getChar () 初始条件：存在一非空的二叉树 操作结果：返回字符型的数值 getInt () 初始条件：存在一非空的二叉树 操作结果：返回整型的数值 find () 初始条件：存在一非空二叉树 操作结果：从二叉树中查找某一元素 traverse () 初始条件：存在一非空的二叉树 操作结果：对二叉树中的元素进行遍历 preorder () 初始条件：存在一非空的二叉树 操作结果：对二叉树中的元素进行先根遍历 inOrder () 初始条件：存在一非空的二叉树 操作结果：对二叉树中的元素进行中根遍历 postOrder () 初始条件：存在一非空的二叉树 操作结果：对二叉树中的元素进行后根遍历 DisplayNode () 初始条件：存在一非空的二叉树 操作结果：显示出二叉树中的整形数值和双精度浮点型数值 public static void main 操作结果：调用主函数
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值