数据结构实验——二叉树及其应用

最新推荐文章于 2024-09-21 16:50:16 发布
最新推荐文章于 2024-09-21 16:50:16 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flippped/article/details/110700504
版权

文章目录

主要内容：

（1）按先序次序输入二叉树中结点的值，建立一棵以二叉链表作存储结构的二叉树，然后按先序、中序、后序、层序遍历这棵二叉树，并完成二叉树的相应信息的统计（如各种结点数目、二叉树的深度等）；
（2）建立一棵二叉排序树，并对其遍历、结点统计、深度计算、数据查找等。

代码

Tree.cpp

#ifndef TR
#define TR
#include"include.h"
#include"Tree.h"
 
Status GetHead(SqQueue Q,QElemType &e){
	if(Q.front==Q.rear)return ERROR;
	e = Q.base[Q.front];
	return OK;
	
}
int QueueLength(SqQueue Q){
	return (Q.rear - Q.front+MAXSIZE)%MAXSIZE;
}

//队列 
Status InitQueue(SqQueue &Q){
	Q.base = (QElemType *)malloc(MAXSIZE * sizeof(QElemType));
	if(!Q.base)exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}
Status EnQueue(SqQueue &Q,QElemType e){
	if((Q.rear+1)%MAXSIZE==Q.front)return ERROR;
	Q.base[Q.rear]=e;
	Q.rear = (Q.rear+1)%MAXSIZE;
	return OK; 
}
Status DeQueue(SqQueue &Q,QElemType &e){
	if(Q.front == Q.rear)return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXSIZE;
	return OK;
}
Status DestroyQueue(SqQueue &Q){
	free(Q.base);
	Q.base = NULL;
	Q.front = Q.rear = 0;
	return OK;
}
Status QueuenEmpty(SqQueue Q){
	return (Q.front==Q.rear);
}
//根据先序和中序创建二叉树
void PreInCreat (BiTree &T,ElemType pre[],int in[],int l1,int h1,int l2,int h2){
	T = (BiTree)malloc(sizeof(BiNode));
	T->data = pre[l1];
	for(int i = l2;i<=h2;i++)
		{
		if(in[i]==pre[l1])break;
		if(i==l2) T->lchild = NULL;
		else PreInCreat(T->lchild,pre,in,l1+1,l1+(i-l2),l2,i-1);
		if(i==h2) T->rchild=NULL;
		else PreInCreat(T->rchild,pre,in,l1+(i-l2)+1,h1,i+1,h2);
		}
} 
//二叉排序树 
void CreateBiTree1(BiTree &root){
	ElemType x;
	root = NULL;
	cin>>x;
	while(x!=-1){
		insert(root,x);
		cin>>x;
	}
} 
void insert(BiTree &T,ElemType x){
	if(T==NULL){
		T = (BiTree)malloc(sizeof(BiTNode));
		T->data = x;
		T->lchild = T->rchild = NULL;
	}
	else{
		if(x<=T->data)insert(T->lchild,x);
		else insert(T->rchild,x);
	}
}
//查找递归算法 
BiTree SearchBST(BiTree L,TElemType x){
	if(L==NULL)return NULL;
	if(L->data==x)return L;
	else{
		if(x<L->data)
			return SearchBST(L->lchild,x);
		else
			return SearchBST(L->rchild,x);
	}
}
//查找非递归算法 
BiTree SearchBST2(BiTree L,ElemType x){
	BiTree p = L;
	while(p&&(x!=p->data))
		if(x<p->data) p = p->lchild;
		else	p = p->rchild;
	return p;
}
//二叉树 
Status  CreateBiTree(BiTree &T){
	char c;
	cin>>c; 
	if(c=='#')	T=NULL;
	else{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))exit(OVERFLOW);
		T->data = c;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return OK;
}

void visit(TElemType e){
	cout<<e;
	printf("\n");
}
void visit2(ElemType e){
	cout<<e; 
	printf("\n");
}
Status PreOrderTraverse(BiTree T){
	if(T){
		visit(T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
	return OK;
}
Status InOrderTraverse(BiTree T){
		if(T){
		InOrderTraverse(T->lchild);
		visit(T->data);
		InOrderTraverse(T->rchild);
	}
	return OK;
}
Status InOrderTraverse2(BiTree L){
		if(L){
		InOrderTraverse2(L->lchild);
		visit2(L->data);
		InOrderTraverse2(L->rchild);
	}
	return OK;
}
Status PostOrderTraverse(BiTree T){
		if(T){
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		visit(T->data);
	}
	return OK;
}
Status LevelOrderTraverse(BiTree T){
	SqQueue Q;
	QElemType b;
	InitQueue(Q);
	if(T!=NULL){
		EnQueue(Q,T);
		while(!QueuenEmpty(Q)){
			DeQueue(Q,b);
			visit(b->data);
			if(b->lchild!=NULL)
				EnQueue(Q,b->lchild);
			if(b->rchild!=NULL)
				EnQueue(Q,b->rchild);
		}
	}
	return OK;
}
int Depth(BiTree T){
	int depthval = 0;
	int depthLeft,depthRight;
	if(!T) depthval = 0;
	else{
		depthLeft=Depth(T->lchild);
		depthRight = Depth(T->rchild);
		depthval = 1 + (depthLeft>depthRight?depthLeft:depthRight);
	}
	return depthval;
} 
int count_n(BiTree T){
	int num1,num2,num;
	if(T==NULL)num = 0;
	else{
		num1 = count_n(T->lchild);
		num2 = count_n(T->rchild);
		num = num1 + num2 +1;
	}
	return num;
}
int countleaft(BiTree T){//单独统计叶子结点 
	int num1,num2,num;
	if(T==NULL)num=0;
	else{
		if((T->lchild==NULL)&&(T->rchild==NULL))
			num = 1;
			else{
				num1 = countleaft(T->lchild);
				num2 = countleaft(T->rchild);
				num = num1 + num2;
			}
	}
	return num;
}
void count(BiTree L,int &n,int &n0,int &n1,int &n2)//统计所有节点数目 
{
	if(L)
	{
		n++;//所有节点 
		if(!L->lchild && !L->rchild)//结点 
			n0++;
		if((!L->lchild && L->rchild)||(!L->rchild && L->lchild))	//单叶子 
			n1++;
		if(L->lchild&&L->rchild)//双叶子 
			n2++;
		count(L->lchild,n,n0,n1,n2);
		count(L->rchild,n,n0,n1,n2);
	} 
}
void change_left_right(BiTree T){
	BiTree temp;
	if(T){
		change_left_right(T->lchild);
		change_left_right(T->rchild);
		temp = T->lchild;T->lchild = T->rchild;T->rchild = temp;
	}
} 
#endif

main.cpp

#include"include.h"
#include"Tree.h"

int main() {
	BiTree T,L;
	int n;
	printf("现在你对二叉树有以下操作：\n0——退出\n1——创建\n2——先序遍历\n3——中序遍历\n4——后序遍历\n5——层序遍历\n6——深度\n7——结点\n8——叶子节点\n9——统计所有结点\n"); 
	cin>>n;
	fflush(stdin);
	while(n){
		switch  (n){
			case 1:{
				printf("现在开始创建二叉树，以#作为结束符\n");
				CreateBiTree(T);
				break;
			}
			case 2:{
				printf("开始先序遍历：\n");
				PreOrderTraverse(T);
				break;
			}
			case 3:{
				printf("开始中序遍历：\n");
				InOrderTraverse(T);
				break;
			}
			case 4:{
				printf("开始后序遍历：\n");
				PostOrderTraverse(T);
				break;
			}
			case 5:{
				printf("开始层序遍历：\n");
				LevelOrderTraverse(T);
				printf("\n");
				break;
			}
			case 6:{
				int depth = Depth(T);
				printf("现在树的深度是：%d\n",depth);
				break;
			}
			case 7:{
				int count = count_n(T);
				printf("现在树的结点是：%d\n",count);
				break;
			}
			case 8:{
				int count = countleaft(T);
				printf("现在树的叶子结点是：%d\n",count);
				break;
			} 
			case 9:{
				int n=0,n0=0,n1=0,n2=0;
				count(T,n,n0,n1,n2);
				printf("节点：%d,结点：%d,单叶子：%d,双叶子：%d\n",n,n0,n1,n2);
				break;
			}
		}
		printf("继续操作：\n");
		scanf("%d",&n);
	} 
	printf("现在进行二叉排序树，请输入数字，以-1作为结尾\n");
	CreateBiTree1(L);
	printf("现在你可以对二叉排序树做以下操作：\n0——退出\n1——结点统计\n2——深度计算\n3——数据查找\n4——按序遍历\n5——统计所有的节点\n");
	cin>>n;
	fflush(stdin);
	while(n){
		switch(n){
			case 1:{
				int count = countleaft(L);
				printf("现在树的叶子结点是：%d\n",count);
				break;
			}
			case 2:{
				int depth = Depth(L);
				printf("现在树的深度是：%d\n",depth);
				break;
			}
			case 3:{
				BiTree E=NULL;
				ElemType x;
				printf("请输入需要查找的数据：\n");
				cin>>x;
				E = SearchBST(L,x);
				if(E==NULL)printf("查找失败！\n");
				else printf("查找成功！\n"); 
				break;
			}
			case 4:{
				printf("按序遍历：\n");
				InOrderTraverse2(L);
				printf("\n");
				break;
			}
			case 5:{
				int n=0,n0=0,n1=0,n2=0;
				count(L,n,n0,n1,n2);
				printf("节点：%d,结点：%d,单叶子：%d,双叶子：%d\n",n,n0,n1,n2);
				break;
			}
			default:{
				printf("输入有误！\n");
				break;
			}
		}
		printf("继续操作：\n");
		cin>>n;
		fflush(stdin);
	}
	return 0;
}

Tree.h

#ifndef TREE
#define TREE

#define MAX_TREE_SIZE 100
#define MAXSIZE 100
typedef char TElemType;
typedef int ElemType;
typedef int Status;
//typedef TElemType SqBiTree[MAX_TREE_SIZE];
//SqBiTree bt;
//链式存储
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiNode,*BiTree;
typedef BiTree QElemType;

typedef struct{
	QElemType *base;
	int front;
	int rear;
}SqQueue;
Status InitQueue(SqQueue &Q);
//int QueueLength(SqQueue Q);
Status EnQueue(SqQueue &Q,QElemType e);
Status DeQueue(SqQueue &Q,QElemType &e);
Status DestroyQueue(SqQueue &Q);
//Status GetHead(SqQueue Q,QElemType &e);
Status QueuenEmpty(SqQueue Q);

Status  CreateBiTree(BiTree &T);
void PreInCreat (BiTree &T,ElemType pre[],int[],int l1,int h1,int l2,int h2);
void visit(TElemType e);
Status PreOrderTraverse(BiTree T);
Status InOrderTraverse(BiTree T);
Status PostOrderTraverse(BiTree T);
Status LevelOrderTraverse(BiTree T); 
int Depth(BiTree T);
int count_n(BiTree T);
int countleaft(BiTree T);
void change_left_right(BiTree T);
void CreateBiTree1(BiTree &root);
void insert(BiTree &T,ElemType x);
BiTree SearchBST2(BiTree L,ElemType x);
BiTree SearchBST(BiTree L,TElemType x);
void insert(BiTree &T,ElemType x);
void CreateBiTree1(BiTree &root);
Status InOrderTraverse2(BiTree L);
void visit2(ElemType e);
Status GetHead(SqQueue Q,QElemType &e);
int QueueLength(SqQueue Q); 
void count(BiTree L,int &n,int &n0,int &n1,int &n2); 
#endif

include.h


#ifndef INCLUDE
#define INCLUDE
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define OK 1
#define ERROR -1


#endif

最后的话

代码仅做参考和本人的学习记录，请不要用于其他途径。
刚写博客不久，没有注释说明，请谅解，学艺不精，请指正。

Fli2ped
关注
专栏目录
数据结构实验报告《四、二叉树及其应用》
11-29
数据结构实验报告 《四、二叉树及其应用》
数据结构实验课：实验五、二叉树操作及应用
listboy的博客
05-19 9115
实验五、二叉树操作及应用 一、 实验目的 掌握二叉树的定义、结构特征，以及各种存储结构的特点及使用范围，各种遍历算法。掌握用指针类型描述、访问和处理二叉树的运算。掌握前序或中序的非递归遍历算法。 二、 实验要求 有如下二叉树： 程序代码给出了该二叉树的链式存储结构的建立、前序、中序、后序遍历的算法，同时也给出了查询“E”是否在二叉树里的代码。代码有三处错误，有标识，属于逻辑错误，对照书中的代码仔细分析后，请修改了在电脑里运行。 #include <stdlib.h> #include <s
数据结构——二叉树
最新发布
weixin_74889808的博客
09-21 725
/子树//同一根结点的兄弟结点//树的值。
数据结构实验三：二叉树及其应用
weixin_34218890的博客
01-05 239
设计两种输入模式建立一棵二叉树；输出该二叉树的深度；输出二叉树的子叶结点#include&lt;stdio.h&gt;#include&lt;malloc.h&gt;struct node{    char data;    struct node *lchild;    struct node *rchild;};node * creat(node *p){    char ch;    sca...
二叉树实验 （数据结构）
Popcorn_zyh的博客
11-03 1625
二叉树的遍历 数据结构 实验报告
数据结构二叉树的实验练习
c673929079的博客
04-20 1303
数据结构二叉树的实验练习
算法与数据结构实验报告——树及其应用.docx
07-12
《算法与数据结构实验报告——树及其应用》深入探讨了树这一重要的数据结构在实际问题中的应用。树因其非线性的特性，在计算机科学领域扮演着关键角色，它被广泛应用于互联网技术，例如搜索引擎的索引构建、文件系统...
数据结构实验——分类二叉树和堆排序.doc
06-13
【数据结构实验——分类二叉树和堆排序】 在数据结构的学习中，分类二叉树和堆排序是两个重要的概念，它们在实际的编程和算法设计中有着广泛的应用。本实验旨在让学生深入理解和掌握这两种数据结构及其操作。 分类...
数据结构实验报告——二叉树
11-14
### 数据结构实验报告——二叉树 #### 实验概述与目的 本次实验的主题是围绕“二叉树”这一核心概念展开。二叉树作为一种重要的非线性数据结构，在计算机科学中有着广泛的应用，例如在搜索算法、排序算法、编译器...
数据结构实验——二叉树
The_star_is_at的博客
04-30 1141
// // main.cpp // 160929 // // Created by 刘哲 on 17/4/28. // Copyright © 2016年 my_code. All rights reserved. //#include #include #include #include #include #include #include #include #incl
实验4 树及其应用——二叉树的遍历
Jegret的博客
01-28 917
【实验目的】 使学生深入了解并掌握非线性数据结构的特点，掌握创建二叉树二叉链表存储结构的方法；同时深刻理解二叉树的各遍历过程。 【实验内容】 问题描述：很多涉及二叉树操作的算法都是以二叉树遍历为基础的。本实验要求编写程序，对一棵给定的二叉树进行先、中、后三种次序的遍历。 基本要求：以二叉链表为存储结构，实现二叉树的先、中、后三种次序的递归遍历。 实现提示： （１）设二叉树的结点不超过30个，每个结点的数据均为字符，这样可用先序遍历序列作为输入，顺序创建二叉树链表存储结构。 （２）也可利用完全二叉树在顺序存
数据结构实验（二叉树）
07-10
数据结构实验，二叉树类型的实现，完美代码、报告。
数据结构二叉树的实验（）
07-18
数据结构实验二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树二叉树
数据结构实验-3二叉树遍历与路径查找（二叉树实验）
08-03
实验三 二叉树遍历与路径查找（二叉树实验） 实现功能：建立二叉树存储结构、求二叉树的先序遍历、求二叉树的中序遍历、求二叉树的后序遍历、求二叉树的层次遍历、求根到给定结点的路径。 主控菜单： 1．建立二叉树存储结构 2．求二叉树的先序遍历 3．求二叉树的中序遍历 4．求二叉树的后序遍历 5．求二叉树的层次遍历 6．求根到给定结点的路径 0．退出系统 请选择0—6： 实现菜单1、0的功能：建立二叉树存储结构、退出系统 实现菜单2、3、4的功能：求二叉树的先序遍历、求二叉树的中序遍历、求二叉树的后序遍历 实现菜单5的功能：求二叉树的层次遍历 实现菜单6的功能：求根到给定结点的路径
数据结构实验：二叉树的基本操作
12-04
南邮数据结构实验使用C++描述，二叉树的基本操作
数据结构之二叉树实验
// 在校菜鸟大学生的日常学习博客
09-01 4722
二叉树实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过实验掌握二叉树的基本存储结构； 掌握二叉树的建立与遍历的基本算法，并加以应用； 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握二叉树的链式存储结构—二叉链表的定义、构造、遍历等基本操作； 实验内容 完成二叉树的二叉链表的存储结构的定义、创建、前序遍历、中序遍历、后序遍历、求叶子数和求深度等函数的编写。完成以下函数的编写： (1) 编写一个函数输出结点的值。visit( BiTree T) (2)编写一个函
数据结构实验——二叉树实验
躺在草地看天空的博客
05-04 1833
实验要求实验源代码#include <stdio.h> #include <malloc.h>typedef struct TREE{ int data; struct TREE *left; struct TREE *right; }Tree,*linkTree;linkTree creatTree(int data); // 中序遍历 void inorderTree(l
二叉树实验数据结构
wsswsswss123的博客
03-30 1734
```cpp 《数据结构》实验报告 程序名： 二叉树实验 一、上机实验的问题和要求： 设计一个程序来对二叉树进行操作，具体功能要求如下： 1.通过输入带虚结点（用#表示）的前序序列来生成一棵二叉树（参考实验课本的验证实验）。 2.按前序序列顺序输出只有一个孩子的结点。 3.求解二叉树的镜像并输出（交换左右孩子）。 4.求解二叉树的高度并输出 二、程序设计的基本思想，原理和算法描述： （分.
数据结构之二叉树及其应用
m0_72936412的博客
06-12 830
数据结构之二叉树及其应用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值