【开源分享】一个纯 C++ 实现的 K-Means 聚类工具：轻量、可读、适合学习

Jimmy

分享一个纯 C++ 实现的 K-Means 聚类程序。它不依赖第三方库，结构完整、逻辑清晰，编译后就能直接跑，适合拿来学习 C++ 算法实现，也可以作为后续扩展的基础模板。
它是什么
这个程序实现的是经典的 K-Means 聚类算法，主要用来把一组二维数据点自动划分成若干个簇。
简单来说，它可以完成这些工作：
●       从文本文件中加载二维数据；
●       随机初始化聚类中心；
●       反复把数据点分配到最近的聚类中心；
●       更新每个簇的中心位置；
●       根据惯性变化判断是否收敛；
●       把最终聚类结果保存到输出文件中。
它比较适合用来学习 C++ 文件读写、算法流程、工程结构，也适合做课程练习、算法实验，或者在此基础上继续加可视化、多线程、参数解析等功能。
适合什么人
●       想练习 C++ 基础算法实现的人；
●       想了解 K-Means 聚类流程的人；
●       想做一个可以编译运行的 C++ 小项目的人；
●       想在此基础上继续扩展功能的人。
使用方法
1. 准备数据文件
程序默认读取当前目录下的 data.txt。
文件格式很简单：每行两个数字，用空格分开，分别表示一个点的 x 和 y 坐标。
例如：
2.1 2.3
7.8 8.1
5.0 1.2
不需要表头，也不需要逗号分隔，只要每行两个浮点数即可。
2. 编译程序
使用支持 C++11 及以上的编译器即可。
编译命令示例：
g++ -o kmeans kmeans.cpp -std=c++11
如果你使用的是其他编译器，只要支持 C++11 标准，一般也可以正常编译。
3. 运行程序
编译完成后，直接运行生成的可执行文件：
./kmeans
程序运行后会输出当前迭代信息，包括迭代次数和惯性值。惯性值越小，说明数据点离各自簇中心的距离总和越小，聚类效果通常越稳定。
4. 查看结果
运行结束后，程序会生成一个 result.txt 文件。
输出文件每行包含三个值：
x y cluster_id
其中：
●       x：数据点的横坐标；
●       y：数据点的纵坐标；
●       cluster_id：该点所属的簇编号，从 0 开始。
你可以用这个结果文件做后续分析、绘图，或者导入到其他工具里查看聚类分布。
默认参数说明
程序内置了几个默认参数：
●       输入文件：data.txt
●       输出文件：result.txt
●       聚类数量：3
●       最大迭代次数：100
●       收敛阈值：0.0001
如果想修改这些参数，可以直接在源码中调整对应变量，也可以后续自己扩展成命令行参数形式。
注意事项
●       数据文件必须存在，且至少包含两列有效数字；
●       聚类数量不能超过数据点数量；
●       由于初始中心是随机选择的，多次运行结果可能略有差异；
●       如果数据分布本身不适合 K-Means，聚类效果可能不理想；
●       当前版本只支持二维数据，如需更高维度可以继续扩展。
后续可以怎么玩
这个版本适合作为基础模板。后面可以继续扩展：
●       支持命令行参数；
●       支持多维数据；
●       加入肘部法则自动选择 K 值；
●       支持 CSV 文件读取；
●       输出可视化数据；
●       加入多线程加速；
●       封装成更完整的 C++ 小库。
如果大家对这类 C++ 算法小项目感兴趣，后面可以继续分享更多版本。
代码：

1. // kmeans.cpp
   
2. #include <iostream>
   
3. #include <fstream>
   
4. #include <sstream>
   
5. #include <vector>
   
6. #include <cmath>
   
7. #include <random>
   
8. #include <algorithm>
   
9. #include <limits>
   
10. #include <iomanip>
    
11. 
    
12. struct Point {
    
13.     double x, y;
    
14.     int cluster;
    
15.     Point(double x = 0, double y = 0) : x(x), y(y), cluster(-1) {}
    
16. };
    
17. 
    
18. double euclidean_distance(const Point& a, const Point& b) {
    
19.     return std::sqrt((a.x - b.x) * (a.x - b.x) +
    
20.                      (a.y - b.y) * (a.y - b.y));
    
21. }
    
22. 
    
23. std::vector<Point> load_data(const std::string& filename) {
    
24.     std::vector<Point> data;
    
25.     std::ifstream file(filename);
    
26.     if (!file.is_open()) {
    
27.         std::cerr << "无法打开文件: " << filename << std::endl;
    
28.         return data;
    
29.     }
    
30.     std::string line;
    
31.     while (std::getline(file, line)) {
    
32.         std::istringstream iss(line);
    
33.         double x, y;
    
34.         if (iss >> x >> y) {
    
35.             data.emplace_back(x, y);
    
36.         }
    
37.     }
    
38.     return data;
    
39. }
    
40. 
    
41. std::vector<Point> initialize_centroids(const std::vector<Point>& data, int k) {
    
42.     std::vector<Point> centroids;
    
43.     std::random_device rd;
    
44.     std::mt19937 gen(rd());
    
45.     std::uniform_int_distribution<size_t> dist(0, data.size() - 1);
    
46. 
    
47.     for (int i = 0; i < k; ++i) {
    
48.         centroids.push_back(data[dist(gen)]);
    
49.     }
    
50.     return centroids;
    
51. }
    
52. 
    
53. void assign_clusters(std::vector<Point>& data, const std::vector<Point>& centroids) {
    
54.     for (auto& point : data) {
    
55.         double min_dist = std::numeric_limits<double>::max();
    
56.         int best_cluster = 0;
    
57.         for (size_t i = 0; i < centroids.size(); ++i) {
    
58.             double dist = euclidean_distance(point, centroids[i]);
    
59.             if (dist < min_dist) {
    
60.                 min_dist = dist;
    
61.                 best_cluster = static_cast<int>(i);
    
62.             }
    
63.         }
    
64.         point.cluster = best_cluster;
    
65.     }
    
66. }
    
67. 
    
68. std::vector<Point> update_centroids(const std::vector<Point>& data, int k) {
    
69.     std::vector<Point> new_centroids(k);
    
70.     std::vector<int> counts(k, 0);
    
71. 
    
72.     for (const auto& point : data) {
    
73.         new_centroids[point.cluster].x += point.x;
    
74.         new_centroids[point.cluster].y += point.y;
    
75.         counts[point.cluster]++;
    
76.     }
    
77. 
    
78.     for (int i = 0; i < k; ++i) {
    
79.         if (counts[i] > 0) {
    
80.             new_centroids[i].x /= counts[i];
    
81.             new_centroids[i].y /= counts[i];
    
82.         }
    
83.     }
    
84.     return new_centroids;
    
85. }
    
86. 
    
87. double compute_inertia(const std::vector<Point>& data, const std::vector<Point>& centroids) {
    
88.     double inertia = 0.0;
    
89.     for (const auto& point : data) {
    
90.         inertia += euclidean_distance(point, centroids[point.cluster]);
    
91.     }
    
92.     return inertia;
    
93. }
    
94. 
    
95. void kmeans(std::vector<Point>& data, int k, int max_iters, double tolerance) {
    
96.     auto centroids = initialize_centroids(data, k);
    
97.     double prev_inertia = std::numeric_limits<double>::max();
    
98. 
    
99.     for (int iter = 0; iter < max_iters; ++iter) {
    
100.         assign_clusters(data, centroids);
     
101.         auto new_centroids = update_centroids(data, k);
     
102.         double inertia = compute_inertia(data, new_centroids);
     
103. 
     
104.         std::cout << "迭代 " << iter + 1
     
105.                   << " | 惯性: " << std::fixed << std::setprecision(4) << inertia << std::endl;
     
106. 
     
107.         if (std::abs(prev_inertia - inertia) < tolerance) {
     
108.             std::cout << "收敛于迭代 " << iter + 1 << std::endl;
     
109.             break;
     
110.         }
     
111. 
     
112.         centroids = new_centroids;
     
113.         prev_inertia = inertia;
     
114.     }
     
115. }
     
116. 
     
117. void save_results(const std::vector<Point>& data, const std::string& filename) {
     
118.     std::ofstream file(filename);
     
119.     for (const auto& point : data) {
     
120.         file << point.x << " " << point.y << " " << point.cluster << std::endl;
     
121.     }
     
122. }
     
123. 
     
124. int main() {
     
125.     std::string input_file = "data.txt";
     
126.     std::string output_file = "result.txt";
     
127.     int k = 3;
     
128.     int max_iters = 100;
     
129.     double tolerance = 1e-4;
     
130. 
     
131.     auto data = load_data(input_file);
     
132.     if (data.empty()) {
     
133.         std::cerr << "数据为空" << std::endl;
     
134.         return 1;
     
135.     }
     
136. 
     
137.     std::cout << "加载了 " << data.size() << " 个数据点" << std::endl;
     
138.     kmeans(data, k, max_iters, tolerance);
     
139.     save_results(data, output_file);
     
140.     std::cout << "结果已保存到 " << output_file << std::endl;
     
141. 
     
142.     return 0;
     
143. }

复制代码