优雅解读 层次聚类

// 常用距离计算示例
double singleLinkage(double[] a, double[] b) {
    double min = Double.MAX_VALUE;
    for (int i : a) for (int j : b) 
        min = Math.min(min, euclideanDistance(i, j));
    return min;
}

import java.util.*;

class Cluster {
    int id;
    List<Double[]> points = new ArrayList<>();
    
    public Cluster(Double[] point) { 
        points.add(point); 
    }
}

public class HierarchicalClustering {
    public static void main(String[] args) {
        // 样本数据初始化
        List<Cluster> clusters = new ArrayList<>();
        clusters.add(new Cluster(new Double[]{1.0, 2.0}));
        clusters.add(new Cluster(new Double[]{5.0, 6.0}));
        clusters.add(new Cluster(new Double[]{1.5, 2.5}));

        // 凝聚式聚类过程
        while (clusters.size() > 1) {
            double minDist = Double.MAX_VALUE;
            int[] mergePair = new int[2];
            
            // 查找最近簇对
            for (int i=0; i<clusters.size(); i++) {
                for (int j=i+1; j<clusters.size(); j++) {
                    double dist = singleLinkage(clusters.get(i), clusters.get(j));
                    if (dist < minDist) {
                        minDist = dist;
                        mergePair = new int[]{i, j};
                    }
                }
            }
            
            // 合并簇
            Cluster merged = new Cluster();
            merged.points.addAll(clusters.get(mergePair[0]).points);
            merged.points.addAll(clusters.get(mergePair[1]).points);
            clusters.remove(mergePair[1]);
            clusters.remove(mergePair[0]);
            clusters.add(merged);
            
            System.out.println("合并后簇数: " + clusters.size());
        }
    }
    
    // 单链接距离计算
    static double singleLinkage(Cluster a, Cluster b) {
        double min = Double.MAX_VALUE;
        for (Double[] p1 : a.points) 
            for (Double[] p2 : b.points) 
                min = Math.min(min, euclidean(p1, p2));
        return min;
    }
    
    static double euclidean(Double[] a, Double[] b) {
        return Math.sqrt(Math.pow(a[0]-b[0],2) + Math.pow(a[1]-b[1],2));
    }
}

// 内存优化：稀疏矩阵存储
Map<String, Double> distanceCache = new HashMap<>();

// 计算加速：并行化距离计算
clusters.parallelStream().forEach(cluster -> {
    // 并行处理逻辑
});