KNN算法实验报告
knn算法实验总结与体会
knn算法实验总结与体会KNN算法实验总结与体会KNN算法是一种常见的机器学习算法，它的原理比较简单，但是应用广泛。
在进行KNN算法实验时，我深刻领悟到以下几点：1. 数据预处理非常重要在进行KNN算法实验时，数据预处理是非常重要的一步。
数据预处理包括数据清洗、特征选择、特征提取等。
只有对数据进行充分的预处理，才能提高算法的准确性和效率。
2. K值的选择需要根据实际情况进行调整KNN算法中的K值是一个重要的参数，它决定了算法的准确性和效率。
在进行KNN算法实验时，我们需要根据实际情况进行K值的选择。
如果K值过小，算法会过拟合；如果K值过大，算法会欠拟合。
因此，我们需要通过实验来选择最合适的K值。
3. 距离度量方法的选择也很重要KNN算法中的距离度量方法有很多种，如欧氏距离、曼哈顿距离、切比雪夫距离等。
在进行KNN算法实验时，我们需要选择最合适的距离度量方法。
不同的距离度量方法对算法的准确性和效率有很大的影响。
4. 数据集的选择和样本数量的影响KNN算法的准确性和效率也与数据集的选择和样本数量有很大的关系。
在进行KNN算法实验时，我们需要选择最合适的数据集和样本数量。
只有选择合适的数据集和样本数量，才能提高算法的准确性和效率。
5. KNN算法的优缺点KNN算法有很多优点，如算法简单易懂、可解释性强、适用于多分类问题等。
但是KNN算法也有一些缺点，如算法计算复杂度高、对样本分布敏感、需要大量的存储空间等。
在进行KNN算法实验时，我们需要了解KNN算法的优缺点，才能更好地应用算法。
综上所述，KNN算法是一种简单而有效的机器学习算法。
在进行KNN算法实验时，我们需要充分考虑数据预处理、K值的选择、距离度量方法的选择、数据集的选择和样本数量的影响等因素。
只有深入理解KNN算法的原理和优缺点，才能更好地应用算法。
(完整word版)数据挖掘与实验报告(word文档良心出品)
中科大数据挖掘实验报告姓名樊涛声班级软设一班学号SA15226248实验一K邻近算法实验一实验内容使用k近邻算法改进约会网站的配对效果。
海伦使用约会网址寻找适合自己的约会对象，约会网站会推荐不同的人选。
她将曾经交往过的的人总结为三种类型：（1）不喜欢的人（2）魅力一般的人（3）极具魅力的人尽管发现了这些规律，但依然无法将约会网站提供的人归入恰当的分类。
使用KNN算法，更好的帮助她将匹配对象划分到确切的分类中。
二实验要求（1）独立完成kNN实验，基本实现可预测的效果（2）实验报告（3）开放性：可以自己增加数据或修改算法，实现更好的分类效果三实验步骤（1）数据源说明实验给出的数据源为datingTestSet.txt，共有4列，每一列的属性分别为：①percentage of time spenting playing vedio games；②frequent flied miles earned per year；③liters of ice cream consumed per year；④your attitude towars this people。
通过分析数据源中的数据，得到规律，从而判断一个人的前三项属性来得出划分海伦对他的态度。
（2）KNN算法原理对未知属性的某数据集中的每个点一次执行以下操作①计算已知类别数据集中的每一个点和当前点的距离②按照距离递增依次排序③选取与当前点距离最小的k个点④确定k个点所在类别的出现频率⑤返回k个点出现频率最高的点作为当前点的分类（3）KNN算法实现①利用python实现构造分类器首先计算欧式距离然后选取距离最小的K个点代码如下：def classify(inMat,dataSet,labels,k):dataSetSize=dataSet.shape[0]#KNN的算法核心就是欧式距离的计算，一下三行是计算待分类的点和训练集中的任一点的欧式距离diffMat=tile(inMat,(dataSetSize,1))-dataSetsqDiffMat=diffMat**2distance=sqDiffMat.sum(axis=1)**0.5#接下来是一些统计工作sortedDistIndicies=distance.argsort()classCount={}for i in range(k):labelName=labels[sortedDistIndicies[i]]classCount[labelName]=classCount.get(labelName,0)+1;sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True) return sortedClassCount[0][0]②解析数据输入文件名，将文件中的数据转化为样本矩阵，方便处理代码如下：def file2Mat(testFileName,parammterNumber):fr=open(testFileName)lines=fr.readlines()lineNums=len(lines)resultMat=zeros((lineNums,parammterNumber))classLabelVector=[]for i in range(lineNums):line=lines[i].strip()itemMat=line.split('\t')resultMat[i,:]=itemMat[0:parammterNumber]classLabelVector.append(itemMat[-1])fr.close()return resultMat,classLabelVector;返回值为前三列属性被写入到resultMat二维数组中，第四列属性作为标签写入到classLableVector中③归一化数据不同评价指标往往具有不同的量纲和量纲单位，这样的情况会影响到数据分析的结果，为了消除指标之间的量纲影响，需要进行数据标准化处理，使各指标处于同一数量级。
knn算法实战
一、kNN原理1、kNN算法概述kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。
该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
2、kNN算法介绍最简单最初级的分类器是将全部的训练数据所对应的类别都记录下来，当测试对象的属性和某个训练对象的属性完全匹配时，便可以对其进行分类。
但是怎么可能所有测试对象都会找到与之完全匹配的训练对象呢，其次就是存在一个测试对象同时与多个训练对象匹配，导致一个训练对象被分到了多个类的问题，基于这些问题呢，就产生了kNN。
kNN是通过测量不同特征值之间的距离进行分类。
它的的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
K通常是不大于20的整数。
kNN算法中，所选择的邻居都是已经正确分类的对象。
该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
下面通过一个简单的例子说明一下：如下图，绿色圆要被决定赋予哪个类，是红色三角形还是蓝色四方形？如果K=3，由于红色三角形所占比例为2/3，绿色圆将被赋予红色三角形那个类，如果K=5，由于蓝色四方形比例为3/5，因此绿色圆被赋予蓝色四方形类。
由此也说明了kNN算法的结果很大程度取决于K的选择。
在kNN中，通过计算对象间距离来作为各个对象之间的非相似性指标，避免了对象之间的匹配问题，在这里距离一般使用欧氏距离或曼哈顿距离：同时，kNN通过依据k个对象中占优的类别进行决策，而不是单一的对象类别决策。
这两点就是kNN算法的优势。
接下来对kNN算法的思想总结一下：就是在训练集中数据和标签已知的情况下，输入测试数据，将测试数据的特征与训练集中对应的特征进行相互比较，找到训练集中与之最为相似的前K个数据，则该测试数据对应的类别就是K个数据中出现次数最多的那个分类，其算法的描述为：1）计算测试数据与各个训练数据之间的距离；2）按照距离的递增关系进行排序；3）选取距离最小的K个点；4）确定前K个点所在类别的出现频率；5）返回前K个点中出现频率最高的类别作为测试数据的预测分类。
算法实验报告范文
实验题目：K近邻算法（K-Nearest Neighbors, KNN）在鸢尾花数据集上的应用一、实验目的1. 理解K近邻算法的基本原理和实现过程。
2. 掌握K近邻算法在分类问题中的应用。
3. 通过实验验证K近邻算法在鸢尾花数据集上的性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 库：NumPy，Matplotlib，Scikit-learn三、实验原理K近邻算法（KNN）是一种基于距离的最近邻分类算法。
其基本思想是：对于待分类的数据点，找到与它距离最近的K个数据点，这K个数据点中多数属于某个类别，则待分类数据点也属于该类别。
K近邻算法的步骤如下：1. 计算待分类数据点与训练集中每个数据点的距离。
2. 找到距离最近的K个数据点。
3. 根据这K个数据点的多数类别，对待分类数据点进行分类。
四、实验数据本次实验使用鸢尾花数据集（Iris dataset），该数据集包含150个样本，每个样本有4个特征（花瓣长度、花瓣宽度、花萼长度、花萼宽度），分为3个类别（setosa，versicolor，virginica）。
五、实验步骤1. 导入所需库和数据集。
```pythonfrom sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_scoreimport matplotlib.pyplot as pltimport numpy as np# 加载数据集iris = datasets.load_iris()X = iris.datay = iris.target```2. 数据预处理。
```python# 划分训练集和测试集X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)```3. 实现K近邻算法。
深入浅出KNN算法（二）sklearnKNN实践
深⼊浅出KNN算法（⼆）sklearnKNN实践姊妹篇：上次介绍了KNN的基本原理，以及KNN的⼏个窍门，这次就来⽤sklearn实践⼀下KNN算法。
⼀.Skelarn KNN参数概述要使⽤sklearnKNN算法进⾏分类，我们需要先了解sklearnKNN算法的⼀些基本参数，那么这节就先介绍这些内容吧。
def KNeighborsClassifier(n_neighbors = 5,weights='uniform',algorithm = '',leaf_size = '30',p = 2,metric = 'minkowski',metric_params = None,n_jobs = None)- n_neighbors：这个值就是指 KNN 中的 “K”了。
前⾯说到过，通过调整 K 值，算法会有不同的效果。
- weights（权重）：最普遍的 KNN 算法⽆论距离如何，权重都⼀样，但有时候我们想搞点特殊化，⽐如距离更近的点让它更加重要。
这时候就需要 weight 这个参数了，这个参数有三个可选参数的值，决定了如何分配权重。
参数选项如下：• 'uniform'：不管远近权重都⼀样，就是最普通的 KNN 算法的形式。
• 'distance'：权重和距离成反⽐，距离预测⽬标越近具有越⾼的权重。
• ⾃定义函数：⾃定义⼀个函数，根据输⼊的坐标值返回对应的权重，达到⾃定义权重的⽬的。
- algorithm：在 sklearn 中，要构建 KNN 模型有三种构建⽅式，1. 暴⼒法，就是直接计算距离存储⽐较的那种放松。
2. 使⽤ kd 树构建 KNN 模型 3. 使⽤球树构建。
其中暴⼒法适合数据较⼩的⽅式，否则效率会⽐较低。
如果数据量⽐较⼤⼀般会选择 • 'brute' ：蛮⼒实现• 'kd_tree'：KD 树实现 KNN• 'ball_tree'：球树实现 KNN• 'auto'：默认参数，⾃动选择合适的⽅法构建模型不过当数据较⼩或⽐较稀疏时，⽆论选择哪个最后都会使⽤ 'brute'- leaf_size：如果是选择蛮⼒实现，那么这个值是可以忽略的，当使⽤KD树或球树，它就是是停⽌建⼦树的叶⼦节点数量的阈值。
k最近邻算法实验报告
题目k-最近邻算法实现学生学生学号专业班级指导教师2015-1-2实验二k-最近邻算法实现一、实验目的1.加强对k-最近邻算法的理解；2.锻炼分析问题、解决问题并动手实践的能力。
二、实验要求使用一种你熟悉的程序设计语言，如C++或Java，给定最近邻数k和描述每个元组的属性数n，实现k-最近邻分类算法，至少在两种不同的数据集上比较算法的性能。
三、实验环境Win7 旗舰版+ Visual Studio 2010语言：C++四、算法描述KNN(k Nearest Neighbors)算法又叫k最临近方法。
假设每一个类包含多个样本数据，而且每个数据都有一个唯一的类标记表示这些样本是属于哪一个分类，KNN就是计算每个样本数据到待分类数据的距离。
如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
KNN 方法虽然从原理上也依赖于极限定理，但在类别决策时，只与极少量的相邻样本有关。
因此，采用这种方法可以较好地避免样本的不平衡问题。
另外，由于KNN 方法主要靠周围有限的邻近的样本，而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN 方法较其他方法更为适合。
该方法的不足之处是计算量较大，因为对每一个待分类的文本都要计算它到全体已知样本的距离，才能求得它的K 个最近邻点。
目前常用的解决方法是事先对已知样本点进行剪辑，事先去除对分类作用不大的样本。
该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这种算法比较容易产生误分。
1、 算法思路K-最临近分类方法存放所有的训练样本，在接受待分类的新样本之前不需构造模型，并且直到新的（未标记的）样本需要分类时才建立分类。
K-最临近分类基于类比学习，其训练样本由N 维数值属性描述，每个样本代表N 维空间的一个点。
(完整版)KNN算法实验报告
KNN 算法实验报告一试验原理K近来邻(k-NearestNeighbor ，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。
该方法的思路是：若是一个样本在特色空间中的 k 个最相似( 即特色空间中最周边 )的样本中的大多数属于某一个种类，那么该样本也属于这个种类。
KNN算法中，所选择的邻居都是已经正确分类的对象。
该方法在定类决策上只依照最周边的一个也许几个样本的种类来决定待分样本所属的种类。
KNN方法诚然从原理上也依赖于极限制理，但在种类决策时，只与极少量的相邻样本相关。
由于 KNN方法主要靠周围有限的周边的样本，而不是靠鉴识类域的方法来确定所属种类的，因此对于类域的交织或重叠很多的待分样本集来说， KNN方法较其他方法更为适合。
KNN算法不但能够用于分类，还可以够用于回归。
经过找出一个样本的 k 个近来邻居，将这些邻居的属性的平均值赋给该样本，就可以获取该样本的属性。
更适用的方法是将不同样距离的邻居对该样本产生的影响恩赐不同样的权值 (weight) ，如权值与距离成正比。
该算法在分类时有个主要的缺乏是，当样本不平衡时，如一个类的样本容量很大，而其他类样本容量很小时，有可能以致当输入一个新样本时，该样本的 K个邻居中大容量类的样本占多数。
该算法只计算“近来的〞邻居样本，某一类的样本数量很大，那么也许这类样本其实不凑近目标样本，也许这类样本很凑近目标样本。
无论怎样，数量其实不能够影响运行结果。
能够采用权值的方法〔和该样本距离小的邻居权值大〕来改良。
该方法的另一个缺乏之处是计算量较大，由于对每一个待分类的文本都要计算它到全体样本的距离，才能求得它的K个近来邻点。
目前常用的解决方法是早先对样本点进行剪辑，早先去除对分类作用不大的样本。
该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这类算法比较容易产生误分。
二试验步骤那么依照以上的描述，我把结合使用反余弦般配和 kNN 结合的过程分成以下几个步骤：1．计算出样本数据和待分类数据的距离2．为待分类数据选择 k 个与其距离最小的样本3．统计出 k 个样本中大多数样本所属的分类4．这个分类就是待分类数据所属的分类数学表达：目标函数值能够是失散值 (分类问题 )，也能够是连续值(回归问题).函数形势为 f:n 维空间 R—〉一维空间 R。
KNN算法实验报告11页
KNN算法实验报告11页KNN算法是一种非常简单但实用的机器学习算法，它非常适用于分类和回归问题。
本文主要介绍了KNN算法的原理以及在实际问题中的应用。
实验通过使用Python语言实现了KNN算法，并在多个数据集上进行了测试，证实了该算法的有效性。
1. KNN算法简介KNN算法（K-Nearest Neighbor）最初由Cover和Hart在1967年提出，是一种基于实例的分类算法，它的基本思想是通过比较不同样本之间距离的大小来实现分类或者回归。
在KNN算法中，距离的度量方式有很多种，最常见的是欧氏距离和曼哈顿距离。
在KNN算法中，K表示邻居的个数，对于一个待分类的样本，算法会找出与其距离最近的K个样本，并统计这K个样本中属于每个类别的数量，最终将待分类样本归为数量最多的那个类别。
如果K=1，则为最近邻算法。
2.1 Python代码实现本文使用Python语言实现KNN算法，实现过程如下：首先，需要定义距离度量方式。
本文采用欧氏距离：def distance(x1, x2):return np.sqrt(np.sum((x1 - x2) ** 2))然后，通过相似度计算函数对数据进行分类，代码如下：2.2 测试数据为了验证KNN算法的有效性，本文使用了三个不同的数据集，分别是Iris鸢尾花数据集、Wine酒数据集和Diabetes糖尿病数据集。
Iris鸢尾花数据集是常用的分类实验数据集，由Fisher于1936年收集整理，包含3种不同种类的鸢尾花，每种鸢尾花有4个不同的属性。
本文只考虑其中前两种鸢尾花，样本数量分别为50。
Wine酒数据集是一个常用的分类实验数据集，由UCI Machine Learning Repository 提供，包含13个不同的属性，涉及到葡萄品种、酒精、酸度等等。
本文只考虑其中前两个葡萄品种，样本数量分别为59和71。
Diabetes糖尿病数据集是美国国家糖尿病和肾脏疾病研究所提供的数据集，包括了一些糖尿病患者和非患者的生理指标数据，以及一个二元分类变量（是否患有糖尿病）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
KNN算法实验报告一试验原理K最近邻(k-NearestNeighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。
该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。
KNN算法中，所选择的邻居都是已经正确分类的对象。
该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
KNN方法虽然从原理上也依赖于极限定理，但在类别决策时，只与极少量的相邻样本有关。
由于KNN方法主要靠周围有限的邻近的样本，而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN方法较其他方法更为适合。
KNN算法不仅可以用于分类，还可以用于回归。
通过找出一个样本的k个最近邻居，将这些邻居的属性的平均值赋给该样本，就可以得到该样本的属性。
更有用的方法是将不同距离的邻居对该样本产生的影响给予不同的权值(weight)，如权值与距离成正比。
该算法在分类时有个主要的不足是，当样本不平衡时，如一个类的样本容量很大，而其他类样本容量很小时，有可能导致当输入一个新样本时，该样本的K个邻居中大容量类的样本占多数。
该算法只计算“最近的”邻居样本，某一类的样本数量很大，那么或者这类样本并不接近目标样本，或者这类样本很靠近目标样本。
无论怎样，数量并不能影响运行结果。
可以采用权值的方法（和该样本距离小的邻居权值大）来改进。
该方法的另一个不足之处是计算量较大，因为对每一个待分类的文本都要计算它到全体已知样本的距离，才能求得它的K个最近邻点。
目前常用的解决方法是事先对已知样本点进行剪辑，事先去除对分类作用不大的样本。
该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这种算法比较容易产生误分。
二试验步骤那么根据以上的描述，我把结合使用反余弦匹配和kNN结合的过程分成以下几个步骤：1．计算出样本数据和待分类数据的距离2．为待分类数据选择k个与其距离最小的样本3．统计出k个样本中大多数样本所属的分类4．这个分类就是待分类数据所属的分类数学表达：目标函数值可以是离散值(分类问题)，也可以是连续值(回归问题).函数形势为f:n维空间R—〉一维空间R。
第一步：将数据集分为训练集（DTrn）和测试集（DTES）。
第二步：在测试集给定一个实例Xq;在训练集（DTrn）中找到与这个实例Xq的K-最近邻子集{X1、、、、XK}，即：DKNN。
第三步：计算这K-最近邻子集得目标值，经过加权平均：^f(Xq)=(f(X1)+...+f(XK))/k作为f(Xq）的近似估计。
改进的地方：对kNN算法的一个明显的改进是对k个最近邻的贡献加权，将较大的权值赋给较近的近邻，相应的算法称为距离加权kNN回归算法，则公式1则修改为：^f(Xq)=(w1*f(X1)+...+wk*f(XK))/(w1+...wk)一般地距离权值wi和距离成反比关系，例如，wi近似=1/d(xq;xi).K值的选择：需要消除K值过低，预测目标容易产生变动性，同时高k值时，预测目标有过平滑现象。
推定k值的有益途径是通过有效参数的数目这个概念。
有效参数的数目是和k值相关的，大致等于n/k，其中，n 是这个训练数据集中实例的数目。
缺点：（1）在大训练集寻找最近邻的时间是难以忍受的。
（2）在训练数据集中要求的观测值的数目，随着维数p的增长以指数方式增长。
这是因为和最近邻的期望距离随着维数p的增多而急剧上升，除非训练数据集的大小随着p以指数方式增长。
这种现象被称为“维数灾难”。
解决办法有下面几个：（1）通过降维技术来减少维数，如主成分分析，因子分析，变量选择（因子选择）从而减少计算距离的时间；（2）用复杂的数据结构，如搜索树去加速最近邻的确定。
这个方法经常通过公式2公式1设定“几乎是最近邻”的目标去提高搜索速度；（3）编辑训练数据去减少在训练集中的冗余和几乎是冗余的点，从而加速搜索最近邻。
在个别例子中去掉在训练数据集中的一些观察点，对分类效果没有影响，原因是这些点被包围属于同类的观测点中。
三注意事项KNN算法的实现要注意：1．用TreeMap<String，TreeMap<String，Double>>保存测试集和训练集。
2．注意要以"类目_文件名"作为每个文件的key，才能避免同名不同内容的文件出现。
3．注意设置JM参数，否则会出现JA V Aheap溢出错误。
4．本程序用向量夹角余弦计算相似度。
四代码//KNN.javapackage cqu.KNN;import java.util.ArrayList;import parator;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.PriorityQueue;//KNN算法主体类public class KNN{/** * 设置优先级队列的比较函数，距离越大，优先级越高 */private Comparator<KNNNode> comparator = new Comparator<KNNNode>(){public int compare(KNNNode o1, KNNNode o2){if (o1.getDistance() >= o2.getDistance()){return -1;}else{return 1;}}};/** * 获取K个不同的随机数 * @param k 随机数的个数 * @param max 随机数最大的范围 * @return 生成的随机数数组 */public List<Integer> getRandKNum(int k, int max){List<Integer> rand = new ArrayList<Integer>(k);for (int i = 0; i < k; i++){int temp = (int) (Math.random() * max);if (!rand.contains(temp)){rand.add(temp);}else{i--;}}return rand;}/** * 计算测试元组与训练元组之前的距离 * @param d1 测试元组* @param d2 训练元组 * @return 距离值 */public double calDistance(List<Double> d1, List<Double> d2){double distance = 0.00;for (int i = 0; i < d1.size(); i++){distance += (d1.get(i) - d2.get(i)) * (d1.get(i) - d2.get(i));}return distance;}/** * 执行KNN算法，获取测试元组的类别 * @param datas 训练数据集 * @paramtestData 测试元组 * @param k 设定的K值 * @return 测试元组的类别 */public String knn(List<List<Double>> datas, List<Double> testData, int k){PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k,comparator);List<Integer> randNum = getRandKNum(k, datas.size());for (int i = 0; i < k; i++){int index = randNum.get(i);List<Double> currData = datas.get(index);String c = currData.get(currData.size()-1).toString();KNNNode node = new KNNNode(index, calDistance(testData, currData), c); pq.add(node);}for (int i = 0; i < datas.size(); i++){List<Double> t = datas.get(i);double distance = calDistance(testData, t);KNNNode top = pq.peek();if (top.getDistance() > distance){pq.remove();pq.add(new KNNNode(i, distance, t.get(t.size()-1).toString()));}}return getMostClass(pq);}/** * 获取所得到的k个最近邻元组的多数类 * @param pq 存储k个最近近邻元组的优先级队列* @return 多数类的名称 */private String getMostClass(PriorityQueue<KNNNode> pq){Map<String, Integer> classCount = new HashMap<String, Integer>();int pqsize = pq.size();for (int i = 0; i < pqsize; i++){KNNNode node = pq.remove();String c = node.getC();if (classCount.containsKey(c)){classCount.put(c, classCount.get(c) + 1);}else{classCount.put(c, 1);}}int maxIndex = -1;int maxCount = 0;Object[] classes = classCount.keySet().toArray();for (int i = 0; i < classes.length; i++){if (classCount.get(classes[i]) > maxCount){maxIndex = i; maxCount = classCount.get(classes[i]); }}return classes[maxIndex].toString();}}//KNNNode.javapackage cqu.KNN;public class KNNNode{private int index; // 元组标号private double distance; // 与测试元组的距离private String c; // 所属类别public KNNNode(int index, double distance, String c){super();this.index = index;this.distance = distance; this.c = c;}public int getIndex(){return index;}public void setIndex(int index){this.index = index;}public double getDistance(){return distance;}public void setDistance(double distance){this.distance = distance;}public String getC(){return c;}public void setC(String c){this.c = c;}}//TestKNN.javapackage cqu.KNN;import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.util.ArrayList;import java.util.List;// KNN算法测试类public class TestKNN{/** * 从数据文件中读取数据 * @param datas 存储数据的集合对象 * @param path 数据文件的路径 */public void read(List<List<Double>> datas, String path){try {BufferedReader br = new BufferedReader(new FileReader(new File(path))); String reader = br.readLine();while (reader != null){String t[] = reader.split(" ");ArrayList<Double> list = new ArrayList<Double>();for (int i = 0; i < t.length; i++){list.add(Double.parseDouble(t[i]));}datas.add(list); reader = br.readLine();}}catch (Exception e){e.printStackTrace();}}/** * 程序执行入口 * @param args */public static void main(String[] args){TestKNN t = new TestKNN();String datafile = new File("").getAbsolutePath() + File.separator + "cqudata\\datafile.txt";String testfile = new File("").getAbsolutePath() + File.separator + "cqudata\\testfile.txt";try {List<List<Double>> datas = new ArrayList<List<Double>>();List<List<Double>> testDatas = new ArrayList<List<Double>>();t.read(datas, datafile);t.read(testDatas, testfile);KNN knn = new KNN();for (int i = 0; i < testDatas.size(); i++){List<Double> test = testDatas.get(i);System.out.print("测试元组: ");for (int j = 0; j < test.size(); j++){System.out.print(test.get(j) + " ");}System.out.print("类别为: ");System.out.println(Math.round(Float.parseFloat((knn.knn(datas, test, 3)))));}}catch (Exception e){e.printStackTrace();}}}五运行测试训练数据：1.0 1.1 1.22.1 0.3 2.3 1.4 0.5 11.7 1.2 1.42.0 0.2 2.5 1.2 0.8 11.2 1.8 1.62.5 0.1 2.2 1.8 0.2 11.92.1 6.2 1.1 0.93.3 2.4 5.5 01.0 0.8 1.62.1 0.2 2.3 1.6 0.5 11.62.1 5.2 1.1 0.83.6 2.44.5 0实验数据：1.0 1.1 1.22.1 0.3 2.3 1.4 0.51.7 1.2 1.42.0 0.2 2.5 1.2 0.81.2 1.8 1.62.5 0.1 2.2 1.8 0.21.92.1 6.2 1.1 0.93.3 2.4 5.51.0 0.8 1.62.1 0.2 2.3 1.6 0.51.62.1 5.2 1.1 0.83.6 2.44.5程序运行结果：测试元组: 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 类别为: 1 测试元组: 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 类别为: 1 测试元组: 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 类别为: 1 测试元组: 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 类别为: 0 测试元组: 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 类别为: 1 测试元组: 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 类别为: 0。