K近邻算法(KNN)的C++实现
knn算法的实现方法
knn算法的实现方法KNN算法是一种常见的分类算法，其全称为K-Nearest Neighbor算法，即K近邻算法。
该算法的基本思想是：对于一个未知样本，找到与其最近的K个已知样本，将这K个样本中出现最多的类别作为该未知样本的类别。
KNN算法的实现方法主要包括以下几个步骤：1. 数据预处理在使用KNN算法进行分类之前，需要对数据进行预处理。
预处理的主要目的是将数据转换为算法能够处理的形式。
具体来说，需要将数据转换为数值型数据，并进行归一化处理。
这样可以避免不同特征之间的差异对分类结果的影响。
2. 计算距离KNN算法的核心是计算样本之间的距离。
常用的距离计算方法有欧氏距离、曼哈顿距离、切比雪夫距离等。
在计算距离时，需要考虑不同特征之间的权重，以避免某些特征对距离的影响过大。
3. 选择K值K值的选择对KNN算法的分类结果有很大的影响。
一般来说，K值越小，模型越复杂，容易出现过拟合；K值越大，模型越简单，容易出现欠拟合。
因此，需要通过交叉验证等方法来选择合适的K值。
4. 进行分类在计算出样本之间的距离并选择好K值之后，就可以进行分类了。
具体来说，需要找到与未知样本最近的K个已知样本，并统计这K个样本中出现最多的类别。
将该类别作为未知样本的类别即可。
KNN算法的优缺点：优点：1. 简单易懂，易于实现。
2. 对于非线性数据具有较好的分类效果。
3. 对于小样本数据具有较好的分类效果。
缺点：1. 计算复杂度高，需要计算每个未知样本与所有已知样本之间的距离。
2. 对于高维数据，距离计算会受到维度灾难的影响。
3. 对于不平衡数据，容易出现分类偏差。
总结：KNN算法是一种简单易懂的分类算法，其实现方法也比较简单。
但是，KNN算法也存在一些缺点，如计算复杂度高、对高维数据不适用等。
因此，在实际应用中需要根据具体情况选择合适的算法。
knn算法的实现流程
knn算法的实现流程knn算法（k-Nearest Neighbors）是一种基于实例的学习方法，它的核心思想是通过找到与要预测数据最相似的k个样本来进行分类或回归。
knn算法在分类、回归和数据挖掘等领域都有着广泛的应用。
本文将介绍knn算法的实现流程。
1. 收集数据我们需要收集训练数据。
训练数据通常由多个样本组成，每个样本都有多个特征和一个标签。
在分类问题中，标签表示样本所属的类别；在回归问题中，标签则表示样本的目标值。
在实际应用中，我们可以通过爬虫、采集和数据库等方式来获取训练数据。
2. 数据预处理在收集到数据后，我们需要对数据进行预处理。
预处理的目的是为了让数据适合knn算法的要求。
首先，我们需要对数据进行归一化处理，将所有特征的值缩放到同一范围内。
其次，我们需要对数据进行清洗和去重，确保数据的质量和准确性。
3. 选择k值knn算法中的k值表示需要选择的最近邻居个数。
k值的选择对算法的性能和准确性有着重要的影响。
通常，我们可以通过交叉验证等方式来选择最合适的k值。
4. 计算距离在knn算法中，我们需要计算目标样本与所有训练样本之间的距离。
距离计算通常采用欧氏距离、曼哈顿距离、闵可夫斯基距离等方式。
距离计算的目的是为了找到与目标样本最相似的k个训练样本。
5. 选择k个最近邻居在计算完目标样本与所有训练样本之间的距离后，我们需要选择与目标样本最相似的k个训练样本。
通常，我们可以采用堆排序等方式来实现k个最近邻居的选择。
6. 进行分类或回归在选择完k个最近邻居后，我们需要根据这k个训练样本的标签来进行分类或回归。
在分类问题中，我们可以采用多数表决等方式来确定目标样本所属的类别；在回归问题中，我们可以采用加权平均等方式来预测目标样本的目标值。
7. 评估算法性能在完成knn算法的实现后，我们需要对算法的性能进行评估。
通常，我们可以采用精确度、召回率、F1值等指标来评估算法的性能。
同时，我们也可以通过与其他算法进行比较来评估算法的优劣。
人工智能实验-k-近邻算法
k-近邻算法一、 实验题目1. kNN 代码实现-AB 分类采用测量不同特征值之间的距离方法进行分类，用所给的函数创建具有两个特征与一个标签类型的数据作 为训练集，编写 classify0 函数对所给的数据进行 AB 分类。
2. k-近邻算法改进约会网站的配对效果k-近邻算法改进约会网站的配对效果通过收集的一些约会网站的数据信息，对匹配对象的归类：不喜欢的人、魅力一般的人、极具魅力的人。
数据中包含了 3 种特征：每年获得的飞行常客里程数、玩视频游戏所耗时间百分比、每周消费的冰淇淋公升数二、 实验代码1. kNN 代码实现-AB 分类kNN from http.client import ImproperConnectionStatefrom numpy import ∗ from collections importCounter import operator def createDataSet():group = array([[1.0, 1.1], [1.0, 1.0], [0, 0], [0, 0.1]])labels = [’A ’, ’A ’, ’B’, ’B’] return group, labelsdef classify0(inX, group, labels, k = 3):res1 = (inX − group)∗∗2 dist =res1[:,0] + res1[:,1] dic = argsort(dist) dic = dic[0:k:1] newdic = [] for i in range (k): newdic.append(labels[dic[i]]) c = Counter(newdic).most_common(1) return c[0][0] tests import kNN group, lables = kNN.createDataSet() print (’分类结果’) print (’[0,0] %c’ %(kNN.classify0([0, 0], group, lables, k = 3))) print (’[0.8,0.7] %c’ %(kNN.classify0([0.8, 0.7], group, lables, k = 3)))2.k-近邻算法改进约会网站的配对效果1 2 3 4 5 67 8 910111213141516171819 1 2 3 4 5import pandas as pdimport kNNfrom sklearn.model_selection import train_test_splitdf = pd.read_table(’datingTestSet2.txt’,sep=’\s+’, names = [’A ’, ’B’, ’C’, ’Y’])# 对特征进行归一化处理df2 = df.iloc[:, :3] df2 =(df2−df2.mean())/df2.std() lable=df.iloc[:,3:4] df2.loc[:, ’Y’] =lable# 对数据集进行测试集和训练集划分，90%作为训练集，10%作为测试集X_train, X_test, Y_train, Y_test = train_test_split(df2.iloc[:, :3], df2.Y, train_size=.90)# 将DataFrame 格式转化为numpy 格式处理 group = X_train.values label =Y_train.values length =len (X_test) X_test.iloc[0:1,:]# res 以储存测试结果res = []# 设置错误正确数count 以计算正确率Tnum = 0 Fnum = 0 for iin range (length):inX = X_test.iloc[i:i+1 , :].values res.append(kNN.classify0(inX,group, label, k = 3)) if (kNN.classify0(inX, group, label, k = 3) ==Y_test.values[i]):Tnum += 1 else :Fnum += 1res1 = pd.DataFrame(data = res, columns=[’TestResult’])Y_test.reset_index(inplace=True,drop=True)res1.loc[:, ’OriginTest’] = Y_testprint (’前20个数据测试结果和原数据比较’) print (’−−−−−−−−−−−−−−−−−−−−−——−−−−’) print (res1.head(20))print (’−−−−−−−−−−−−−−−−−−−−−——−−−−’) print (’正确率%.2f%%’ %(100∗Tnum/(Tnum+Fnum))) 三、 实验结果及分析1. kNN 代码实现-AB 分类分类结果[0, 0] B[0.8, 0.7] A2. k-近邻算法改进约会网站的配对效果1 2 3 45 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 2526 27 28 29 3031 32 33 3435363738 1 2 3前20个数据测试结果和原数据比较−−−−−−−−−−−−−−−−−−−−−——−−−TestResult OriginTest0 2 2 1 3 3 2 1 3 3 2 2 4 2 2 5 3 3 6 3 3 7 2 2 8 1 1 9 1 1 10 1 1 11 3 3 12 2 2 13 2 2 14 1 1 15 2 2 16 1 1 17 2 2 18 1 1 19 3 3−−−−−−−−−−−−−−−−−−−−−——−−− 正确率97.00%从实验结果可以看出，通过 k-近邻算法改进后的约会网站的配对效果比较显著，多次随机划分测试集和训练集后发现正确率基本可以达到 90% 以上。
k近邻算法的原理和实现过程
k近邻算法的原理和实现过程
k近邻算法是一种基本的分类和回归算法，它的原理和实现过程如下：
原理：
1. 确定一个样本的k个最近的邻居，即选取与该样本距离最近的k个样本。
2. 根据这k个最近邻居的标签进行投票或者加权，确定该样本的预测标签。
如果
是分类问题，那么选取票数最多的标签作为预测标签；如果是回归问题，那么选
取k个最近邻居的标签的平均值作为预测标签。
实现过程：
1. 准备数据集：收集已知样本和其对应的标签。
2. 确定距离度量准则：选择合适的距离度量准则来度量样本间的距离，例如欧氏
距离、曼哈顿距离等。
3. 选择合适的k值：根据问题的要求选择适当的k值。
4. 计算样本之间的距离：对于每个未知样本，计算它与已知样本之间的距离，选
择k个最近邻居。
5. 统计k个最近邻居的标签：对于分类问题，统计k个最近邻居的标签的出现次数，并选择出现次数最多的标签作为预测标签；对于回归问题，计算k个最近邻
居的标签的平均数作为预测标签。
6. 将样本进行分类或预测：根据预测标签将未知样本进行分类或预测。
需要注意的是，在实际应用中，可以采取一些优化措施来提高k近邻算法的效率，比如使用kd树来加速最近邻搜索过程。
还可以对特征进行归一化处理，以避免
某些特征的权重过大对距离计算的影响。
kNN（k近邻）算法代码实现
kNN（k近邻）算法代码实现⽬标：预测未知数据(或测试数据)X的分类y批量kNN算法1.输⼊⼀个待预测的X(⼀维或多维)给训练数据集,计算出训练集X_train中的每⼀个样本与其的距离2.找到前k个距离该数据最近的样本-->所属的分类y_train3.将前k近的样本进⾏统计，哪个分类多，则我们将x分类为哪个分类# 准备阶段：import numpy as np# import matplotlib.pyplot as pltraw_data_X = [[3.393533211, 2.331273381],[3.110073483, 1.781539638],[1.343808831, 3.368360954],[3.582294042, 4.679179110],[2.280362439, 2.866990263],[7.423436942, 4.696522875],[5.745051997, 3.533989803],[9.172168622, 2.511101045],[7.792783481, 3.424088941],[7.939820817, 0.791637231]]raw_data_y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]X_train = np.array(raw_data_X)y_train = np.array(raw_data_y)x = np.array([8.093607318, 3.365731514])核⼼代码：⽬标：预测未知数据(或测试数据)X的分类y批量kNN算法1.输⼊⼀个待预测的X(⼀维或多维)给训练数据集,计算出训练集X_train中的每⼀个样本与其的距离2.找到前k个距离该数据最近的样本-->所属的分类y_train3.将前k近的样本进⾏统计，哪个分类多，则我们将x分类为哪个分类from math import sqrtfrom collections import Counter# 已知X_train，y_train# 预测x的分类def predict(x, k=5):# 计算训练集每个样本与x的距离distances = [sqrt(np.sum((x-x_train)**2)) for x_train in X_train] # 这⾥⽤了numpy的fancy⽅法，np.sum((x-x_train)**2) # 获得距离对应的索引，可以通过这些索引找到其所属分类y_trainnearest = np.argsort(distances)# 得到前k近的分类ytopK_y = [y_train[neighbor] for neighbor in nearest[:k]]# 投票的⽅式，得到⼀个字典，key是分类，value数个数votes = Counter(topK_y)# 取出得票第⼀名的分类return votes.most_common(1)[0][0] # 得到y_predictpredict(x, k=6)⾯向对象的⽅式，模仿sklearn中的⽅法实现kNN算法：import numpy as npfrom math import sqrtfrom collections import Counterclass kNN_classify:def__init__(self, n_neighbor=5):self.k = n_neighborself._X_train = Noneself._y_train = Nonedef fit(self, X_train, y_train):self._X_train = X_trainself._y_train = y_trainreturn selfdef predict(self, X):'''接收多维数据，返回y_predict也是多维的'''y_predict = [self._predict(x) for x in X]# return y_predictreturn np.array(y_predict) # 返回array的格式def _predict(self, x):'''接收⼀个待预测的x，返回y_predict'''distances = [sqrt(np.sum((x-x_train)**2)) for x_train in self._X_train] nearest = np.argsort(distances)topK_y = [self._y_train[neighbor] for neighbor in nearest[:self.k]]votes = Counter(topK_y)return votes.most_common(1)[0][0]def__repr__(self):return'kNN_clf(k=%d)' % self.k。
knn算法的实现过程
knn算法的实现过程KNN算法是一种基于距离最近的分类算法，KNN全称为K-Nearest-Neighbors，也就是K个最近邻点。
在分类的时候，对于一个新的数据点，KNN算法会先找到K个与该数据点距离最近的已知类别样本，接着根据这K个样本的类别进行投票，选择票数最多的类别作为新数据点的类别。
这种算法简单有效，又不需要太多的先验信息和经验，因此在很多实际应用案例中得到了广泛的应用。
KNN算法实现的前提是我们需要有一些已知类别的样本点，作为算法的训练数据，这些训练数据的类别应该尽可能地代表我们将来需要进行分类的实例的不同状态。
当然，在数据的质量和样本的选取上，对于KNN算法的效果也有很大的影响。
一般实现KNN算法的流程如下：1. 数据预处理：首先我们需要将数据预处理成算法能够处理的矩阵数据，一般来说，我们需要将每个数据点的所有属性值都存放到该点的特征向量中，对于一个d维的数据点，其特征向量x可以表示成：x = [x1, x2, x3, …, xd]在实际应用中，比较常见的数据预处理工作包括数据清洗、数据离散化和数据归一化等。
2. 计算距离：在将预处理后的数据存储为矩阵数据后，我们需要计算新数据点与旧数据点之间的距离，这里一般可以使用欧氏距离、曼哈顿距离、余弦距离、皮尔森相关系数等距离计算法。
例如，使用欧式距离的公式为：d(x,y) = sqrt(∑(xi-yi)^2)其中Xi和Yi分别是特征向量X和Y的第i个属性值，∑是对所有i的和。
3. 寻找最近邻点：根据我们计算出来的距离，我们需要寻找出与新数据点距离最近的K个训练样本点，并统计这K个点所属的不同的分类结果，选取票数最多的类别作为新数据点所属类别。
4. 输出分类结果：根据我们上一步寻找到的K个最近邻点所属的类别，并根据投票的结果，我们就可以得出新数据点的分类结果。
通常情况下，当我们寻找到K个最近邻点时，我们可以为每个点设置权重，将距离近的点赋予更高的权重，可提升算法的分类结果。
Python机器学习（十三）最近邻居k-近邻算法
Python机器学习（⼗三）最近邻居k-近邻算法KNN算法是⼀种基于实例的学习，或者是局部近似和将所有计算推迟到分类之后的惰性学习。
⽤最近的邻居（k）来预测未知数据点。
k 值是预测精度的⼀个关键因素，⽆论是分类还是回归，衡量邻居的权重都⾮常有⽤，较近邻居的权重⽐较远邻居的权重⼤。
KNN 算法的缺点是对数据的局部结构⾮常敏感。
计算量⼤，需要对数据进⾏规范化处理，使每个数据点都在相同的范围。
ML_Alg_KNN.gif代码实现：from sklearn import datasetsfrom sklearn.neighbors import KNeighborsClassifier#digit dataset from sklearndigits = datasets.load_digits()#create the KNeighborsClassifierclf = KNeighborsClassifier(n_neighbors=6)#set training setx, y = digits.data[:-1], digits.target[:-1]#train modelclf.fit(x, y)#predicty_pred = clf.predict([digits.data[-1]])y_true = digits.target[-1]print(y_pred)print(y_true)执⾏结果：C:\Anaconda3\python.exe "C:\Program Files\JetBrains\PyCharm 2019.1.1\helpers\pydev\pydevconsole.py" --mode=client --port=49329import sys; print('Python %s on %s' % (sys.version, sys.platform))sys.path.extend(['C:\\app\\PycharmProjects', 'C:/app/PycharmProjects'])Python 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)]Type 'copyright', 'credits'or'license'for more informationIPython 7.12.0 -- An enhanced Interactive Python. Type '?'for help.PyDev console: using IPython 7.12.0Python 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)] on win32runfile('C:/app/PycharmProjects/ArtificialIntelligence/test.py', wdir='C:/app/PycharmProjects/ArtificialIntelligence')[8]8延伸：KNN 的⼀个缺点是依赖于整个训练数据集，学习向量量化（Learning Vector Quantization，LVQ)是⼀种监督学习的⼈神经⽹络算法，允许你选择训练实例。
KNN算法的实现
KNN算法的实现K近邻（KNN）算法简介 KNN是通过测量不同特征值之间的距离进⾏分类。
它的思路是：如果⼀个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的⼤多数属于某⼀个类别，则该样本也属于这个类别，其中K通常是不⼤于20的整数。
KNN算法中，所选择的邻居都是已经正确分类的对象。
该⽅法在定类决策上只依据最邻近的⼀个或者⼏个样本的类别来决定待分样本所属的类别。
下⾯通过⼀个简单的例⼦说明⼀下：如下图，绿⾊圆要被决定赋予哪个类，是红⾊三⾓形还是蓝⾊四⽅形？如果K=3，由于红⾊三⾓形所占⽐例为2/3，绿⾊圆将被赋予红⾊三⾓形那个类，如果K=5，由于蓝⾊四⽅形⽐例为3/5，因此绿⾊圆被赋予蓝⾊四⽅形类。
由此也说明了KNN算法的结果很⼤程度取决于K的选择。
在KNN中，通过计算对象间距离来作为各个对象之间的⾮相似性指标，避免了对象之间的匹配问题，在这⾥距离⼀般使⽤欧⽒距离或曼哈顿距离：L1是曼哈顿距离：顾名思义，在曼哈顿街区要从⼀个⼗字路⼝开车到另⼀个⼗字路⼝，驾驶距离显然不是两点间的直线距离。
这个实际驾驶距离就是“曼哈顿距离”。
曼哈顿距离也称为“城市街区距离”(City Block distance)。
L2是我们的欧⽒距离：欧⽒距离是最容易直观理解的距离度量⽅法，我们⼩学、初中和⾼中接触到的两个点在空间中的距离⼀般都是指欧⽒距离。
我们⼀般都常⽤欧⽒距离。
同时，KNN通过依据k个对象中占优的类别进⾏决策，⽽不是单⼀的对象类别决策。
这两点就是KNN算法的优势。
接下来对KNN算法的思想总结⼀下：就是在训练集中数据和标签已知的情况下，输⼊测试数据，将测试数据的特征与训练集中对应的特征进⾏相互⽐较，找到训练集中与之最为相似的前K个数据，则该测试数据对应的类别就是K个数据中出现次数最多的那个分类。
其算法的描述为：1）计算测试数据与各个训练数据之间的距离；2）按照距离的递增关系进⾏排序；3）选取距离最⼩的K个点；4）确定前K个点所在类别的出现频率；5）返回前K个点中出现频率最⾼的类别作为测试数据的预测分类。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
本文不对KNN算法做过多的理论上的解释，主要是针对问题，进行算法的设计和代码的注解。
KNN算法：优点：精度高、对异常值不敏感、无数据输入假定。
缺点：计算复杂度高、空间复杂度高。
适用数据范围：数值型和标称性。
工作原理：存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。
输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最近邻）的分类标签。
一般来说，我们只选择样本数据及中前ｋ个最相似的数据，这就是k-近邻算法中k的出处，通常k选择不大于20的整数。
最后，选择k个最相似数据中出现次数最多的分类，作为新数据的分类。
K-近邻算法的一般流程：（1）收集数据：可以使用任何方法（2）准备数据：距离计算所需要的数值，最好是结构化的数据格式（3）分析数据：可以使用任何方法（4）训练算法：此步骤不适用k-邻近算法（5）测试算法：计算错误率（6）使用算法：首先需要输入样本数据和结构化的输出结果，然后运行k-近邻算法判定输入数据分别属于哪个分类，最后应用对计算出的分类执行后续的处理。
问题一：现在我们假设一个场景，就是要为左边上的点进行分类，如下图所示：上图一共12个左边点，每个坐标点都有相应的坐标(x,y)以及它所属的类别A/B，那么现在需要做的就是给定一个点坐标(x1,y1)，判断它属于的类别A或者B。
所有的坐标点在data.txt文件中：0.0 1.1 A1.0 1.0 A2.0 1.0 B0.5 0.5 A2.5 0.5 B0.0 0.0 A1.0 0.0 A2.0 0.0 B3.0 0.0 B0.0 -1.0 A1.0 -1.0 A2.0 -1.0 Bstep1：通过类的默认构造函数去初始化训练数据集dataSet和测试数据testData。
step2：用get_distance()来计算测试数据testData和每一个训练数据dataSet[index]的距离，用map_index_dis来保存键值对<index,distance>,其中index代表第几个训练数据，distance代表第index个训练数据和测试数据的距离。
step3：将map_index_dis按照value值（即distance值）从小到大的顺序排序，然后取前k个最小的value值，用map_label_freq来记录每一个类标签出现的频率。
step4：遍历map_label_freq中的value值，返回value最大的那个key 值，就是测试数据属于的类。
看一下代码KNN_：#include<iostream>#include<map>#include<vector>#include<stdio.h>#include<cmath>#include<cstdlib>#include<algorithm>#include<fstream>using namespace std;typedef char tLabel;typedef double tData;typedef pair<int,double> PAIR;constintcolLen = 2;constintrowLen = 12;ifstream fin;ofstreamfout;class KNN{private:tDatadataSet[rowLen][colLen];tLabel labels[rowLen];tDatatestData[colLen];int k;map<int,double>map_index_dis;map<tLabel,int>map_label_freq;doubleget_distance(tData *d1,tData *d2);public:KNN(int k);voidget_all_distance();voidget_max_freq_label();structCmpByValue{bool operator() (const PAIR&lhs,const PAIR&rhs){returnlhs.second<rhs.second;}};};KNN::KNN(int k){this->k = k;fin.open("data.txt");if(!fin){cout<<"can not open the file data.txt"<<endl;exit(1);}/* input the dataSet */for(inti=0;i<rowLen;i++){for(int j=0;j<colLen;j++){fin>>dataSet[i][j];}fin>>labels[i];}cout<<"please input the test data :"<<endl;/* inuput the test data */for(inti=0;i<colLen;i++)cin>>testData[i];}/** calculate the distance between test data and dataSet[i]*/double KNN:: get_distance(tData *d1,tData *d2){double sum = 0;for(inti=0;i<colLen;i++){sum += pow( (d1[i]-d2[i]) , 2 );}// cout<<"the sum is = "<<sum<<endl;returnsqrt(sum);}/** calculate all the distance between test data and each training data*/void KNN:: get_all_distance(){double distance;inti;for(i=0;i<rowLen;i++){distance = get_distance(dataSet[i],testData);//<key,value> =><i,distance>map_index_dis[i] = distance;}//traverse the map to print the index and distancemap<int,double>::const_iterator it = map_index_dis.begin();while(it!=map_index_dis.end()){cout<<"index = "<<it->first<<" distance = "<<it->second<<endl;it++;}}/** check which label the test data belongs to to classify the test data*/void KNN:: get_max_freq_label(){//transform the map_index_dis to vec_index_disvector<PAIR>vec_index_dis( map_index_dis.begin(),map_index_dis.end() );//sort the vec_index_dis by distance from low to high to get the nearest datasort(vec_index_dis.begin(),vec_index_dis.end(),CmpByValue());for(inti=0;i<k;i++){cout<<"the index = "<<vec_index_dis[i].first<<" the distance ="<<vec_index_dis[i].second<<" the label = "<<labels[vec_index_dis[i].first]<<" the coordinate ( "<<dataSet[ vec_index_dis[i].first ][0]<<","<<dataSet[ vec_index_dis[i].first ][1]<<" )"<< endl;//calculate the count of each labelmap_label_freq[ labels[ vec_index_dis[i].first ] ]++;}map<tLabel,int>::const_iteratormap_it = map_label_freq.begin();tLabel label;intmax_freq = 0;//find the most frequent labelwhile(map_it != map_label_freq.end() ){if(map_it->second >max_freq ){max_freq = map_it->second;label = map_it->first;}map_it++;}cout<<"The test data belongs to the "<<label<<" label"<<endl;}int main(){int k ;cout<<"please input the k value : "<<endl;cin>>k;KNN knn(k);knn.get_all_distance();knn.get_max_freq_label();system("pause");return 0;}我们来测试一下这个分类器(k=5)：testData(5.0,5.0):testData(-5.0,-5.0):testData(1.6,0.5):分类结果的正确性可以通过坐标系来判断，可以看出结果都是正确的。