C++聚类算法与聚类树结构的构建

在C++中实现聚类算法和构建聚类树结构需要一些数学和算法知识。这里，我们将简要介绍K-means聚类算法和基于密度的DBSCAN算法，以及如何构建聚类树结构。

1. K-means聚类算法：

K-means是一种迭代优化算法，用于将数据集划分为K个簇。其基本思想是最小化每个簇内数据点与其质心之间的距离之和。以下是K-means算法的C++实现：

#include <iostream>
#include <vector>
#include <cmath>
#include <random>

using namespace std;

vector<vector<double>> kMeans(const vector<vector<double>>& data, int k, int maxIter = 100) {
    int n = data.size();
    vector<vector<double>> centroids(k, vector<double>(data[0].size(), 0));
    vector<int> labels(n, -1);

    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(0, k - 1);

    for (int iter = 0; iter < maxIter; ++iter) {
        vector<vector<double>> newCentroids(k, vector<double>(data[0].size(), 0));

        for (int i = 0; i < n; ++i) {
            int label = dis(gen);
            labels[i] = label;
            for (int j = 0; j < data[0].size(); ++j) {
                newCentroids[label][j] += data[i][j];
            }
        }

        for (int i = 0; i < k; ++i) {
            double sum = 0;
            for (int j = 0; j < data[0].size(); ++j) {
                sum += newCentroids[i][j];
            }
            for (int j = 0; j < data[0].size(); ++j) {
                newCentroids[i][j] /= sum;
            }
        }

        bool converged = true;
        for (int i = 0; i < k; ++i) {
            for (int j = 0; j < data[0].size(); ++j) {
                if (abs(newCentroids[i][j] - centroids[i][j]) > 1e-6) {
                    converged = false;
                    break;
                }
            }
            if (!converged) break;
        }

        if (converged) break;

        centroids = newCentroids;
    }

    return centroids;
}

2. DBSCAN聚类算法：

DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的聚类算法。它可以将具有足够高密度的区域划分为簇，并将稀疏区域的噪声点排除在外。以下是DBSCAN算法的C++实现：

#include <iostream>
#include <vector>
#include <cmath>
#include <queue>
#include <unordered_set>

using namespace std;

vector<vector<int>> dbscan(const vector<vector<double>>& data, double eps, int minPts) {
    int n = data.size();
    vector<vector<int>> labels(n, -1);
    queue<int> q;
    unordered_set<int> visited;

    for (int i = 0; i < n; ++i) {
        if (visited.find(i) != visited.end()) continue;
        q.push(i);
        visited.insert(i);

        int numNeighbors = 0;
        vector<int> neighbors(minPts);
        while (!q.empty()) {
            int point = q.front();
            q.pop();

            for (int j = 0; j < data[0].size(); ++j) {
                int neighbor = -1;
                for (int k = 0; k < minPts; ++k) {
                    if (abs(data[point][j] - data[neighbors[k]][j]) < eps) {
                        neighbor = neighbors[k];
                        break;
                    }
                }

                if (neighbor == -1) {
                    neighbors[numNeighbors++] = point;
                    q.push(point);
                    visited.insert(point);
                } else if (labels[neighbor] == -1) {
                    labels[neighbor] = labels[point];
                    q.push(neighbor);
                    visited.insert(neighbor);
                }
            }
        }
    }

    return labels;
}

3. 聚类树结构构建：

聚类树（Cluster Tree）是一种用于表示数据集层次聚类结构的树形数据结构。这里我们使用著名的Agglomerative Clustering算法来构建聚类树。以下是Agglomerative Clustering算法的C++实现：

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

vector<int> agglomerativeClustering(const vector<vector<double>>& data, int minPts, double eps) {
    int n = data.size();
    vector<int> labels(n, -1);
    vector<vector<int>> clusters(n);

    for (int i = 0; i < n; ++i) {
        clusters[i].push_back(i);
    }

    while (clusters.size() > 1) {
        int minDist = INT_MAX;
        int minIndex = -1;
        for (size_t i = 0; i < clusters.size() - 1; ++i) {
            for (size_t j = i + 1; j < clusters.size(); ++j) {
                double dist = calculateDistance(clusters[i], clusters[j], data);
                if (dist < minDist) {
                    minDist = dist;
                    minIndex = i;
                }
            }
        }

        int mergedCluster = clusters[minIndex];
        clusters.erase(clusters.begin() + minIndex);

        clusters.push_back(mergeClusters(mergedCluster, clusters[minIndex], data, eps));
    }

    return labels;
}

double calculateDistance(const vector<int>& cluster1, const vector<int>& cluster2, const vector<vector<double>>& data) {
    double distance = 0;
    for (int point : cluster1) {
        for (int point2 : cluster2) {
            distance += pow(data[point][0] - data[point2][0], 2) + pow(data[point][1] - data[point2][1], 2);
        }
    }
    return sqrt(distance);
}

vector<int> mergeClusters(const vector<int>& cluster1, const vector<int>& cluster2, const vector<vector<double>>& data, double eps) {
    vector<int> mergedCluster;
    for (int point : cluster1) {
        mergedCluster.push_back(point);
    }
    for (int point : cluster2) {
        mergedCluster.push_back(point);
    }

    vector<vector<int>> distanceMatrix(mergedCluster.size(), vector<int>(mergedCluster.size(), -1));
    for (size_t i = 0; i < mergedCluster.size(); ++i) {
        for (size_t j = i + 1; j < mergedCluster.size(); ++j) {
            distanceMatrix[i][j] = calculateDistance({mergedCluster[i]}, {mergedCluster[j]}, data);
            distanceMatrix[j][i] = distanceMatrix[i][j];
        }
    }

    int maxDistIndex = 0;
    for (size_t i = 1; i < distanceMatrix.size(); ++i) {
        if (distanceMatrix[i][maxDistIndex] > distanceMatrix[maxDistIndex][i]) {
            maxDistIndex = i;
        }
    }

    for (size_t i = maxDistIndex + 1; i < distanceMatrix.size(); ++i) {
        double dist = distanceMatrix[maxDistIndex][i];
        for (size_t j = i + 1; j < distanceMatrix.size(); ++j) {
            if (distanceMatrix[i][j] > dist) {
                dist = distanceMatrix[i][j];
            }
        }

        if (dist < eps) {
            distanceMatrix[maxDistIndex][i] = 0;
            distanceMatrix[i][maxDistIndex] = 0;
            for (size_t k = 0; k < mergedCluster.size(); ++k) {
                distanceMatrix[maxDistIndex][k] = 0;
                distanceMatrix[k][maxDistIndex] = 0;
            }
        }
    }

    return mergedCluster;
}

这些代码片段展示了如何在C++中实现K-means聚类算法、DBSCAN聚类算法和Agglomerative Clustering算法，以及如何构建聚类树结构。你可以根据自己的需求对这些代码进行修改和优化。