Java K-Means 聚类算法实现232

K-Means 聚类算法是一种无监督机器学习算法，用于将数据点分组到不同的簇中。它广泛用于数据挖掘、图像处理和自然语言处理等领域。本文将介绍如何在 Java 中实现 K-Means 聚类算法，并提供一个代码示例。

K-Means 算法

K-Means 算法是一个迭代算法，它以以下步骤工作：1. 初始化簇中心：随机选择 k 个数据点作为初始簇中心。
2. 分配数据点：将每个数据点分配到距离最近的簇中心。
3. 更新簇中心：重新计算每个簇中数据点的平均值，并将其作为新的簇中心。
4. 重复步骤 2-3：重复步骤 2 和 3，直到簇中心不再发生变化或达到最大迭代次数。

Java 实现

以下是在 Java 中实现 K-Means 算法的代码示例：```java
import .*;
public class KMeans {
private int k; // 簇数
private int maxIterations; // 最大迭代次数
private List dataPoints; // 数据点列表
private List clusters; // 簇列表
public KMeans(int k, int maxIterations) {
this.k = k;
= maxIterations;
= new ArrayList();
= new ArrayList();
}
public void addDataPoint(DataPoint dataPoint) {
(dataPoint);
}
public void run() {
// 初始化簇中心
initializeCentroids();
// 迭代聚类
for (int i = 0; i < maxIterations; i++) {
// 分配数据点
assignDataPointsToClusters();
// 更新簇中心
updateCentroids();
}
}
private void initializeCentroids() {
// 随机选择 k 个数据点作为初始簇中心
for (int i = 0; i < k; i++) {
int randomIndex = (int) (() * ());
(new Cluster((randomIndex)));
}
}
private void assignDataPointsToClusters() {
// 遍历所有数据点
for (DataPoint dataPoint : dataPoints) {
// 找到距离最近的簇中心
Cluster closestCluster = null;
double minDistance = Double.MAX_VALUE;
for (Cluster cluster : clusters) {
double distance = (());
if (distance < minDistance) {
minDistance = distance;
closestCluster = cluster;
}
}
// 将数据点分配到最近的簇中
(dataPoint);
}
}
private void updateCentroids() {
// 遍历所有簇
for (Cluster cluster : clusters) {
// 计算新簇中心
DataPoint newCentroid = ();
// 更新簇中心
(newCentroid);
}
}
public List getClusters() {
return clusters;
}
public static void main(String[] args) {
// 创建一个 K-Means 实例
KMeans kMeans = new KMeans(3, 100);
// 添加数据点
(new DataPoint(1, 2));
(new DataPoint(3, 4));
(new DataPoint(5, 6));
(new DataPoint(7, 8));
// 运行聚类
();
// 获取聚类结果
List clusters = ();
// 打印聚类结果
for (Cluster cluster : clusters) {
("簇：" + cluster);
}
}
}
class DataPoint {
private double x;
private double y;
public DataPoint(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getDistance(DataPoint other) {
return ((this.x - other.x, 2) + (this.y - other.y, 2));
}
@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
}
class Cluster {
private DataPoint centroid;
private List dataPoints;
public Cluster(DataPoint centroid) {
= centroid;
= new ArrayList();
}
public void addDataPoint(DataPoint dataPoint) {
(dataPoint);
}
public DataPoint getCentroid() {
return centroid;
}
public void setCentroid(DataPoint centroid) {
= centroid;
}
public List getDataPoints() {
return dataPoints;
}
public DataPoint getAverageDataPoint() {
double avgX = 0;
double avgY = 0;
for (DataPoint dataPoint : dataPoints) {
avgX += ();
avgY += ();
}
avgX /= ();
avgY /= ();
return new DataPoint(avgX, avgY);
}
@Override
public String toString() {
return "簇中心：" + centroid + ", 数据点：" + dataPoints;
}
}
```