KD树+BBF+KNN使用C#实现（2）

最新推荐文章于 2023-07-16 00:16:18 发布
最新推荐文章于 2023-07-16 00:16:18 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： C# 文章标签： KD树 K最近邻查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjp837661103/article/details/9770311
版权

在上一节中我们讲解了KD的构造过程，这里我们主要讲解的KD的搜索过程，如何查找距离目标点最近的点。

我们先把KD树的最邻近搜索（KNN）的代码粘贴出来：

private Node KDTreeFindNearest(Node tree, Train target)
        {
            double dist = double.MaxValue; //最近邻和目标点之间的距离
            Node nearest = null;    //最近邻节点
            Node searchNode = tree; //根节点
            List<Node> searchPath = new List<Node>();   //搜索路径
            #region 检索搜索路径
            while (searchNode != null)
            {
                searchPath.Add(searchNode); //添加当前搜索节点

                if (searchNode.split == 0)
                {
                    //X方向轴分割
                    if (target.positionX <= searchNode.point.positionX)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
                else if (searchNode.split == 1)
                {
                    //Y方向轴分割
                    if (target.positionY <= searchNode.point.positionY)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
                else
                {
                    if (target.positionZ <= searchNode.point.positionZ)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
            }
            #endregion

            nearest = searchPath[searchPath.Count - 1]; //获取搜索路径最后一个节点
            searchPath.Remove(nearest); //从搜索路径中删除假定的最近邻节点

            //计算两个节点之间的距离
            dist = this.Distance(nearest.point, target);

            #region 回溯路径搜索

            Node backNode;
            int split = -1;
            while (searchPath.Count > 0)
            {
                backNode = searchPath[searchPath.Count - 1];    //取搜索路径最后一个
                if (backNode.leftNode == null && backNode.righNode == null)
                {
                    //该节点为叶子节点
                    if (Distance(nearest.point, target) > Distance(backNode.point, target))
                    {
                        nearest = backNode;
                        dist = Distance(backNode.point, target);
                    }
                }
                else
                {
                    split = backNode.split;     //取出当前的分割方向轴
                    if (split == 0)
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionX - backNode.point.positionX);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionX > backNode.point.positionX)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }

                    }
                    else if (split == 1)
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionY - backNode.point.positionY);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionY > backNode.point.positionY)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }
                    }
                    else
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionZ - backNode.point.positionZ);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionZ > backNode.point.positionZ)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }
                    }
                }

                searchPath.Remove(backNode);
            }

            #endregion

            return nearest;     //返回最近邻节点
        }

下面我们讲解一下搜索过程。

首先，我们从根节点开始搜索，一直搜索到目标点所在区域的叶子节点，同时假定叶子节点时距离目标点最近的节点，计算他们之间的欧几里德距离，并且假定这个距离值最近的距离。即：

double dist = double.MaxValue; //最近邻和目标点之间的距离
            Node nearest = null;    //最近邻节点
            Node searchNode = tree; //根节点
            List<Node> searchPath = new List<Node>();   //搜索路径
            #region 检索搜索路径
            while (searchNode != null)
            {
                searchPath.Add(searchNode); //添加当前搜索节点

                if (searchNode.split == 0)
                {
                    //X方向轴分割
                    if (target.positionX <= searchNode.point.positionX)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
                else if (searchNode.split == 1)
                {
                    //Y方向轴分割
                    if (target.positionY <= searchNode.point.positionY)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
                else
                {
                    if (target.positionZ <= searchNode.point.positionZ)
                    {
                        searchNode = searchNode.leftNode;
                    }
                    else
                        searchNode = searchNode.righNode;
                }
            }
            #endregion

            nearest = searchPath[searchPath.Count - 1]; //获取搜索路径最后一个节点
            searchPath.Remove(nearest); //从搜索路径中删除假定的最近邻节点

            //计算两个节点之间的距离
            dist = this.Distance(nearest.point, target);
其次，当搜索到叶子节点的时候，搜索路径已经确定，然后我们需要进行回溯查找，一直到搜索路径为空的时候，那么就结束搜索，返回搜索到的最近邻节点。当然在回溯查找的过程中，我们也是搜索到子树的叶子节点问题。 

#region 回溯路径搜索

            Node backNode;
            int split = -1;
            while (searchPath.Count > 0)
            {
                backNode = searchPath[searchPath.Count - 1];    //取搜索路径最后一个
                if (backNode.leftNode == null && backNode.righNode == null)
                {
                    //该节点为叶子节点
                    if (Distance(nearest.point, target) > Distance(backNode.point, target))
                    {
                        nearest = backNode;
                        dist = Distance(backNode.point, target);
                    }
                }
                else
                {
                    split = backNode.split;     //取出当前的分割方向轴
                    if (split == 0)
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionX - backNode.point.positionX);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionX > backNode.point.positionX)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }

                    }
                    else if (split == 1)
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionY - backNode.point.positionY);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionY > backNode.point.positionY)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }
                    }
                    else
                    {
                        if (Distance(backNode.point, target) < dist)
                        {
                            nearest = backNode;
                            dist = Distance(backNode.point, target);
                        }

                        //确定是否进入子空间搜索
                        float disTmp = Math.Abs(target.positionZ - backNode.point.positionZ);
                        if (disTmp < dist)
                        {
                            //判断目标点是在左子空间还是右子空间
                            if (target.positionZ > backNode.point.positionZ)
                            {
                                //目标点在右子空间，则需要进入左子空间进行搜索
                                searchNode = backNode.leftNode;
                            }
                            else
                                searchNode = backNode.righNode;

                            searchPath.Add(searchNode);     //添加搜索节点
                        }
                    }
                }

                searchPath.Remove(backNode);
            }

            #endregion

代码下载

踏雪_无痕
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
KD树+KNN+BBF搜索
08-05
在C#中实现KD树，我们可以构建一个能够高效存储和查询多维数据点的结构。 1. **KD树的构造** - 分割策略：构造KD树的关键在于如何选择分割超平面。通常采用最大方差轴向（Maximal Variance Axis）或最小边界轴向...
KNN算法与Kd树（转载+代码详细解释）
微电子学与固体电子学-俞驰
07-17 1272
最近邻法和k-近邻法 　　下面图片中只有三种豆，有三个豆是未知的种类，如何判定他们的种类？ 提供一种思路，即：未知的豆离哪种豆最近就认为未知豆和该豆是同一种类。由此，我们引出最近邻算法的定义：为了判定未知样本的类别，以全部训练样本作为代表点，计算未知样本与所有训练样本的距离，并以最近邻者的类别作为决策未知样本类别的唯一依据。但是，最近邻算法明显是存在缺陷的，比如下面的例子：有一个未知形状(图中绿...
KD树详解及KD树最近邻算法
生活不止眼前的枸杞， 还有蜂蜜和咖啡！
06-08 5402
&amp;nbsp; &amp;nbsp; 一般说来，索引结构中相似性查询有两种基本的方式： 一种是范围查询，范围查询时给定查询点和查询距离阈值，从数据集中查找所有与查询点距离小于阈值的数据另一种是K近邻查询，就是给定查询点及正整数K，从数据集中找到距离查询点最近的K个数据，当K=1时，它就是最近邻查询。&amp;nbsp; &amp;nbsp; 同样，针对特征点匹配也有两种方法： 最容易的办法就是线性扫描，也就是我们常...
C#实现KD树
weixin_71224572的博客
07-16 298
【代码】C#实现KD树。
K-D树
热门推荐
ACdreamer
03-27 1万+
K-D树，即K-Dimensional Tree，是一种高维索引树型数据结构。常用于大规模高维数据空间的最邻近或者K邻 近查找，例如图像检索中高维图像特征向量的K邻近匹配，对KNN算法的优化等。   Contents      1. K-D树的基本原理    2. K-D树的改进（BBF算法）    3. K-D树的C++实现    4. K-D树的开源框架介绍     1.
C# 通过KD树进行距离最近点的查找.
aitukang0425的博客
09-26 662
本文首先介绍Kd-Tree的构造方法，然后介绍Kd-Tree的搜索流程及代码实现，最后给出本人利用C#语言实现的二维KD树代码。这也是我自己动手实现的第一个树形的数据结构。理解上难免会有偏差，敬请各位多多斧正。 1. KD树介绍 Kd-Tree（KD树），即K-dimensional tree，是一种高维索引树形数据结构，常用于在大规模的高维数据空间进行最邻近查找和近似最邻近查找。我实现...
如何利用 C# 实现 K-D Tree 结构？
老马的程序人生
03-12 4064
我的朋友海伦一直使用在线约会网站寻找适合自己的约会对象。尽管约会网站会推荐不同的人选，但她没有从中找到喜欢的人。经过一番总结，她发现曾交往过三种类型的人： 不喜欢的人 魅力一般的人 极具魅力的人 尽管发现了上述规律，但海伦依然无法将约会网站推荐的匹配对象归入恰当的分类。她觉得可以在周一到周五约会哪些魅力一般的人，而周末则更喜欢与那些极具魅力的人为伴。海伦希望我们的分类软件可以更好地帮助她匹配对...
从K近邻算法、距离度量谈到KD树、SIFT+BBF算法
03-03
这点儿小忙还说，不地道”，有的时候，稍许感受到受人信任也是一种压力，愿我不辜负大家对我的信任），于是今天开始Top10AlgorithmsinDataMining系列第三篇文章，即本文「从K近邻算法谈到KD树、SIFT+BBF算法」的创作...
用python手写KNN算法+kd树及其BBF优化（原理与实现）（上篇）
01-20
用python手写KNN算法+kd树及其BBF优化（原理与实现）（上篇） 初学python和机器学习，突然兴起想动手用python实践一下KNN算法，本来想着这个算法原理很简单明了，应该实现起来没什么大问题，然而真正上手的时候问题...
KNN算法C#实现
03-22
KNN算法C#实现
经典KD树数据结构C#实现
12-07
经典的kd树数据结构C#代码实现，代码通俗易懂，适合初学者学习
C#通过KD树进行距离最近点的查找
08-29
主要为大家详细介绍了C#通过KD树进行距离最近点的查找，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
KNN（k—近邻算法）算法C#实现
12-16
KNN算法C#实现 中文文本分词技术的常规算法 提供改进接口
KNN算法 C#程序
04-18
KNN算法 C#程序
从K近邻算法、距离度量谈到KD树、SIFT+BBF算法（二）
03-03
之前blog内曾经介绍过SIFT特征匹配算法，特征点匹配和数据库查、图像检索本质上是同一个问题，都可以归结为一个通过距离函数在高维矢量之间进行相似性检索的问题，如何快速而准确地找到查询点的近邻，不少人提出了很...
KD树-预排序加速以及动态化分割
weixin_40470384的博客
08-30 925
对于一个n维的kd树, 建树的大概步骤, 就是将高维的点集不断轮换其维度进行二分. 比如一个二维点Point的数组, 就先对其x轴分割, 再对其Y轴分割. 但分割时需要找到其中位数, 开销可能比较大. 一般来说有两种方案 : 1, 进行排序, 找到中位数. ( 时间开销: O(nlogn)O(nlogn)O(nlogn)) 2, 快速取第len/2个点. ( 时间开销: O(n)O(n)O(n)) 而且其常数项都比较高. 因此中位数必须等分割以后才可以计算, 而无法一开始就算好. 对此, 我们仔细观察分割
求解平面最近点，分治法，k-d树法
qq_43517189的博客
05-07 636
假设平面上有n个点，要求求解最近的两点之间的距离。 首先可以想到暴力法，遍历所有点求解其与其它点的最近距离，时间复杂度为O(n^2)。 但还有另外两种复杂度更低的方法，分治法和k-d树法。 分治法 分治法的详细介绍可以参考这两篇文章，原理都差不多。 https://blog.csdn.net/lytning/article/details/25370169 https://blog.csdn.ne...
什么是KD树？
Despicable_Me的博客
05-18 1597
KD树（K-Dimensional Tree）是一种用于高效处理多维数据的数据结构。它是二叉搜索树的一种变体，在每个节点上对数据进行分割，从而构建一个多维空间的层次结构。因为KD树是基于二叉搜索树的特性构建的，所以它保留了二叉搜索树的一些性质，例如在插入和搜索操作中的平均时间复杂度为O(log n)。但与传统的二叉搜索树不同的是，KD树的节点划分是基于多维空间的划分，而不仅仅是单个维度上的划分KD树主要用于解决最近邻搜索（Nearest Neighbor Search）等问题。
C#实现K-近邻(KNN)算法
HerryDong的博客
11-09 2377
KNN（k-nearest-neighbor）算法的思想是找到在输入新数据时，找到与该数据最接近的k个邻居，在这k个邻居中，找到出现次数最多的类别，对其进行归类。 Iris数据集是常用的分类实验数据集，由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。数据集包含150个数据集，分为3类，每类50个数据，每个数据包含4个属性。可通过花萼长度，花萼宽度，花瓣长...
kd-tree+bbf
最新发布
11-06
kd-tree和bbf（Best Bin First）都是用于高效地处理k维空间数据的算法。 kd-tree是一种用于快速检索k维空间中数据的树形结构。它通过递归地将数据集按照k维空间中的划分轴进行切分，每次选择一个划分点，并将其分成...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

踏雪_无痕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值