实验三 树的应用

最新推荐文章于 2022-06-21 22:32:00 发布
原创 最新推荐文章于 2022-06-21 22:32:00 发布 · 367 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #树的基本操作 

// BTreeFinal.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"


/*
** 树的构建和遍历实现
** 需要借助栈和队列来实现
*/


#include <iostream>
using namespace std;

const int STACK_INIT_SIZE = 20;		//顺序栈容量
const int QUEUE_INIT_SIZE = 20;		//循环队列容量
const int ERROR = 0;
const int OK = 1;
const int EMPTY = 1;

typedef int Status;

//顺序栈的模板实现
template <typename T>
class SqStack
{
public:
	SqStack();
	~SqStack();
	T GetTop() const;
	Status Push(T &e);
	Status Pop(T &e);
	int stackLength() const;
	Status IsEmpty() const;

private:
	T * base;		//栈的起始位置
	T *top;			//栈顶指针
	int stackSize;	//栈的容量
};

//构造函数
//初始化一个栈
template <typename T>
SqStack<T>::SqStack()
{
	base = new T[STACK_INIT_SIZE];	//申请空间
	top = base;
	stackSize = STACK_INIT_SIZE;	//更新当前栈长
}

//析构函数
//释放一个栈
template <typename T>
SqStack<T>::~SqStack()
{
	delete[] base;
}

//取栈顶元素
template <typename T>
T SqStack<T>::GetTop() const
{
	if (top == base)
	{
		cerr << "当前栈为空" << endl;
	}
	T e = *(top - 1);
	return e;
}

//顺序栈入栈
template <typename T>
Status SqStack<T>::Push(T &e)
{
	if (top - base >= stackSize)	//栈满
	{
		return ERROR;
	}
	*top++ = e;	//先赋值，再加指针
	return OK;
}

//顺序栈出栈
template <typename T>
Status SqStack<T>::Pop(T &e)
{
	if (top == base)
	{
		return ERROR;	//栈空
	}
	e = *--top;	//先赋值，再加指针
	return OK;
}

//求栈长
template <typename T>
int SqStack<T>::stackLength() const
{
	return (top - base);
}

//判断栈是否为空
template <typename T>
Status SqStack<T>::IsEmpty() const
{
	if (top == base)
	{
		return EMPTY;	//栈空
	}
	else
	{
		return !EMPTY;	//栈非空
	}
}


//循环队列的模板实现
template <typename T>
class CircularQueue
{
public:
	CircularQueue();
	~CircularQueue();
	Status EnQueue(T e);
	Status DeQueue(T &e);
	int QueueLength() const;
	Status IsEmpty() const;

private:
	T * base;		//内存空间的首地址
	int front;		//头指针
	int rear;		//尾指针
	int queueSize;	//队列的长度
};

//构造函数
//初始化队列
template <typename T>
CircularQueue<T>::CircularQueue()
{
	base = new T[QUEUE_INIT_SIZE];
	if (base == nullptr)
	{
		cerr << "内存分配错误！！" << endl;
	}
	rear = front = 0;
	queueSize = QUEUE_INIT_SIZE;
}

//析构函数
//释放空间
template <typename T>
CircularQueue<T>::~CircularQueue()
{
	delete[] base;
}

//循环队列元素入队
template <typename T>
Status CircularQueue<T>::EnQueue(T e)
{
	if ((rear + 1) % QUEUE_INIT_SIZE == front)	//队列已满
	{
		return ERROR;
	}
	base[rear] = e;
	rear = (rear + 1) % QUEUE_INIT_SIZE;	//尾指针后移
	return OK;
}

//循环队列元素出队
template <typename T>
Status CircularQueue<T>::DeQueue(T &e)
{
	if (rear == front)	//队列为空
	{
		return ERROR;
	}
	e = base[front];
	front = (front + 1) % QUEUE_INIT_SIZE;	//删除一个元素后头指针后移
	return OK;
}


//求循环队列的长度
template <typename T>
int CircularQueue<T>::QueueLength() const
{
	//确保其为一个整数再取模
	return (rear - front + QUEUE_INIT_SIZE) % QUEUE_INIT_SIZE;
}

//判断该循环队列是否为空
template <typename T>
Status CircularQueue<T>::IsEmpty() const
{
	return (rear == front) ? EMPTY : !EMPTY;
}


//二叉链表表示的树节点
template <class T>
class BTNode
{
public:
	T data;			//存储该节点的相关数据信息
	BTNode *lChild;	//左孩子节点
	BTNode *rChild;	//右孩子节点
};


//二叉树类定义
template <typename T>
class BTree
{
public:
	BTree();
	~BTree();
	void PreOrderDispTree(BTNode<T> *const &t) const;
	void PreOrderDispTreeRE(BTNode<T> *t) const;
	void InOrderDispTree(BTNode<T> *t) const;
	void InOrderDispTreeRE(BTNode<T> *t) const;
	void PostOrderDispTree(BTNode<T> *t) const;
	void PostOrderDispTreeRE(BTNode<T> *t) const;
	void levelDispTree(BTNode<T> *t) const;
	void createBTree(char *str);
	int getBTreeHeight(BTNode<T> *t) const;
	void DispBTree(BTNode<T> *t) const;
	BTNode<T>* getRoot() { return root; }
	void destory(BTNode<T> *&t);
private:
	BTNode<T> *root;	//二叉树的根节点
};

//构造函数
//初始化该树
template <class T>
BTree<T>::BTree()
{
	root = nullptr;
}

//析构函数
template <class T>
BTree<T>::~BTree()
{
	destory(root);
}

//销毁树结构
//相当于树的后序遍历
template <class T>
void BTree<T>::destory(BTNode<T> *&t)
{
	if (t != NULL)
	{
		destory(t->lChild);
		destory(t->rChild);
		delete t;
	}
}

//先序遍历算法 -- 递归实现
//按照根-左-右的顺序
template <typename T>
void BTree<T>::PreOrderDispTree(BTNode<T> *const &t) const
{
	if (t != nullptr)		//根节点不为空
	{
		cout << t->data;
		PreOrderDispTree(t->lChild);	//递归遍历左子树
		PreOrderDispTree(t->rChild);	//递归遍历右子树
	}
}

//先序遍历算法
//非递归实现  --  利用栈
template <typename T>
void BTree<T>::PreOrderDispTreeRE(BTNode<T> *t) const
{
	SqStack<BTNode<T>*> s;	//声明一个指针栈
	BTNode<T> *p = t;		//开始时指向根

	while (p != nullptr || !s.IsEmpty())
	{
		while (p != nullptr)
		{
			cout << p->data;
			s.Push(p);
			p = p->lChild;
		}
		//通过下一次循环中的内嵌while实现右子树的遍历
		if (!s.IsEmpty())
		{
			s.Pop(p);	//将当前子树的根节点出栈访问右节点
			p = p->rChild;
		}
	}
	cout << endl;
}

//中序遍历算法 -- 递归实现
//按照左---根---右的顺序
template <typename T>
void BTree<T>::InOrderDispTree(BTNode<T> *t) const
{
	if (t != nullptr)
	{
		InOrderDispTree(t->lChild);		//中序遍历左子树
		cout << t->data;
		InOrderDispTree(t->rChild);		//中序遍历右子树
	}
}

//中序遍历算法
//非递归实现
template <typename T>
void BTree<T>::InOrderDispTreeRE(BTNode<T> *t) const
{
	SqStack<BTNode<T>*> s;
	BTNode<T> *p = t;

	while (p != nullptr || !s.IsEmpty())
	{
		while (p != nullptr)
		{
			s.Push(p);
			p = p->lChild;
		}
		if (!s.IsEmpty())
		{
			s.Pop(p);
			cout << p->data;	//访问根节点
			p = p->rChild;		//通过下一次循环来实现右子树遍历
		}
	}
	cout << endl;
}

//后序遍历算法 -- 递归实现
//按照左---右---根的顺序
template <typename T>
void BTree<T>::PostOrderDispTree(BTNode<T> *t) const
{
	if (t != nullptr)
	{
		PostOrderDispTree(t->lChild);
		PostOrderDispTree(t->rChild);
		cout << t->data;
	}
}

//后序遍历算法
//非递归实现
//采用双栈法实现
template <typename T>
void BTree<T>::PostOrderDispTreeRE(BTNode<T> *t) const
{
	if (t != nullptr)
	{
		SqStack<BTNode<T>*> s1;
		SqStack<BTNode<T>*> s2;
		BTNode<T> *p = nullptr;
		s1.Push(t);
		while (!s1.IsEmpty())
		{
			s1.Pop(p);
			s2.Push(p);
			if (p->lChild != nullptr)
			{
				s1.Push(p->lChild);
			}
			if (p->rChild != nullptr)
			{
				s1.Push(p->rChild);
			}
		}
		while (!s2.IsEmpty())
		{
			//出栈序列即为后序遍历序列
			s2.Pop(p);
			cout << p->data;
		}
	}
	cout << endl;
}


//层次遍历
//借助循环队列实现
template <typename T>
void BTree<T>::levelDispTree(BTNode<T> *t) const
{
	CircularQueue<BTNode<T>*> queue1;
	BTNode<T> *p = t;
	BTNode<T> *q = nullptr;
	if (t != nullptr)
	{
		queue1.EnQueue(p);	//根节点进队列
		while (!queue1.IsEmpty())
		{
			queue1.DeQueue(q);
			cout << q->data;
			if (q->lChild != nullptr)
			{
				queue1.EnQueue(q->lChild);
			}
			if (q->rChild != nullptr)
			{
				queue1.EnQueue(q->rChild);
			}
		}
	}
	cout << endl;
}

//根据广义表类型创建二叉树
template <typename T>
void BTree<T>::createBTree(char *str)
{
	//需要用到存放BTree的堆栈
	SqStack<BTNode<T>*> s;
	BTNode<T> *p = nullptr;
	int j = 0;	//当前处理字符的标志
	int k = -1;	//当前处理字符的左右标志
	char ch;
	ch = str[j];	//逐个处理字符

	while (ch != '\0')	//到字符串尾部
	{
		switch (ch)
		{
		case '(':
			s.Push(p);	//将根节点入栈，设置处理左子树
			k = 1;		//表示后面节点为前面节点的左孩子
			break;
		case ')':
			s.Pop(p);
			break;
		case ',':
			k = 2;	//设置处理右子树
			break;
		default:
			p = new BTNode<T>;
			p->data = ch;
			p->lChild = nullptr;
			p->rChild = nullptr;
			if (root == nullptr)
			{
				root = p;	//设置根节点
			}
			else
			{
				if (k == 1)
				{
					s.GetTop()->lChild = p;
				}
				if (k == 2)
				{
					s.GetTop()->rChild = p;
				}
			}
		}
		ch = str[++j];
	}
}

//计算二叉树的高度
template <typename T>
int BTree<T>::getBTreeHeight(BTNode<T> *t) const
{
	int lChildHeight = -1;
	int rChildHeight = -1;
	if (t == nullptr)
	{
		return 0;
	}
	else
	{
		lChildHeight = getBTreeHeight(t->lChild);
		rChildHeight = getBTreeHeight(t->rChild);
		return (lChildHeight > rChildHeight ? lChildHeight + 1 : rChildHeight + 1);
	}
}

//输出二叉树
template <typename T>
void BTree<T>::DispBTree(BTNode<T> *t) const
{
	if (t != nullptr)
	{
		cout << t->data;
		if ((t->lChild != nullptr) || (t->rChild != nullptr))
		{
			cout << '(';
			DispBTree(t->lChild);
			if (t->rChild != nullptr)
			{
				cout << ',';
			}
			DispBTree(t->rChild);
			cout << ')';
		}
	}
}

int main()
{
	BTree<char> tree;
	char str[] = "A(B(D(,G)),C(E,F))";
	cout << "-----二叉树功能测试-----" << endl;
	tree.createBTree(str);
	BTNode<char> *root = tree.getRoot();
	cout << "这棵树的结构为：";
	tree.DispBTree(root);
	cout << endl;
	cout << "先序遍历递归实现:";
	tree.PreOrderDispTree(root);
	cout << endl;
	cout << "先序遍历非递归实现：";
	tree.PreOrderDispTreeRE(root);
	cout << "中序遍历递归实现:";
	tree.InOrderDispTree(root);
	cout << endl;
	cout << "中序遍历非递归实现：";
	tree.InOrderDispTreeRE(root);
	cout << "后序遍历递归实现:";
	tree.PostOrderDispTree(root);
	cout << endl;
	cout << "后序遍历非递归实现：";
	tree.PostOrderDispTreeRE(root);
	cout << "层序遍历结果为:";
	tree.levelDispTree(root);
	cout << "树的高度为:";
	cout << tree.getBTreeHeight(root) << endl;

	return 0;
}

在这里插入图片描述

数据结构 实验三 树的应用
weixin_51733609的博客
11-24 1737
一、实验内容： 1、以字符串输入形式创建一棵二叉树（提示：可以是简单的一个字符作为二叉树中一个结点；也可以是以学校管理层次体系或者族谱为蓝本，将表示该实际问题的树结构转换为对应的二叉树后，再以二叉树的创建方法来创建这棵具有实际意义的树结构。） 2、对构建的二叉树分别采用先序、中序、后序遍历算法输出每个结点数据。 3、选作题：统计叶结点的个数；计算二叉树的高度。 二、实验原理： 1、树的逻辑结构特点：树(tree)是n(n≥0)个结点的有限集T，其中： （1）有且仅有一个特定的结点，称为树的根(root)；
实验三 二叉树应用 刘立嘉
12-07
石家庄铁道大学 刘立嘉 算法与数据结构 实验三 二叉树应用
数据结构实验报告7-树-二叉树的字符图形显示程序(半期测试)-实验内容与要求.docx
07-06
设二叉树采用二叉链表存储结构，结点数据域为字符类型。编写控制台应用程序采用先序遍历法建立二叉树存储结构并实现二叉树的字符图形显示。
实验题：树的应用
m0_51625133的博客
10-24 590
实验内容： 以二叉树链表做存储结构，设计求二叉树高度的算法。 一颗树n个结点的完全二叉树用向量做存储结构，用非递归算法实现对该二叉树进行前序遍历。 以二叉树链表做存储结构，编写非递归的前序、中序、后续遍历算法。 实验代码： #include<iostream> #include<malloc.h> #include<stack> using namespace std; #define OK 1; #define ERROR 0; typedef int
树的应用
xiaomimi1993的博客
08-07 4191
二叉排序树 平衡二叉树 哈夫曼树及哈夫曼编码
精选资源
实验三 决策树算法实验实验报告.pdf
07-01
本实验报告主要关注的是决策树算法的实践应用，旨在帮助学生理解其分类原理和实现过程。 实验原理基于决策树学习和分类，决策树通过不断选择最优属性进行划分，以最大化信息增益或基尼指数，直到所有样本属于同一...
精选资源
算法与数据结构实验报告——树及其应用.docx
07-12
《算法与数据结构实验报告——树及其应用》深入探讨了树这一重要的数据结构在实际问题中的应用。树因其非线性的特性，在计算机科学领域扮演着关键角色，它被广泛应用于互联网技术，例如搜索引擎的索引构建、文件系统...
C++数据结构实验三：树的应用
01-16
3．了解树在计算机科学及其他工程技术中的应用。 4. 掌握树和二叉树的逻辑结构特点、二叉树的顺序存储结构、二叉树的链式存储结构——二叉链表、二叉链表的结构体类型定义、在二叉链表存储结构上先序遍历、中序遍历...
算法与数据结构实验：树的应用
最新发布
01-10
实验内容的第三个方面是要求学生掌握树的应用算法，如构建二叉树、判断二叉搜索树和计算二叉树的宽度等。构建二叉树是通过后序和中序遍历的结果来恢复原始二叉树的结构。这一过程不仅考验学生对二叉树遍历序列的理解...
实验三 二叉树
九大于七的博客
10-29 1041
广义表转二叉树和层序遍历 简单介绍了二叉树及其性质
所有关于树的函数实现
11-09
所有关于树的函数实现 数据结构与算法 所有关于树的函数实现
树的应用——使用并查集解决动态连通性问题（含C++代码实现）（中篇：快速合并）
weixin_51461842的博客
11-07 848
上篇：树的应用——使用并查集解决动态连通性问题（含C++代码实现）（上篇：快速查找） 第二种设计：快速合并 Quick-union 在这种设计中，数据结构id[]还是一个整数类型的数组，其索引的含义与之前（上篇：快速查找）相同。但与之前有所不同的是，我们用树来表示连通分量，相互连通的对象之间存在双亲与孩子的关系。id[]中存储的值是其索引对应的对象的双亲对象的索引 (值=双亲的索引）。例如： 对应于id[5]： index 0 1 2 3 4 value 1 2 2 2 4 “0号对象
树的应用——并查集及实现代码
薛定谔的猫的博客
11-06 392
文章目录什么是并查集亲戚问题并查集的实现改进——路径压缩并查集的用途 什么是并查集  并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示。  并查集支持以下3种操作： 初始化（Initial）：将集合中的每个元素初始化为只有一个单元素的子集合。 合并（Union）：把两个不相交的集合合并为一个集合。 查询（Find）：查询两个元素是否在同一个集合中。 这样来说还是有点抽象，所以先来看看并查集最直接的一个应用场景：亲戚问题。 亲戚问
树的介绍以及应用
YZG ' BLOG
12-28 1494
目录 一、树的介绍 1、数组存储方式的分析 2、链式存储方式的分析 3、树存储方式的分析 二、树的常用术语 三、二叉树的概念 四、二叉树的遍历 1、二叉树的应用 2、代码实现： 五、顺序存储二叉树 1、基本说明 2、 顺序存储二叉树的特点: 3、应用： 4、代码实现： 六、线索化二叉树 1、基本介绍 ...
华东理工数据结构实验-树
weixin_56213139的博客
06-21 812
选取了数据结构中四个有关树的实验
大学数据结构实验(四.树型结构及其应用四)
weixin_42473228的博客
10-28 795
大学程序实验.数据结构.树型结构及其应用四.算子树数0 目录4 树型结构及其应用4.4 算子树数4.4.1 题目4.4.2 源码 0 目录 4 树型结构及其应用 4.4 算子树数 4.4.1 题目 编写算法求二叉树中某个结点的子孙结点(不包括该结点)为多少个。 4.4.2 源码 // 算子树数.cpp : Defines the entry point for the console ...
20162302 实验二《树》实验报告
weixin_30561177的博客
10-29 699
实 验 报 告 课程：程序设计与数据结构 姓名：杨京典 班级：1623 学号：20162302 实验名称：树 实验器材：装有IdeaU的联想拯救者15ISK 实验目的与要求： 1.实现二叉树 2.中序先序序列构造二叉树 3.决策树 4.表达式树 5.二叉查找树 6.红黑树分析 实验内容、步骤与体会： 实验内容： 实现二叉树LinkedBinaryTree 书上已给出接口BinaryTr...
20172319 实验二《树》实验报告
weixin_30889885的博客
11-11 834
20172319 2018.11.04-11.12 实验二《树》 实验报告 课程名称:《程序设计与数据结构》 学生班级：1723班 学生姓名：唐才铭 学生学号：20172319 实验教师：王志强老师 课程助教：张师瑜学姐、张之睿学长 实验时间：2018年11月04日——2018年11月12日 必修/选修：必修 目录 实验内容 实验要求 实验步骤 代码实现及解释 测试过程及...
实验 5：树和二叉树的实验 2
M_Mango的博客
05-23 390
一、实验目的 1、 熟练理解树和二叉树的相关概念，掌握的存储结构和相关操作实现； 2、 掌握树的顺序结构的实现； 3、 学会运用树的知识解决实际问题 二、 实验内容 自己确定一个二叉树（树结点类型、数目和结构自定）利用链式存储结构方法存储。实 现树的构造，并完成： 1） 用前序遍历、中序遍历、后序遍历输出结点数据；  2） 以合理的格式，输出各个结点和双亲、孩子结点信息； 3） 输出所有的叶子结点...
树的应用在数据结构实验三中的实现
标题和描述提及的“数据结构 实验三源码.zip”与“数据结构 实验三 树的应用”暗示了本次实验的核心内容是数据结构中树的应用。从文件名称列表“实验三”我们可以得知，这是一个特定的实验项目，可能是针对树这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值