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算法，以及如何構建聚類樹結構。你可以根據自己的需求對這些代碼進行修改和優化。