1.实验题目： 编程实现P274页的最邻近法（可视化，并给出算法执行过程）。
2．源程序：
package com.knn;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
首都医科大学学报import java.util.Comparator;
import java.util.Map;
import java.util.PriorityQueue;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableModel;
//KNN结点类，用来存储最近邻的k个元组相关的信息 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;
}
}
非线性薛定谔方程//KNN算法主体类
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 (!ains(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 训练数据集
* @param testData 测试元组
* @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 = (i);
List<Double> currData = (index);
String c = (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 = (i);
double distance = calDistance(testData, t);
KNNNode top = pq.peek();
if (Distance() > 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 = C();
if (ainsKey(c))
{
classCount.put(c, (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 ((classes[i]) > maxCount)
{
maxIndex = i;
maxCount = (classes[i]);
}
}
return classes[maxIndex].toString();
}
}
class KNNFrame
{
private JFrame frame1=new JFrame("KNN最邻近算法");
private JLabel label1=new JLabel("为了方便显示算法可视化，请按照如下步骤操作完成！");
private JLabel label2=new JLabel("第一步：请在表格中输入训练数据。");
private JLabel label3=new JLabel("第二步：请在表格中输入测试元组数据。");
private JLabel label4=new JLabel("最后一步：显示比较训练元组和测试元组的相似度
类别。");
private JButton button1=new JButton("现在去输入");
private JButton button2=new JButton("现在去输入");
private JButton button3=new JButton("立刻显示");
//错误窗口。
private JFrame frame5=new JFrame("错误窗口！");
private JLabel label5=new JLabel();
豫公网安备41160202000603
站长QQ:729038198
关于我们
投诉建议