KD树简单实现

最新推荐文章于 2024-08-26 16:25:37 发布
转载 最新推荐文章于 2024-08-26 16:25:37 发布 · 234 阅读 · 0

本文介绍了一种高效的空间数据结构——Kd树的实现细节。包括如何构建空树、插入节点、查找节点等核心操作，并实现了绘制树结构、范围查询及最近邻搜索等功能。
public class KdTree {
   private int n;
   private Node root;
   private static final int LEFT = 1;
   private static final int RIGHT = 2;
   private static final int BOTTOM = 3;
   private static final int TOP = 4;
   public KdTree()                               // construct an empty set of points
   {
       root = null;
       n = 0;
   }
   private static class Node {
       private Point2D p;      // the point
       private RectHV rect;    // the axis-aligned rectangle corresponding to this node
       private Node lb;        // the left/bottom subtree
       private Node rt;        // the right/top subtree
       public Node(Point2D p,RectHV rect)
       {
           this.p = p;
           this.rect = rect;

       }

    }
   public boolean isEmpty()                        // is the set empty?
   {
       return n == 0;
   }
   public int size()                               // number of points in the set
   {
       return n;
   }
   private Node insert(Node x,Point2D p,int depth,double original,int orientation,RectHV rect)
   {
       if (x == null) 
       {
           if (depth == 0)
           {
               n++;
               return new Node(p,new RectHV(0,0,1,1));
           }
           else
           {
               double xmin = rect.xmin();
               double xmax = rect.xmax();
               double ymin = rect.ymin();
               double ymax = rect.ymax();
               switch (orientation)
               {

                   case LEFT : xmax = original;break;
                   case RIGHT: xmin = original;break;
                   case TOP: ymin = original;break;
                   case BOTTOM: ymax = original;break;
                   default :break;
               }
               //StdOut.print(original);
               n++;
               return new Node(p,new RectHV(xmin,ymin,xmax,ymax));
           }
       }
       if (x.p.equals(p)) return x;
       if (depth % 2 == 0)
       {
           if (p.x() < x.p.x()) x.lb = insert(x.lb,p,depth + 1,x.p.x(),LEFT,x.rect);
           else x.rt = insert(x.rt,p,depth + 1,x.p.x(),RIGHT,x.rect);
       }
       else
       {
           if (p.y() < x.p.y()) x.lb = insert(x.lb,p,depth + 1,x.p.y(),BOTTOM,x.rect);
           else x.rt = insert(x.rt,p,depth + 1,x.p.y(),TOP,x.rect);
       }

       return x;

   }
   public void insert(Point2D p)                   // add the point p to the set (if it is not already in the set)
   {
       root = insert(root,p,0,0,0,new RectHV(1,1,1,1));

   }
   private boolean contains(Node x,Point2D p,int depth)
   {
       if (x == null) 
           return false;
       if (x.p.equals(p)) return true;
       if (depth % 2 == 0)
       {
           if (p.x() < x.p.x()) return contains(x.lb,p,depth + 1);
           else return contains(x.rt,p,depth + 1);
       }
       else
       {
           if (p.y() < x.p.y()) return contains(x.lb,p,depth + 1);
           else return contains(x.rt,p,depth + 1);
       }

   }
   public boolean contains(Point2D p)              // does the set contain the point p?
   {
       return contains(root,p,0);
   }
   private void draw(Node x,int depth)
   {
       if (x == null) return;
       if (depth % 2 == 0)
       {
           StdDraw.setPenColor(StdDraw.BLACK);
           StdDraw.setPenRadius(.01);
           x.p.draw();
           StdDraw.setPenColor(StdDraw.RED);
           StdDraw.setPenRadius();
           x.rect.draw();
       }
       else
       {
           StdDraw.setPenColor(StdDraw.BLACK);
           StdDraw.setPenRadius(.01);
           x.p.draw();
           StdDraw.setPenColor(StdDraw.BLUE);
           StdDraw.setPenRadius();
           x.rect.draw();
       }
       draw(x.lb,depth + 1);
       draw(x.rt,depth + 1);
   }
   public void draw()                              // draw all of the points to standard draw
   {
       draw(root,0);
   }
   private void range(Node x,RectHV rect,Queue q,int depth)
   {

       if (x == null || !x.rect.intersects(rect)) return;
       if (rect.contains(x.p)) q.enqueue(x.p);

       if (depth % 2 == 0)
       {
           double xmin = rect.xmin();
           double xmax = rect.xmax();
           if (x.p.x() >= xmin && x.p.x() <= xmax)
           {
               range(x.lb,rect,q,depth + 1);
               range(x.rt,rect,q,depth + 1);
           }
           else if (x.p.x() < xmin)
               range(x.rt,rect,q,depth + 1);
           else
               range(x.lb,rect,q,depth + 1);
       }
       else
       {
           double ymin = rect.ymin();
           double ymax = rect.ymax();
           if (x.p.y() >= ymin && x.p.y() <= ymax)
           {
               range(x.lb,rect,q,depth + 1);
               range(x.rt,rect,q,depth + 1);
           }
           else if (x.p.y() < ymin)
               range(x.rt,rect,q,depth + 1);
           else
               range(x.lb,rect,q,depth + 1);
       }

   }
   public Iterable<Point2D> range(RectHV rect)     // all points in the set that are inside the rectangle
   {
       Queue<Point2D> q = new Queue<Point2D>();
       range(root,rect,q,0);
       return q;
   }
   private Node smallerToP(Node x,Node y,Point2D p)
   {
       if (x == null) return y;
       if (y == null) return x;
       return x.p.distanceSquaredTo(p) <= y.p.distanceSquaredTo(p) ? x : y;
   }
   private Node nearest(Node x,Point2D p,Node shortNode,int depth)
   {
       if (shortNode == null) shortNode = x;
       if (x == null || shortNode.p.distanceTo(p) < x.rect.distanceTo(p)) return null;
       shortNode = smallerToP(shortNode,x,p);
       Node q;
       if (depth % 2 == 0)
       {
           if (p.x() < x.p.x()) 
           {
               q = nearest(x.lb,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
               q = nearest(x.rt,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
           }
           else
           {
               q = nearest(x.rt,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
               q = nearest(x.lb,p,shortNode,depth + 1);   shortNode = smallerToP(shortNode,q,p);
           }
       }
       else
       {

           if (p.y() < x.p.y())
           {
               q = nearest(x.lb,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
               q = nearest(x.rt,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
           }
           else
           {
               q = nearest(x.rt,p,shortNode,depth + 1);  shortNode = smallerToP(shortNode,q,p);
               q = nearest(x.lb,p,shortNode,depth + 1);   shortNode = smallerToP(shortNode,q,p);
           }
       }

       return shortNode;
   }
   public Point2D nearest(Point2D p) // a nearest neighbor in the set to p; null if set is empty              
   {
       Node q = nearest(root,p,null,0);
       if (q == null) return null;
       return q.p;

   }
}
KD树的实现
qq_50323694的博客
11-16 1608
在我们使用KNN算法分类时，需要求离某个点最近的k个样本。如果用矩阵来储存计算的话，则大大降低效率，因此我们使用KD树进行储存与搜索。
k-d tree 算法实现
温染的笔记
04-07 1208
k-d tree 算法 k-d 树（k-dimensional 树的简称），是一种分割 k 维数据空间的数据结构。主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。 应用背景 过程 k-d tree 算法主要分为两部分： k-d 树的构建算法； 基于 k-d 树的最邻近查找算法。 k-d 树的构建算法 k-d 树是一个二叉树，每个节点表示一个空间范围，下表给出 k-d 树节点的数...
KD-Tree 算法的 C++ 实现
Doge的博客
12-15 1536
KD-Tree 算法的 C++ 实现阅读本文前，建议查阅相关资料，了解 KNN 算法与 KD 树。基础知识如图所示，假设一个点 a 目前的最近邻点为 b，如果存在相对于 b 离 a 更近的点，那么这个点一定在以 a 为圆心，ab 为半径的圆内。 现右侧的区域是未知的，如果 a 到分界线的距离 l 大于目前的最近距离 L（圆半径），则没有必要在右侧的未知区域继续寻找最近邻点（如图一），反之，则要继续
kd_tree实现代码
08-04
这里面是kd_tree的实现算法，看完对kd_tree将会有更深的了解
手写Kd树（C++模板非递归实现）
我爱调试
07-22 1402
本文实现的Kd树实现参考了高翔博士的书《自动驾驶与机器人中的slam技术从理论到实践》；高博士原书中是递归形式实现的，本文改写成了while循环的形式，避免了特大规模点云时的栈溢出问题，并且通过C++无类型模板参数，理论上可以实现广义上的无穷维点云的最近邻匹配。
机器学习中的KD树简单Python实现。.zip
04-12
随着统计学的发展，统计学习在机器学习中占据了重要地位，支持向量机（SVM）、决策树和随机森林等算法的提出和发展，使得机器学习能够更好地处理分类、回归和聚类等任务。进入21世纪，深度学习成为机器学习领域的...
基于kd树的kNN算法代码实现
04-27
**基于kd树的kNN算法代码实现** kNN（k-Nearest Neighbors）算法是一种简单而有效的非参数机器学习方法，广泛应用于分类和回归问题。它的基本思想是：一个未知样本点的类别由其最近的k个已知类别的训练样本点的多数...
KD树的概念、构建和最近邻搜索算法实现（PCL/C++）
JimmyC18的博客
08-19 1778
KD树（K-Dimension Tree）是一种用于组织k维空间中点集的数据结构，它通过构建树形结构来高效地进行多维空间信息的搜索，如最近邻搜索、范围搜索等。本文主要介绍了KD树的基础特性，构建过程和基于PCL实现的最近邻搜索算法。
C++实现K最邻近算法(机器学习 KNN KD树)
08-17
本文将详细介绍C++如何实现KNN算法，并结合KD树（K-Dimensional Tree）进行优化，以提高在大数据集上的处理效率。 KNN算法的基本思想是：对于一个未知类别的样本，我们将其与训练集中已知类别的样本进行比较，找到...
C++代码实现KD树的构建与遍历
12-20
用C++实现KD树的构建以及递归输出。。。
kd树实现（C++）
04-08
一个kd树的代码，希望可以帮助大家，相互学习。
kd树建立 MATLAB源代码
05-05
用于建立kd树数据结构，对于做图像处理的人应该很有用
c++实现kd树
weixin_30352645的博客
12-25 776
1 #ifndef _KD_TREE_H_ 2 #define _KD_TREE_H_ 3 4 #include <memory> 5 #include <vector> 6 #include <algorithm> 7 #include <iostream> 8 #include <fu...
kd树的简单实现
LZEP2015的专栏
10-23 994
kd树在特征匹配中有着重要的作用
K-D树的Python实现
小威的博客
01-23 465
""" K-D Tree 实现了构建和检索 author:小威 """ from __future__ import print_function import heapq import math class KDNode(object): """节点""" def __init__(self, data=None, left=None, right=None, axis=None, sel_axis=None, dimensions=None):
9. k_d tree原理及python代码实现
最新发布
weixin_71719718的博客
08-26 1512
k_d tree其实就是多维（空间二叉树的一种特殊情况）， 里面储存着k维的点的信息，是对k维空间进行划分的一种数据结构。本文看了博客，这篇博客写的很详细，只是这里对这篇博客进行了扩展。在点云操作中，常常需要从大量点云中找到距离输入点最近的点，如果使用线性搜索，逐个判断与输入点的距离，那么搜寻耗时将会与点云规模呈线性上升趋势，时间复杂度为O ( N ) O(N)O(N)。显然这不是我们想看到的，在数据结构与算法中，对常用的搜索方法是为O(logN)，它本质上是构建一棵二叉搜索树，以空间换取时间。
kd树 python实现_统计学习方法---K-近邻（kd树实现）
weixin_39555951的博客
11-26 446
以二维平面点((x,y))的集合(2,3)，(5,4)，(9,6)，(4,7)，(8,1)，(7,2)为例结合下图来说明k-d tree的构建过程。（一）构建步骤1.构建根节点时，此时的切分维度为(x)，如上点集合在(x)维从小到大排序为：(2,3)，(4,7)，(5,4)，(7,2)，(8,1)，(9,6)；其中中位数为7，选择中值(7,2)。（注：2,4,5,7,8,9在数学中的中值为(5 +...
Kd树的具体实现
qq_19094871的博客
04-26 849
Kd树的实现pythonKd树的原理李航的统计学习方法介绍的Kd树网上大部分创建Kd树的思路Kd树的实现sklearn 库中的iris作为本次实验数据集python实现 Kd树的原理 李航的统计学习方法介绍的Kd树 输入：m维空间数据集S={x1,x2,x3,...,xn}S =\{x_{1},x_{2},x_{3},...,x_{n}\}S={x1​,x2​,x3​,...,xn​},其中xi=...
k近邻算法__kd树实现
matt_hzf的博客
10-13 792
k近邻算法__kd树实现第一部分、K近邻算法1.1、什么是K近邻算法 K近邻算法，简称KNN算法，通俗地说：就是寻找K个最近的邻居；当K=1时，算法便成了最近邻算法，即寻找最近的那个邻居。 用官方的话来说，所谓K近邻算法，即是给定一个训练集，对新的输入实例，在训练集中找到与该实例最邻近的K个实例（也就是上面所说的K个邻居），这K个实例的多数属于某个类，就把该输入实例分类到这个类中。 根据
全面解读kd搜索树：功能实现与应用
kd树（k-dimensional tree）是一种用于组织点在k维空间中的数据结构。这种树结构能够高效地解决多维空间的搜索问题，如最近邻搜索或范围搜索等。作为一种特殊的数据结构，kd树具有重要的计算机科学理论意义和广泛的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值