C++中关于八叉树的数据结构的定义

最新推荐文章于 2023-09-18 15:29:40 发布
最新推荐文章于 2023-09-18 15:29:40 发布
阅读量314 收藏
点赞数
分类专栏： 点云PCL C++基础知识 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yamgyutou/article/details/120417422
版权

参考链接：octree八叉树数据结构原理与实现 - Gesündeste - 博客园

#include <iostream>  
 
using namespace std;  
//定义八叉树节点类  
template<class T>  
struct OctreeNode  
{  
    T data; //节点数据  
    T xmin,xmax; //节点坐标，即六面体个顶点的坐标  
    T ymin,ymax;  
    T zmin,zmax;  
    OctreeNode <T>*top_left_front,*top_left_back; //该节点的个子结点  
    OctreeNode <T>*top_right_front,*top_right_back;  
    OctreeNode <T>*bottom_left_front,*bottom_left_back;  
    OctreeNode <T>*bottom_right_front,*bottom_right_back;  
    OctreeNode //节点类  
        (T nodeValue = T(),  
        T xminValue = T(),T xmaxValue = T(),  
        T yminValue = T(),T ymaxValue = T(),  
        T zminValue = T(),T zmaxValue = T(),  
        OctreeNode<T>*top_left_front_Node = NULL,  
        OctreeNode<T>*top_left_back_Node = NULL,  
        OctreeNode<T>*top_right_front_Node = NULL,  
        OctreeNode<T>*top_right_back_Node = NULL,  
        OctreeNode<T>*bottom_left_front_Node = NULL,  
        OctreeNode<T>*bottom_left_back_Node = NULL,  
        OctreeNode<T>*bottom_right_front_Node = NULL,  
        OctreeNode<T>*bottom_right_back_Node = NULL )  
        :data(nodeValue),  
        xmin(xminValue),xmax(xmaxValue),  
        ymin(yminValue),ymax(ymaxValue),  
        zmin(zminValue),zmax(zmaxValue),  
        top_left_front(top_left_front_Node),  
        top_left_back(top_left_back_Node),  
        top_right_front(top_right_front_Node),  
        top_right_back(top_right_back_Node),  
        bottom_left_front(bottom_left_front_Node),  
        bottom_left_back(bottom_left_back_Node),  
        bottom_right_front(bottom_right_front_Node),  
        bottom_right_back(bottom_right_back_Node){}  
};  
//创建八叉树  
template <class T>  
void createOctree(OctreeNode<T> * &root,int maxdepth,double xmin,double xmax,double ymin,double ymax,double zmin,double zmax)  
{  
    //cout<<"处理中，请稍候……"<<endl;  
    maxdepth=maxdepth-1; //每递归一次就将最大递归深度-1  
    if(maxdepth>=0)  
    {  
        root=new OctreeNode<T>();  
        cout<<"请输入节点值:";  
        //root->data =9;//为节点赋值，可以存储节点信息，如物体可见性。由于是简单实现八叉树功能，简单赋值为9。  
        cin>>root->data;  //为节点赋值  
        root->xmin=xmin; //为节点坐标赋值  
        root->xmax=xmax;  
        root->ymin=ymin;  
        root->ymax=ymax;  
        root->zmin=zmin;  
        root->zmax=zmax;  
        double xm=(xmax-xmin)/2;//计算节点个维度上的半边长  
        double ym=(ymax-ymin)/2;  
        double zm=(ymax-ymin)/2;  
        //递归创建子树，根据每一个节点所处（是几号节点）的位置决定其子结点的坐标。  
        createOctree(root->top_left_front,maxdepth,xmin,xmax-xm,ymax-ym,ymax,zmax-zm,zmax);  
        createOctree(root->top_left_back,maxdepth,xmin,xmax-xm,ymin,ymax-ym,zmax-zm,zmax);  
        createOctree(root->top_right_front,maxdepth,xmax-xm,xmax,ymax-ym,ymax,zmax-zm,zmax);  
        createOctree(root->top_right_back,maxdepth,xmax-xm,xmax,ymin,ymax-ym,zmax-zm,zmax);  
        createOctree(root->bottom_left_front,maxdepth,xmin,xmax-xm,ymax-ym,ymax,zmin,zmax-zm);  
        createOctree(root->bottom_left_back,maxdepth,xmin,xmax-xm,ymin,ymax-ym,zmin,zmax-zm);  
        createOctree(root->bottom_right_front,maxdepth,xmax-xm,xmax,ymax-ym,ymax,zmin,zmax-zm);  
        createOctree(root->bottom_right_back,maxdepth,xmax-xm,xmax,ymin,ymax-ym,zmin,zmax-zm);  
    }  
}  
int i=1;  
//先序遍历八叉树  
template <class T>  
void preOrder( OctreeNode<T> * & p)  
{  
    if(p)  
    {  
        cout<<i<<".当前节点的值为："<<p->data<<"\n坐标为：";  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        i+=1;  
        cout<<endl;  
        preOrder(p->top_left_front);  
        preOrder(p->top_left_back);  
        preOrder(p->top_right_front);  
        preOrder(p->top_right_back);  
        preOrder(p->bottom_left_front);  
        preOrder(p->bottom_left_back);  
        preOrder(p->bottom_right_front);  
        preOrder(p->bottom_right_back);  
        cout<<endl;  
    }  
}  
//求八叉树的深度  
template<class T>  
int depth(OctreeNode<T> *& p)  
{  
    if(p == NULL)  
        return -1;  
    int h =depth(p->top_left_front);  
    return h+1;  
}  
//计算单位长度，为查找点做准备  
int cal(int num)  
{  
    int result=1;  
    if(1==num)  
        result=1;  
    else  
    {  
        for(int i=1;i<num;i++)  
            result=2*result;  
    }  
    return result;  
}  
//查找点  
int maxdepth=0;  
int times=0;  
static double xmin=0,xmax=0,ymin=0,ymax=0,zmin=0,zmax=0;  
int tmaxdepth=0;  
double txm=1,tym=1,tzm=1;  
template<class T>  
void find(OctreeNode<T> *& p,double x,double y,double z)  
{  
    double xm=(p->xmax-p->xmin)/2;  
    double ym=(p->ymax-p->ymin)/2;  
    double zm=(p->ymax-p->ymin)/2;  
    times++;  
    if(x>xmax || x<xmin|| y>ymax || y<ymin || z>zmax || z<zmin)  
    {  
        cout<<"该点不在场景中！"<<endl;  
        return;  
    }  
    if(x<=p->xmin+txm&& x>=p->xmax-txm && y<=p->ymin+tym &&y>=p->ymax-tym && z<=p->zmin+tzm &&z>=p->zmax-tzm )  
    {  
        cout<<endl<<"找到该点！"<<"该点位于"<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<"节点内！"<<endl;  
        cout<<"共经过"<<times<<"次递归！"<<endl;  
    }  
    else if(x<(p->xmax-xm) && y<(p->ymax-ym) &&z<(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->bottom_left_back,x,y,z);  
    }  
    else if(x<(p->xmax-xm) && y<(p->ymax-ym) &&z>(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->top_left_back,x,y,z);  
    }  
    else if(x>(p->xmax-xm) && y<(p->ymax-ym) &&z<(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->bottom_right_back,x,y,z);  
    }  
    else if(x>(p->xmax-xm) && y<(p->ymax-ym) &&z>(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->top_right_back,x,y,z);  
    }  
    else if(x<(p->xmax-xm) && y>(p->ymax-ym) &&z<(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->bottom_left_front,x,y,z);  
    }  
    else if(x<(p->xmax-xm) && y>(p->ymax-ym) &&z>(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->top_left_front,x,y,z);  
    }  
    else if(x>(p->xmax-xm) && y>(p->ymax-ym) &&z<(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->bottom_right_front,x,y,z);  
    }  
    else if(x>(p->xmax-xm) && y>(p->ymax-ym) &&z>(p->zmax-zm))  
    {  
        cout<<"当前经过节点坐标："<<endl;  
        cout<<"xmin: "<<p->xmin<<" xmax: "<<p->xmax;  
        cout<<"ymin: "<<p->ymin<<" ymax: "<<p->ymax;  
        cout<<"zmin: "<<p->zmin<<" zmax: "<<p->zmax;  
        cout<<endl;  
        find(p->top_right_front,x,y,z);  
    }  
}  
//main函数  
int main ()  
{  
    OctreeNode<double> *rootNode = NULL;  
    int choiced = 0;  
    while(true)  
    {  
        system("cls");  
        cout<<"请选择操作：\n";  
        cout<<"1.创建八叉树 2.先序遍历八叉树\n";  
        cout<<"3.查看树深度 4.查找节点   \n";  
        cout<<"0.退出\n\n";  
        cin>>choiced;  
        if(choiced == 0)  
            return 0;  
        else if(choiced == 1)  
        {  
            system("cls");  
            cout<<"请输入最大递归深度："<<endl;  
            cin>>maxdepth;  
            cout<<"请输入外包盒坐标，顺序如下：xmin,xmax,ymin,ymax,zmin,zmax"<<endl;  
            cin>>xmin>>xmax>>ymin>>ymax>>zmin>>zmax;  
            if(maxdepth>=0|| xmax>xmin || ymax>ymin || zmax>zmin || xmin>0 || ymin>0||zmin>0)  
            {  
                tmaxdepth=cal(maxdepth);  
                txm=(xmax-xmin)/tmaxdepth;  
                tym=(ymax-ymin)/tmaxdepth;  
                tzm=(zmax-zmin)/tmaxdepth;  
                createOctree(rootNode,maxdepth,xmin,xmax,ymin,ymax,zmin,zmax);  
            }  
            else  
            {  
                cout<<"输入错误！";  
                return 0;  
            }  
        }  
        else if(choiced == 2)  
        {  
            system("cls");  
            cout<<"先序遍历八叉树结果：/n";  
            i=1;  
            preOrder(rootNode);  
            cout<<endl;  
            system("pause");  
        }  
        else if(choiced == 3)  
        {  
            system("cls");  
            int dep =depth(rootNode);  
            cout<<"此八叉树的深度为"<<dep+1<<endl;  
            system("pause");  
        }  
        else if(choiced == 4)  
        {  
            system("cls");  
            cout<<"请输入您希望查找的点的坐标，顺序如下：x,y,z\n";  
            double x,y,z;  
            cin>>x>>y>>z;  
            times=0;  
            cout<<endl<<"开始搜寻该点……"<<endl;  
            find(rootNode,x,y,z);  
            system("pause");  
        }  
        else  
        {  
            system("cls");  
            cout<<"\n\n错误选择！\n";  
            system("pause");  
        }  
    }  
}

Yang_Yutou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Open3D (C++) 八叉树的使用
点云侠的博客
09-13 1001
C++版本Open3D八叉树的使用案例
八叉树，用C++实现简单的八叉树类
JamesXue的博客
07-04 613
八叉树的C++实现代码。
八叉树（C++实现）
code_leader的博客
09-24 1万+
八叉树这块的代码，在别人的基础上，把有问题的地方稍作改动，以及不懂得地方多加了注释，当作以后的学习资料。 #include <iostream> using namespace std; //定义八叉树节点类 template<class T> struct OctreeNode { T data; //节点数据 T xmin, xmax; //节点坐标，即六面体个顶点的坐标 T ymin, ymax; T zmin, zmax; OctreeNode &lt
C++实现八叉树
NINE_world的博客
10-24 1030
【代码】C++实现八叉树。
数据结构——八叉树
weixin_43945471的博客
09-18 1332
八叉树（Octree）是一种用于表示和管理三维空间的树状数据结构。它将三维空间递归地分割成八个八分体（octant），每个八分体可以继续分割，以实现对三维空间的更精细的划分。八叉树通常用于解决空间搜索和查询问题，例如三维物体碰撞检测、体素化（Voxelization）、地理信息系统等领域。
c++八叉树实现
10-13
使用c++的八叉树实现，八叉树（Octree）的定义是：若不为空树的话，树中任一节点的子节点恰好只会有八个，或零个，也就是子节点不会有0与8以外的数目。
红黑树-基于C++实现的红黑树数据结构.zip
最新发布
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
huffman树_Huffman树_C++_huffman_数据结构_
10-02
自己实现huffman树的代码，分享出来
哈夫曼树C++数据结构题目.cpp
03-31
C++数据结构题目，编写一个哈夫曼树，输入一串数据，按数据出现的频率给出哈夫曼树，求最优解，也就是编码长度要最短
c++数据结构进阶线段树习题
07-05
针对线段树的四道c++习题
八叉树算法
10-08
文件包含八叉树构建算法； 用100万个点测试，构建效率高； 代码里面还有关于八叉树的相关操作函数； 欢迎广大爱好者使用交流。
八叉树示例程序
06-02
一个可用的八叉树示例程序
八叉树 Octree.cpp
05-23
关于八叉树实现的代码,可创建八叉树，先序遍历八叉树，查看树深度，查找节点
八叉树 C++ 基础 源码
...
06-20 1万+
http://blog.csdn.net/pizi0475/article/details/6269060四叉树或四元树也被称为Q树（Q-Tree）。四叉树广泛应用于图像处理、空间数据索引、2D中的快速碰撞检测、存储稀疏数据等，而八叉树（Octree）主要应用于3D图形处理。实际的数据结构，就是一个树根不断地往下扩，每次分成八个枝，直到叶子为止。 叶子节点代表了分辨率最高的情况。例如分辨率设成0.
空间数据结构(四叉树/八叉树/BVH树/BSP树/k-d树)
syzdev的博客
09-03 6538
一个自定义区域一般是一个凸多边形，然后可通过一些编辑器手动设置好其各顶点位置，最终手工划分出一块凸多边形区域。3D凸多面体一般很少用，即使在要求划分区域属于同一XOZ面不同高度的3D世界里，考虑到性能，可能更适合用凸多边形+高度来划分区域。此外一提，能不用凹多边形就不用。因为许多程序算法都可以应用在凸多边形上，而相对应用于凹多边形上可能行不通或者得用更低效的算法为了达到自定义区域之间的无缝衔接，游戏程序还往往采用图（或者树）结构来存储这些自定义区域，表示它们之间的联系。
c++八叉树
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 782
八叉树图片 八叉树（octree），或称八元树，是一种用于描述三维空间（划分空间）的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。 用途 •三维计算机图形 •最邻近搜索 ...
高效八叉树octree：基于hash函数的数据结构
小小码农的博客
05-21 9942
1.基础知识八叉树octree是一种递归、轴对齐且空间分隔的数据结构，常用于计算机几何来优化碰撞检测、最邻近搜索等，且常用于3D数据的表达。一个八叉树结构，将有限的三维体数据等分为8个octants。octants也被称为nodes（节点，树结构概念中）或者cells（单元，空间概念中）。将空间分成等大小的立方体可以加速细分运算，且单元大小的存储也节省空间。一个八叉树是通过递归的将空间细分成八个子...
来用C++实现八叉树以及解决点云的均匀降采样问题
weixin_42048023的博客
10-29 2132
点云降采样
八叉树 Octree
热门推荐
timzc的专栏
12-07 1万+
（一）基本原理    用八叉树来表示三维形体，并研究在这种表示下的各种操作及应用是在进入80年代后才比较全面地开展起来的。这种方法，既可以看成是四叉树方法在三维空间的推广，也可以认为是用三维体素阵列表示形体方法的一种改进。    八叉树的逻辑结构如下：    假设要表示的形体V可以放在一个充分大的正方体C内，C的边长为2 n，形体V C，它的八叉树可以用以下的递归方法来定义：    八叉树的每个节点与C的一个子立方体对应，树根与C本身相对应，如果V＝C，那么V的八叉树仅有树根，如果V≠C，则将C等分为八个子
使用c++写出八叉树数据结构
10-12
八叉树是一种树形数据结构，每个节点最多有八个子节点。它通常用于三维空间的划分和搜索，可以有效地提高搜索效率。以下是使用C++实现八叉树的代码： ```cpp struct Point { double x, y, z; }; struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值