四叉树的C++实现

最新推荐文章于 2024-09-06 22:41:06 发布
最新推荐文章于 2024-09-06 22:41:06 发布
阅读量1w 收藏 63
点赞数 7
分类专栏： 编程基础 文章标签： 四叉树 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qithon/article/details/50766136
版权

四叉树的数据结构
抽象数据类型定义如下：

ADT QuadTrees{
	数据对象D：D是具有相同性质的具有二维结构的数据元素的集合,本实验为坐标数据。
	数据关系R：若D为空集，则称为空树；若D仅含有一个数据元素，则R为空集，否则R={H}，	H是如下二元关系：
	(1) 在D中存在唯一的元素root，它在关系H下无父节点；
	(2) D中任意元素d将其子节点划分为四个象限，将其直接相邻的节点分别设为d[1],d[2],d[3],d[4]；
	(3) 若D-{root}≠ɸ，则存在D-{root} ={root[1],root[2],root[3],root[4]}，且两两无交集；
	(4) 若d[i] ≠ɸ(i=1,2,3,4),则d[i]中存在唯一的xi ，<root, xi> ∈H，且存在d[i]上的关系Hi⊂H；
	       H={<root, xi>, Hi},i=1,2,3,4;
	(5) (root[i],{Hi})i=1,2,3,4 是符合定义的四叉树;
	基本操作：
	QuadTreeInit(QT);//构造空的四叉树
	Compare(node A, node B);//返回B在A的第几个象限，返回值取之只能为1,2,3,4
	StaightforwardInsertion(QT,K);//简单插入节点K(不考虑树的平衡)
	SophisticatedInsertion(QT,K);//插入节点K(考虑树的平衡)
	RegionSearch(QT,K,double L,R,B,T);//查找节点K所有在x=L,x=B,y=R,y=T所构成矩形区域的子节点
	}ADT QuadTrees;

算法实现
四叉树给出如下定义：
一棵四叉树T是由一个或一个以上节点组成的有限集，其中有一个特定的节点R称为T的根节点。如果集合( T - { R } ) 非空，那么集合中的这些点被划分为n(n≤4)个不相交的子集 ，其中每个子集都是四叉树,并且其相应的根节点 是R的子节点。子集 称为T 的子树。
四叉树与对应节点关系：

四叉树与对应节点关系对照

以下是源码：

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

template<typename T>
struct Point{
	T x;
	T y;
	Point(){}
	Point(T _x, T _y) :x(_x), y(_y){}
};

template<typename T>
struct Node{
	Node* R[4];
	Point<T> pt;
	Node* parent;
};

template<typename ElemType>
class QuardTree
{
public:
	QuardTree();
	~QuardTree();
	void Insert(const Point<ElemType>& pos);
	void BalanceInsert(const Point<ElemType>& pos );
	int nodeCount();
	int TPLS();
	int Height();
	void RegionResearch(ElemType left, ElemType right, ElemType botom, ElemType top, int& visitednum,int& foundnum);
	void clear();
private:
	Node<ElemType>* root;
	int Compare(const Node<ElemType>* node, const Point<ElemType>& pos);
	bool In_Region(Point<ElemType> t, ElemType left, ElemType right, ElemType botom, ElemType top);
	bool Rectangle_Overlapse_Region(ElemType L, ElemType R, ElemType B, ElemType T, ElemType left, ElemType right, ElemType botom, ElemType top);
	void RegionResearch(Node<ElemType>* t, ElemType left, ElemType right, ElemType botom, ElemType top, int& visitednum, int& foundnum);
	int Depth(Node<ElemType>* &);
	int nodeCount(const Node<ElemType>*);
	void clear(Node < ElemType>*& p);
	void Insert(Node<ElemType>*& , const Point<ElemType>& pos);//递归插入节点
};


template<typename T>
QuardTree<T>::QuardTree()
{
	root = NULL;
}

template<typename T>
QuardTree<T>::~QuardTree()
{
	clear(root);
}

template<typename T>
int QuardTree<T>::TPLS()
{
	return Depth(root);
}

template<typename T>
int QuardTree<T>::Compare(const Node<T>* node, const Point<T>& pos)
{
	if (pos.x == node->pt.x && pos.y == node->pt.y) return 0;
	if (pos.x >= node->pt.x && pos.y>node->pt.y)  return 1;
	if (pos.x<node->pt.x  && pos.y >= node->pt.y) return 2;
	if (pos.x <= node->pt.x && pos.y<node->pt.y)  return 3;
	if (pos.x>node->pt.x  && pos.y <= node->pt.y) return 4;
	return -1;
}


template<typename T>
void QuardTree<T>::BalanceInsert(const Point<T>& pos)
{
	Node<T>* node = (Node<T>*)malloc(sizeof(Node<T>));
	node->R[0] = NULL;
	node->R[1] = NULL;
	node->R[2] = NULL;
	node->R[3] = NULL;
	node->parent = NULL;
	node->pt = pos;
	if (root == NULL)
	{
		root = node;
		return;
	}
	Node<T>* temp = root;
	int direction = Compare(temp, pos);
	if (direction == 0) return;
	while (temp->R[direction - 1] != NULL)
	{
		temp = temp->R[direction - 1];
		direction = Compare(temp, pos);
		if (direction == 0) return;
	}
	temp->R[direction - 1] = node;
	node->parent = temp;
	
	Node<T>* tp = temp->parent;
	if (tp == NULL) return;
	int r = Compare(tp, temp->pt);

	if (abs(direction-r) == 2)
	{
		Node<T>* leaf = node;
		if (tp->R[abs(3 - r)] == NULL )
		{
			tp->R[r - 1] = NULL;
			temp->parent = leaf;
			leaf->R[r-1] = temp;

			temp->R[abs(3 - r)] = NULL;
			Node<T>* Rt = tp->parent;
			if (Rt == NULL)
			{
				root = leaf;
				leaf->parent = NULL;

				leaf->R[abs(3 - r)] = tp;
				tp->parent = leaf;
				return;
			}
			tp->parent = NULL;
			int dd = Compare(Rt, tp->pt);

			Rt->R[dd - 1] = leaf;
			leaf->parent = Rt;

			leaf->R[abs(3 - r)] = tp;
			tp->parent = leaf;
		}
	}	
}


template<typename T>
void QuardTree<T>::Insert(Node<T>*& p, const Point<T>& pos)
{
	if (p == NULL)
	{
		Node<T>* node = (Node<T>*)malloc(sizeof(Node<T>));
		node->R[0] = NULL;
		node->R[1] = NULL;
		node->R[2] = NULL;
		node->R[3] = NULL;
		node->pt = pos;
		p = node;
		return;
	}
	else
	{
		int d = Compare(p, pos);
		if (d == 0) return;
		Insert(p->R[d - 1], pos);
	}
}


template<typename T>
void QuardTree<T>::Insert(const Point<T>& pos)
{
	int direction, len = 0;
	Node<T>* node = (Node<T>*)malloc(sizeof(Node<T>));
	node->R[0] = NULL;
	node->R[1] = NULL;
	node->R[2] = NULL;
	node->R[3] = NULL;
	node->pt = pos;
	if (root == NULL)
	{
		root = node;
		return;
	}
	direction = Compare(root, pos);
	Node<T>* temp = root;
	if (direction == 0) return;//节点已存在 
	len = 1;
	while (temp->R[direction - 1] != NULL)
	{
		temp = temp->R[direction - 1];
		direction = Compare(temp, pos);
		if (direction == 0) return;
	}
	temp->R[direction - 1] = node;
	//Insert(root, pos);//递归插入节点
}





template<typename T>
int QuardTree<T>::nodeCount()
{
	return nodeCount(root);
}

template<typename T>
int QuardTree<T>::nodeCount(const Node<T>* node)
{
	if (node == NULL) return 0;
	return 1 + nodeCount(node->R[0]) + nodeCount(node->R[1]) + nodeCount(node->R[2]) + nodeCount(node->R[3]);
}

template<typename T>
bool QuardTree<T>::In_Region(Point<T> t, T left, T right, T botom, T top)
{
	return t.x >= left && t.x <= right && t.y >= botom && t.y <= top;
}

template<typename ElemType>
bool QuardTree<ElemType>::Rectangle_Overlapse_Region(ElemType L, ElemType R, ElemType B, ElemType T, 
	ElemType left, ElemType right, ElemType botom, ElemType top)
{
	return L <= right && R >= left && B <= top && T >= botom;
	//return true;
}//优化查找速度

template<typename T>
void QuardTree<T>::RegionResearch(Node<T>* t, T left, T right, T botom, T top, int& visitednum, int& foundnum)
{
	if (t == NULL) return;
	T xc = t->pt.x;
	T yc = t->pt.y;
	if (In_Region(t->pt, left, right, botom, top)){ ++foundnum; }
	if (t->R[0] != NULL && Rectangle_Overlapse_Region(xc, right, yc, top, left, right, botom, top))
	{
		visitednum++;
		RegionResearch(t->R[0], xc>left?xc:left, right, yc>botom?yc:botom, top, visitednum, foundnum);
	}
	if (t->R[1] != NULL && Rectangle_Overlapse_Region(left, xc, yc, top, left, right, botom, top))
	{
		visitednum++;
		RegionResearch(t->R[1], left, xc>right?right:xc, yc>botom?yc:botom, top, visitednum, foundnum);
	}
	if (t->R[2] != NULL && Rectangle_Overlapse_Region(left, xc, botom, yc, left, right, botom, top))
	{
		visitednum++;
		RegionResearch(t->R[2], left, xc<right?xc:right, botom, yc<top?yc:top, visitednum, foundnum);
	}
	if (t->R[3] != NULL && Rectangle_Overlapse_Region(xc, right, botom, yc, left, right, botom, top))
	{
		visitednum++;
		RegionResearch(t->R[3], xc>left ? xc : left, right, botom, yc<top ? yc : top, visitednum, foundnum);
	}
}

template<typename T>
void QuardTree<T>::clear()
{
	clear(root);
}

template<typename T>
void QuardTree<T>::clear(Node<T>* &p)
{
	if (p == NULL) return;
	if (p->R[0]) clear(p->R[0]);
	if (p->R[1]) clear(p->R[1]);
	if (p->R[2]) clear(p->R[2]);
	if (p->R[3]) clear(p->R[3]);
	free(p);
	p = NULL;
}

template<typename T>
void QuardTree<T>::RegionResearch(T left, T right, T botom, T top, int& visitednum, int& foundnum)
{
	RegionResearch(root, left, right, botom, top, visitednum,foundnum);
}

template<typename T>
int QuardTree<T>::Depth(Node<T>* &node)
{
	if (node == NULL) return 0;
	int dep = 0;
	Node<T>* tp = root;
	while (tp->pt.x!=node->pt.x || tp->pt.y!=node->pt.y)
	{
		dep++;
		tp = tp->R[Compare(tp, node->pt) - 1];
		if (tp == NULL) break;
	}
	return dep + Depth(node->R[0]) + Depth(node->R[1]) + Depth(node->R[2]) + Depth(node->R[3]);
}

参考文献
Finkel R A, Bentley J L. Quad trees a data structure for retrieval on composite keys[J]. Acta Informatica, 1974, 4(1):1-9.

subtask
关注
专栏目录
C/C++ 四叉树详解及实现源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-30 7645
四叉树（Quadtree）是一种多叉树的形式，用于处理二维空间中的数据。它将空间划分为四个相等的象限，并在每个象限内递归地构建四叉树，直到满足某个条件停止划分。这是一个简单的四叉树实现示例，可以根据需要进行扩展和优化。
C++实现四叉树（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-24 343
C++实现四叉树（附完整源码）
四叉树_C++_四叉树_
10-01
C++实现四叉树的基本功能，建立，查询等
【C++实现四叉树（附完整源码）题】
我的博客
07-12 357
C++实现四叉树（附完整源码）
Unity 四叉树地图项目
最新发布
gitblog_09751的博客
09-06 410
Unity 四叉树地图项目 unity-Multi-tree-manage-scenario-master.7z项目地址:https://gitcode.com/open-source-toolkit/28365 项目描述 当使用Unity构建大规模的游戏地图或场景时，使用四叉树数据结构可以显著提高性能和效率。四叉树是一种基于分割的数据结构，将空间划分为四个相等的子区域，并以递归方式构建树结构。...
四叉树quadtree的c++实现
06-06
使用c++实现一棵四叉树，每个叶节点最多只包含一个二维平面的点。四叉树可以进行遍历，删除，添加，查询操作。
C++实现四叉树效果(附源码下载)
08-31
主要介绍了C++实现四叉树效果(附源码下载),非常不错，具有参考借鉴价值，需要的朋友可以参考下
使用C++实现四叉树的代码
08-10
记录了四叉树的原理，实现代码和思路 附有完整的C++代码。
四叉树C++实现（增删改查，找邻居）
dive_shallow的博客
01-10 3888
好久好久没更过了，因为入坑了一本天书的缘故，有一些比较特别的数据结构需要学一下，第一个就是这个四叉树，工作占的时间太多了，只能用剩下的时间来学一学了，话不多说，先来介绍一下基本的概念： 我们这里的四叉树指的是满四叉树，也就是每个节点要么有四个孩子节点，要么没有孩子节点，它在二维空间中可以表示对一个正方形进行四个象限的分割，从右上，左上，左下，右下这四个方向可以依次表示为第一象限，第二象限，第三象限和第四象限，如图：其中，根节点表示大的正方形，根节点下的四个节点分别表示对应的...
四叉树定义实现C++代码
05-26
四叉树的定义实现C++代码。刚才自己写的凑合着用
QuadTree c++实现
02-18
该代码实现了QuadTree的创建于简单的查询功能 并以真实数据集（City of Oldenburg OL Road Network）共6105个节点进行了简单的测试 该数据集（sortData txt）经过处理按照第一列（精度）从小到大进行了排序
四叉树代码
04-09
四叉树.，代码，提供给你，拿去进步吧！！！多个四叉树
四叉树实现
12-05
四叉树是在二维图片中定位像素的唯一适合的算法。因为二维空间（图经常被描述的方式）中，平面像素可以重复的被分为四部分，树的深度由图片、计算机内存和图形的复杂度决定。四叉树可以用来在数据库中放置和定位文件（称作记录或键）。这一算法通过不停的把要查找的记录分成4部分来进行匹配查找直到仅剩下一条记录为止。
c++四叉树地理文本搜索
11-17
基于C++的四叉树空间搜索，在一个MAIN函数里面写完的，
线性四叉树的实现C++
niufuer的博客
11-06 2648
线性四叉树的实现 1）线性四叉树只存储最后的叶节点信息，包括叶节点的位置，大小和深度（根据数组下标可以直接得到）。 2）使用节点引用类型的vector容器表示一颗完全四叉树。 3) 完全四叉树的父节点数组下标为i时，对应的子节点下标为4*i+num，num∈{1，2，3，4}。 不足： 1.为了通过数组下标明确父节点与子节点的关系，采用的是完全四叉树的结构，由于地理空间对象可能分布不均衡，这样会导致四叉树生成一棵极为不平衡的树，也会造成树结构的不平衡以及存储空间的极大浪费。 2.为了判断是否是叶子结点，在
C++实现四叉树索引
欢迎来到我的博客小天地
08-10 1480
它将已知范围的空间划分为四个相等的子空间，如此递归下去，直至树的层次达到一定深度或者满足某种要求后停止分割。这里介绍的四叉树结构中，所有的点位置信息都存储在叶子节点上，中间节点以及根结点不存储点信息。3.四叉树结点数据结构：四叉树结点是四叉树结构的主要组成部分，主要用于存储点的最小外包矩形，深度，子节点指针等，也是四叉树算法操作的主要部分。（1）判断结点是否已经分裂，已分裂的选择合适的子节点，进行插入；（2）未分裂的查看是否过载，过载的分裂结点，重新插入；（1）通过父节点获取子节点的深度和范围；...
数据结构--知识点16--搜索算法(二叉树)
ANingL的博客
09-06 3132
文章目录一、树的概念1、特点2、树的术语3、树的种类4、树的存储与表示5、常见的树的应用场景二、二叉树1、概念2、性质 一、树的概念 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构 1、特点 每个节点有零个或多个子节点 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点外，每个子节点可以分为**多个不相交(因为都只有一个父节点)**的子树 2、树的术语 节点的度：一个节点含有的子树的个数称为该节点的度 树的度：一棵树中，最大的节点的度称为树的度 叶节点或终端节点
数据的均匀化分割算法（网格划分法、四叉树法（含C++代码））
u014374826的博客
05-11 1121
数据的均匀化分割算法（网格划分法、四叉树法（含C++代码）） 还是选四叉树均匀化与非极大值抑制结合的方法
用C++实现四叉树
06-01
四叉树是一种二叉树的变体，它将平面空间递归分成四个象限。下面是C++代码实现： ```cpp #include <iostream> #include <vector> using namespace std; // 定义节点结构体 struct Node { int x, y, val; Node *nw, *ne, *sw, *se; Node(int x, int y, int val) : x(x), y(y), val(val), nw(NULL), ne(NULL), sw(NULL), se(NULL) {} }; // 定义四叉树类 class QuadTree { private: Node *root; // 根节点 int size; // 树的大小 // 插入节点 Node* insert(Node *node, int x, int y, int val) { if (node == NULL) { // 如果节点为空，则新建一个节点 size++; return new Node(x, y, val); } if (node->x == x && node->y == y) { // 如果节点已存在，则更新节点的值 node->val = val; return node; } if (x < node->x && y < node->y) { // 如果点在左下象限，则递归到左下子树 node->sw = insert(node->sw, x, y, val); } else if (x < node->x && y >= node->y) { // 如果点在左上象限，则递归到左上子树 node->nw = insert(node->nw, x, y, val); } else if (x >= node->x && y < node->y) { // 如果点在右下象限，则递归到右下子树 node->se = insert(node->se, x, y, val); } else { // 如果点在右上象限，则递归到右上子树 node->ne = insert(node->ne, x, y, val); } return node; } // 查询节点 Node* query(Node *node, int x, int y) { if (node == NULL) { // 如果节点为空，则返回NULL return NULL; } if (node->x == x && node->y == y) { // 如果节点匹配，则返回节点 return node; } if (x < node->x && y < node->y) { // 如果点在左下象限，则递归到左下子树 return query(node->sw, x, y); } else if (x < node->x && y >= node->y) { // 如果点在左上象限，则递归到左上子树 return query(node->nw, x, y); } else if (x >= node->x && y < node->y) { // 如果点在右下象限，则递归到右下子树 return query(node->se, x, y); } else { // 如果点在右上象限，则递归到右上子树 return query(node->ne, x, y); } } public: // 构造函数 QuadTree() : root(NULL), size(0) {} // 插入节点 void insert(int x, int y, int val) { root = insert(root, x, y, val); } // 查询节点 Node* query(int x, int y) { return query(root, x, y); } // 获取树的大小 int getSize() { return size; } }; int main() { QuadTree tree; tree.insert(0, 0, 1); tree.insert(1, 1, 2); tree.insert(2, 2, 3); tree.insert(3, 3, 4); Node *node = tree.query(1, 1); if (node != NULL) { cout << "Node value: " << node->val << endl; } else { cout << "Node not found!" << endl; } cout << "Tree size: " << tree.getSize() << endl; return 0; } ``` 以上代码实现了四叉树的插入和查询功能，可以根据需要进行修改。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值