java实现K-mediods算法

以下是Java实现K-medoids算法的步骤：

// 定义一个类来表示数据点
class DataPoint {
    double x;
    double y;
    // 构造函数
    public DataPoint(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

// 定义一个类来表示簇
class Cluster {
    DataPoint medoid;
    List<DataPoint> dataPoints;
    // 构造函数
    public Cluster(DataPoint medoid) {
        this.medoid = medoid;
        this.dataPoints = new ArrayList<>();
    }
    // 计算簇中所有数据点到medoid的距离之和
    public double getDistanceSum() {
        double sum = 0;
        for (DataPoint dataPoint : dataPoints) {
            sum += getDistance(dataPoint, medoid);
        }
        return sum;
    }
}

// 计算两个数据点之间的欧几里得距离
public static double getDistance(DataPoint dataPoint1, DataPoint dataPoint2) {
    double dx = dataPoint1.x - dataPoint2.x;
    double dy = dataPoint1.y - dataPoint2.y;
    return Math.sqrt(dx * dx + dy * dy);
}

// K-medoids算法
public static List<Cluster> kMedoids(List<DataPoint> dataPoints, int k) {
    // 随机选择k个medoid
    List<DataPoint> medoids = new ArrayList<>();
    for (int i = 0; i < k; i++) {
        medoids.add(dataPoints.get((int) (Math.random() * dataPoints.size())));
    }
    // 初始化簇
    List<Cluster> clusters = new ArrayList<>();
    for (DataPoint medoid : medoids) {
        clusters.add(new Cluster(medoid));
    }
    // 迭代
    boolean changed = true;    while (changed) {
        changed = false;
        // 将每个数据点分配到最近的簇中
        for (DataPoint dataPoint : dataPoints) {
            Cluster nearestCluster = null;
            double nearestDistance = Double.MAX_VALUE;
            for (Cluster cluster : clusters) {
                double distance = getDistance(dataPoint, cluster.medoid);
                if (distance < nearestDistance) {
                    nearestCluster = cluster;
                    nearestDistance = distance;
                }
            }
            nearestCluster.dataPoints.add(dataPoint);
        }
        // 重新计算每个簇的medoid
        for (Cluster cluster : clusters) {
            DataPoint nearestMedoid = null;
            double nearestDistanceSum = Double.MAX_VALUE;
            for (DataPoint dataPoint : cluster.dataPoints) {
                double distanceSum = 0;
                for (DataPoint otherDataPoint : cluster.dataPoints) {
                    distanceSum += getDistance(dataPoint, otherDataPoint);
                }
                if (distanceSum < nearestDistanceSum) {
                    nearestMedoid = dataPoint;
                    nearestDistanceSum = distanceSum;
                }
            }
            if (!nearestMedoid.equals(cluster.medoid)) {
                cluster.medoid = nearestMedoid;
                changed = true;
            }
            cluster.dataPoints.clear();
        }
    }
    return clusters;
}