数据结构探险——树篇（代码实现）

最新推荐文章于 2024-04-06 12:01:41 发布
最新推荐文章于 2024-04-06 12:01:41 发布
阅读量522 收藏 1
点赞数
分类专栏： C++ 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuyin1204/article/details/106433938
版权

imooc相关学习视频.

数据结构探险——树篇

1、什么是树？

树是节点的有限集合
树中相关的概念
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2、什么是二叉树？

定义：所有结点的度都小于等于2

二叉树的遍历分为三种，这三种遍历方式是相对于根节点来说的
1）前序遍历—>遍历顺序是：根–左--右
2）中序遍历—>遍历顺序是：左–根--右
3）后序遍历—>遍历顺序是：左–右--根
在这里插入图片描述

3、树的用途

1）压缩软件 --赫夫曼树
2）搜索 --人机对战

4、二叉树数组实现编码

4.1 相关说明

关于数组与树之间的算法转换
int tree[n] 3 5 8 2 6 9 7
父亲结点下标✖2+1——该结点左
父亲结点下标✖2+2——该结点右
    3(0)
 5(1)      8(2)
2(3) 6(4) 9(5) 7(6)

二叉树（数组表示）
完成树的基本操作;
1）树的创建和销毁
2）树中节点的搜索
3）树中节点的添加与删除
4）树中节点的遍历
C语音表示：
BOOL CreateTree(Tree **pTree, Node *pRoot); //创建树
void DestroyTree(Tree *pTree); //销毁树
Node *SearchNode(Tree *pTree, int nodeIndex); //根据索引寻找节点
BOOL AddNode(Tree *pTree, int nodeIndex, int direction, Node *pNode); //添加节点
BOOL DeleteNode(Tree *pTree, int nodeIndex, Node *pNode); //删除节点
void TreeTraverse(Tree *pTree); // 遍历

4.2 编码实现

第一个测试代码
Tree.h–>定义二叉树相关功能接口和元素的头文件（存入的数据都是int类型）

#ifndef TREE_H_
#define TREE_H_

class Tree
{
public:
	Tree(int size, int *pRoot);                             //创建树
	~Tree();                                                //销毁树
	int *SearchNode(int nodeIndex);                         //根据索引寻找结点
	bool AddNode(int nodeIndex, int direction, int *pNode); //添加结点
	bool DeleteNode(int nodeIndex, int *pNode);             //删除结点
	void TreeTraverse();                                    //遍历结点

private:
	int *m_pTree;
	int m_iSize;
};

#endif /* TREE_H_ */

Tree.cpp–>实现二叉树相关功能代码

#include <iostream>
#include "Tree.h"
using namespace std;

Tree::Tree(int size, int* pRoot)
{
	m_iSize = size;
	m_pTree = new int[size];
	for (int i = 0; i < size; i++) {
		m_pTree[i] = 0;
	}
	m_pTree[0] = *pRoot;
}

Tree::~Tree()
{
	delete[] m_pTree;
	m_pTree = NULL;
}

int *Tree::SearchNode(int nodeIndex)
{
	if (nodeIndex < 0 || nodeIndex >= m_iSize) {
		return NULL;
	}
	if (0 == m_pTree[nodeIndex]) {
		return NULL;
	}
	return &m_pTree[nodeIndex];
}

bool Tree::AddNode(int nodeIndex, int direction, int *pNode)
{
	if (nodeIndex < 0 || nodeIndex >= m_iSize) {
		return false;
	}
	if (m_pTree[nodeIndex] == 0) {
		return false;
	}
	if (0 == direction) { // 0表示左孩子
		if (nodeIndex * 2 + 1 >= m_iSize) {
			return false;
		}
		if (m_pTree[nodeIndex * 2 + 1] != 0) { //该位置已经有其他结点
			return false;
		}
		m_pTree[nodeIndex * 2 + 1] = *pNode;
	}

	if (1 == direction) { // 1表示右孩子
		if (nodeIndex * 2 + 2 >= m_iSize) {
			return false;
		}
		if (m_pTree[nodeIndex * 2 + 2] != 0) { //该位置已经有其他结点
			return false;
		}
		m_pTree[nodeIndex * 2 + 2] = *pNode;
	}
	return true;
}

bool Tree::DeleteNode(int nodeIndex, int *pNode)
{
	if (nodeIndex < 0 || nodeIndex >= m_iSize) {
		return false;
	}
	if (0 == m_pTree[nodeIndex]) {
		return false;
	}
	*pNode = m_pTree[nodeIndex];
	m_pTree[nodeIndex] = 0;
	return true;
}

void Tree::TreeTraverse()
{
	for (int i = 0; i < m_iSize; i++) {
		cout << m_pTree[i] << " ";
	}
	cout << endl;
}

TreeDemo.cpp–>测试入口代码文件

#include <iostream>
#include "Tree.h"
using namespace std;

int main() {
	int root = 3;
	Tree *pTree = new Tree(10, &root);
	int node1 = 5;
	int node2 = 8;
	pTree->AddNode(0, 0, &node1);
	pTree->AddNode(0, 1, &node2);

	int node3 = 2;
	int node4 = 6;
	pTree->AddNode(1, 0, &node3);
	pTree->AddNode(1, 1, &node4);

	int node5 = 9;
	int node6 = 7;
	pTree->AddNode(2, 0, &node5);
	pTree->AddNode(2, 1, &node6);
	pTree->TreeTraverse();


	int *temp = pTree->SearchNode(2);
	cout << "temp=" << *temp << endl;

	int node = 0;
	pTree->DeleteNode(5, &node);
	cout << "node=" << node << endl;
	pTree->TreeTraverse();

	delete pTree;
	pTree = NULL;
	return 0;
}

测试结果为：

3 5 8 2 6 9 7 0 0 0 
temp=8
node=9
3 5 8 2 6 0 7 0 0 0

5、二叉树链表实现编码

5.1 相关说明

二叉树：链表实现
Tree(); //创建树
~Tree(); //销毁树
Node *SearchNode(int nodeIndex); //搜索结点
bool AddNode(int nodeIndex, int direction, Node *pNode); //添加结点
bool DeleteNode(int nodeIndex, Node *pNode); //删除结点
void PreorderTraversal(); //前序遍历
void InorderTraversal(); //中序遍历
void PostorderTraversal(); //后序遍历
结点要素：索引 数据 左孩子指针 右孩子指针 父结点指针
      (0)
 5(1)      8(2)
2(3) 6(4) 9(5) 7(6)

上面树进行遍历：
前序遍历：0 1 3 4 2 5 6
中序遍历：3 1 4 0 5 2 6
后序遍历：3 4 1 5 6 2 0

5.2 编码实现

第二个测试代码
Node.h–>定义结点相关功能接口和元素的头文件（存入的数据都是Node类型，包含一个整型的index索引，一个int的data数据）

#ifndef NODE_H_
#define NODE_H_

class Node
{
public:
	Node();
	Node *SearchNode(int nodeIndex);
	void DeleteNode();
	void PreorderTraversal();
	void InorderTraversal();
	void PostorderTraversal();
	int index;
	int data;
	Node *pLChild;
	Node *pRChild;
	Node *pParent;
};

#endif /* NODE_H_ */

Node.cpp–>实现树中节点相关功能代码

#include <iostream>
#include "Node.h"
using namespace std;

Node::Node()
{
	index = 0;
	data = 0;
	pLChild = NULL;
	pRChild = NULL;
	pParent = NULL;
}

Node *Node::SearchNode(int nodeIndex)
{
	if (this->index == nodeIndex)
	{
		return this;
	}
	Node *temp = NULL;
	if (this->pLChild != NULL) {
		if (this->pLChild->index == nodeIndex) { //查找index为该结点的左孩子
			return this->pLChild;
		} else { //没查找到index继续在找到该结点的左孩子下面继续查找
			temp = this->pLChild->SearchNode(nodeIndex);
			if(temp != NULL) {
				return temp;
			}
		}
	}
	if (this->pRChild != NULL) {
		if (this->pRChild->index == nodeIndex) {
			return this->pRChild;
		}  else {
			temp = this->pRChild->SearchNode(nodeIndex);
			if(temp != NULL) {
				return temp;
			}
		}
	}
	return NULL;
}

void Node::DeleteNode()
{
	if (this->pLChild != NULL) {
		this->pLChild->DeleteNode();
	}
	if (this->pRChild != NULL) {
		this->pRChild->DeleteNode();
	}
	if (this->pParent != NULL) {
		if (this->pParent->pLChild == this) {
			this->pParent->pLChild = NULL;
		}
		if (this->pParent->pRChild == this) {
			this->pParent->pRChild = NULL;
		}
	}
	delete this;
}

void Node::PreorderTraversal()
{
	cout << this->index << "   " << this->data << endl;
	if (this->pLChild != NULL) {
		this->pLChild->PreorderTraversal();
	}
	if (this->pRChild != NULL) {
		this->pRChild->PreorderTraversal();
	}
}

void Node::InorderTraversal()
{
	if (this->pLChild != NULL) {
		this->pLChild->InorderTraversal();
	}
	cout << this->index << "   " << this->data << endl;
	if (this->pRChild != NULL) {
		this->pRChild->InorderTraversal();
	}
}

void Node::PostorderTraversal()
{
	if (this->pLChild != NULL) {
		this->pLChild->PostorderTraversal();
	}
	if (this->pRChild != NULL) {
		this->pRChild->PostorderTraversal();
	}
	cout << this->index << "   " << this->data << endl;
}

Tree.h–>修改后的定义树中相关功能接口和元素的头文件（存入的数据都是int类型）

#ifndef TREE_H_
#define TREE_H_

#include "Node.h"

class Tree
{
public:
	Tree();                                                 //创建树
	~Tree();                                                //销毁树
	Node *SearchNode(int nodeIndex);                         //搜索结点
	bool AddNode(int nodeIndex, int direction, Node *pNode); //添加结点
	bool DeleteNode(int nodeIndex, Node *pNode);            //删除结点
	void PreorderTraversal();                               //前序遍历
	void InorderTraversal();                                //中序遍历
	void PostorderTraversal();                              //后序遍历

private:
	Node *m_pRoot;
};

#endif /* TREE_H_ */

Tree.cpp–>修改后的实现树的相关功能代码

#include <iostream>
#include "Tree.h"
using namespace std;


Tree::Tree()
{
	m_pRoot = new Node();
}

Tree::~Tree()
{
	//DeleteNode(0, NULL);     //第一种表示方式
	m_pRoot->DeleteNode();  //第二种表示方式
}

Node *Tree::SearchNode(int nodeIndex)
{
	return m_pRoot->SearchNode(nodeIndex);
}

bool Tree::AddNode(int nodeIndex, int direction, Node *pNode)
{
	Node *temp = SearchNode(nodeIndex);
	if (NULL == temp) {
		return false;
	}
	Node *node = new Node();
	if (NULL == node) {
		return false;
	}
	node->index = pNode->index;
	node->data = pNode->data;
	node->pParent = temp;
	if (0 == direction) {
		temp->pLChild = node;
	}
	if (1 == direction) {
		temp->pRChild = node;
	}
	return true;
}

bool Tree::DeleteNode(int nodeIndex, Node *pNode)
{
	Node *temp = SearchNode(nodeIndex);
	if (NULL == temp) {
		return false;
	}
	if (pNode != NULL) {
		pNode->data = temp->data;
	}
	temp->DeleteNode();
	return true;
}

void Tree::PreorderTraversal()
{
	m_pRoot->PreorderTraversal();
}

void Tree::InorderTraversal()
{
	m_pRoot->InorderTraversal();
}

void Tree::PostorderTraversal()
{
	m_pRoot->PostorderTraversal();
}

TreeDemo.cpp–>修改后的测试入口代码文件

#include <iostream>
#include "Tree.h"
using namespace std;
/*
          (0)
    5(1)         8(2)
2(3)   6(4)   9(5)   7(6)
前序遍历：0 1 3 4 2 5 6
中序遍历：3 1 4 0 5 2 6
后序遍历：3 4 1 5 6 2 0
 */
int main() {
	Node *node1 = new Node();
	node1->index = 1;
	node1->data = 5;

	Node *node2 = new Node();
	node2->index = 2;
	node2->data = 8;

	Node *node3 = new Node();
	node3->index = 3;
	node3->data = 2;

	Node *node4 = new Node();
	node4->index = 4;
	node4->data = 6;

	Node *node5 = new Node();
	node5->index = 5;
	node5->data = 9;

	Node *node6 = new Node();
	node6->index = 6;
	node6->data = 7;

	Tree *pTree = new Tree();
	pTree->AddNode(0, 0, node1);
	pTree->AddNode(0, 1, node2);

	pTree->AddNode(1, 0, node3);
	pTree->AddNode(1, 1, node4);

	pTree->AddNode(2, 0, node5);
	pTree->AddNode(2, 1, node6);
	// 测试1
	pTree->PreorderTraversal();
	// 测试2
	//pTree->InorderTraversal();
	// 测试3
	//pTree->PostorderTraversal();
	// 测试4
	//pTree->DeleteNode(2, NULL);
	//pTree->PreorderTraversal();
	
	delete pTree;
	pTree = NULL;
	return 0;
}

测试1的结果为：

0   0
1   5
3   2
4   6
2   8
5   9
6   7

测试2的结果为：

3   2
1   5
4   6
0   0
5   9
2   8
6   7

测试3的结果为：

3   2
4   6
1   5
5   9
6   7
2   8
0   0

测试4的结果为：

0   0
1   5
3   2
4   6
xuyin1204
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---树（用C++代码实现）
suoyudong的博客
04-01 5540
树 基本概念 分类: 1)空树. n=0时称为空树 2)非空树. 特点: (1)有且只有一个特定的称为根的结点. (2)其余结点分为m个互不相交的有限集,并且称为根的子树. 树的深度:树中结点的最大层次称为树的深度或高度. 结点的度:结点拥有的子树数称为结点的度. 二叉树:由一个根结点和两个互不相交的子树组成. 结点的数=总分支数+1 特点: (1)每个结点最多有两颗子树 (2)左子树和...
数据结构通用树tree的实现-附带可用代码
yjlyyj的博客
06-02 814
数据结构、树、tree的实现，附带可用源码
数据结构04--树（知识点+代码版）
最新发布
weixin_62737397的博客
04-06 1038
一. 树的定义和基本术语一. 树的定义和基本术语。
c++数据结构-树（详细总结附代码，一看就懂）
我的博客
01-19 5694
一棵树是由n（n>0）个元素组成的有限集合，其中：（1）每个元素称为结点（node）（2）有一个特定的结点，称为根结点或树根（root）（3）除根节点外，其余节点能分成m（m>=0）个互不相交的有限集合 T(0)-T(m-1)。其中的每一个子集都是一个树，这些集合被称为这棵树的子树。
数据结构-树的基础代码
IT1995的博客
12-17 6524
数据结构-树的基础代码
架构探险——从零开始写javaweb框架
12-31
《架构探险——从零开始写Java Web框架》首先从一个简单的 Web 应用开始，让读者学会如何使用IDEA、Maven、Git等开发工具搭建 Java Web 应用；接着通过一个简单的应用场景，为该 Web 应用添加若干业务功能，从需求...
车牌数据集——蓝牌、绿牌、黄牌
06-19
车牌数据集包括蓝牌、绿牌、黄牌三类车牌的图片数据。 一共有12000张图片左右。图像效果好，用于车牌号识别模型训练与验证。
和树木普查相关的数据集
02-06
树木普查数据集 数据说明： 纽约市的树木在夏天为我们遮荫，...该数据集包括纽约市每棵树的记录，包括按行政区和纬度/经度划分的树的位置、按拉丁名和通用名划分的物种、大小、健康状况以及树的根、树干和树枝的问题。
数据结构实验2 资源： file.txt
04-02
数据结构实验2 资源： file.txt
架构探险——从零开始写Java Web框架.pdf
02-17
这是架构探险——从零开始写Java Web框架.pdf ，需要的话就下载吧! 这是架构探险——从零开始写Java Web框架.pdf ，需要的话就下载吧!
数据结构-二叉树的代码实现（详解）
weixin_73142957的博客
07-11 3348
内容：二叉树的前、中，后序遍历，层序遍历，二叉树节点个数，叶子节点个数，二叉树高度，第k层节点的个数，查找某个节点，二叉树销毁，判断是否为完全二叉树
数据结构-树的进阶代码
IT1995的博客
12-17 5352
数据结构-树的进阶代码
数据结构与算法入门(Java)
weixin_43830137的博客
03-25 969
数据结构与算法(Java) 1. 数据结构与算法概述 1.1 什么是数据结构？ 官方解释： 数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及他们之间的关系和操作等相关问题的学科。 大白话： 数据结构就是把数据元素按照一定的关系组织起来的集合，用来组织和存储数据 1.2 数据结构分类 传统上，我们可以把数据结构分为逻辑结构和物理结构两大类。 逻辑结构： 逻辑结构是从具体问题中抽象出来的模型，是抽象意义上的结构，按照对象中数据元素之间的相互关系分类，也是 我们后面课题中需要关注和讨论的问题。 a.集
【数据结构】数据结构探索（一） —— 树的综述
猫球球的博客
11-08 337
最近研究了mysql的索引结果，mysql的索引结果是使用了b+ tree的数据结构，了解了结构以后，对索引的功能和使用的一些规则就有了更加深入的了解，原来只是死记硬背规则和策略，现在感觉能知道背后到底是因为什么。 之后因为看到了Set对象的元素存入方式，TreeSet使用的是红黑树存储，来保证元素不会重复，我大概能理解他的实现原理，但我回头一想居然发现我对红黑树的定义已经完全想不起来了。所以准...
数据结构之通用树结构的实现
顾小豆的博客
02-17 8491
之前我们讲了树的定义和操作，这节我们讲一下如何实现这些操作。既然要考虑如何实现，那就得说说树的存储结构。大家都知道树是非线性数据结构，显然我们无法用数组来表示树的逻辑结构。那我们应该怎么办呢？通过什么来表示呢？其实可以设计结构体数组对结点间的关系进行表述。如下图所示：从上图发现，将根结点的双亲定义为-1，表示其没有双亲；将根的孩子结点的双亲定义为0，表示其双亲是根结点；将根结点孩子1的孩子结点的双...
数据结构与算法——普通树的定义与C++实现
热门推荐
Be The Best！
04-05 1万+
用树的第一个儿子和下一个兄弟表示法来表示一个树。 树的节点结构为： struct TreeNode{ TYPE element;//该节点的元素 TreeNode *firstChild;//指向该节点的第一个孩子 TreeNode *nextSibling;//指向该节点的兄弟节点 };
数据结构与算法——与树相关的代码汇总
CSer
11-08 298
**template <class T> class TreeNode { public: TreeNode(const T &); virtual ~TreeNode(){}; bool isLeaf(); T Value(); TreeNode<T> *LeftMostChild(); TreeNode<T&...
DeleteTree 函数
杨小卫的专栏
07-23 1059
void DeleteTree(char* szPath);
迷宫小游戏数据结构c语言
11-26
迷宫小游戏是一个经典的游戏，涉及到迷宫的生成、寻路等问题。在C语言中，我们可以利用数据结构来实现这个小游戏。 首先，我们可以使用二维数组来表示迷宫地图。数组的每个元素可以表示一个迷宫的格子，0表示可走的路径，1表示墙壁。通过这样的二维数组，我们可以很容易地生成迷宫地图，并在地图上进行移动和寻路。 其次，我们可以利用栈或队列来实现迷宫的寻路算法。在C语言中，可以使用数组来实现栈或队列的功能。通过这样的数据结构，我们可以在迷宫中进行深度优先搜索或广度优先搜索，找到从起点到终点的路径。 另外，我们还可以利用递归函数来寻找迷宫的路径。递归函数能够帮助我们在迷宫中不断探索，并找到通往终点的路径。 总的来说，利用C语言中的数据结构，我们可以很好地实现迷宫小游戏。通过数组、栈、队列和递归函数等数据结构，我们可以生成迷宫地图，实现寻路算法，让玩家在迷宫中尽情探险。这不仅能够锻炼玩家的逻辑思维能力，也能够帮助他们理解数据结构在实际问题中的应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值