数据挖掘原理与算法 DBSCAN

用C实现DBSCAN，完全就是暴力模拟，用三个向量存储核心点、噪声点、边界点，先标记核心点，之后先对核心点进行聚类，将在规定范围内的核心点放入一个向量，这时得到的聚类是包含重复的，再将这个暂时得到的核心点聚类进行合并，这时得到的是核心点的分类，且这个分类包含了间接密度可达的核心点，下一步只需要将边界点加到核心点的分类中就可以。过程暴力，时间复杂度怕是要暴。

#include <bits/stdc++.h>
using namespace std;
/*
12 1 4
1 0
4 0
0 1
1 1
2 1
3 1
4 1
5 1
0 2
1 2
4 2
1 3
*/
int Eps; //邻域半径值
int MinPts; //邻域密度阈值
int N;//点个数 

int len[1005];//暂存簇中核心点的个数 
int point[1005][2]; // 保存所有的数据点

vector<int> kernel_point; // 核心点
vector<int> border_point; // 边界点
vector<int> noise_point; // 噪声点

vector<vector<int> > mid; // 可能存在重叠的簇
vector<vector<int> > cluster; // 最终形成的簇

int main() 
{
	scanf("%d %d %d",&N,&Eps,&MinPts);
	for(int i=0;i<N;i++)
		scanf("%d %d",&point[i][0],&point[i][1]);
		
	// 标记核心点
	for(int i=0; i<N; i++) {
		int num = 0;
		for(int j=0; j<N; j++)
			if(pow(point[i][0]-point[j][0],2)+pow(point[i][1]-point[j][1],2)<=pow(Eps,2)) 
				num++;
		if(num>=MinPts)
			kernel_point.push_back(i);
	}

	for(int i=0; i<N; i++) {
		// 边界点或噪声点不能是核心点
		int flag=0;
		for(int j=0; j<kernel_point.size();j++) {
			if(i==kernel_point[j]) {
				flag=1;
				break;
			}	
		}	
		if(flag==0){
			int flag2=1;
			for(int j=0;j<kernel_point.size();j++) {
				int s=kernel_point[j];
				//在任何一个核心点范围内的为边缘点，不在为噪声点 
				if(pow(point[i][0]-point[s][0],2)+pow(point[i][1]-point[s][1],2)<=pow(Eps,2)) {
					flag2=0;
					border_point.push_back(i);
					break;
				}	
			}
			if(flag2==1)
				noise_point.push_back(i);
		}
	}

	// 将核心点进行聚类 得到可能会重叠的聚类 
	for(int i=0; i<kernel_point.size(); i++) {
		int x = kernel_point[i];
		vector<int> record;
		record.push_back(x);
		for(int j=i+1; j<kernel_point.size(); j++) {
			int y=kernel_point[j];
			if(pow(point[x][0]-point[y][0],2)-pow(point[x][1]-point[y][1], 2)<pow(Eps, 2))
				record.push_back(y);
		}
		mid.push_back(record);
	}

	//将重复的核心点聚类合并 ，即实现了间接密度可达中核心点的跳跃 
	for(int i=0; i<mid.size(); i++) {
		if(mid[i][0] == -1)
			continue;
		//如果核心点范围内没有其他核心点就不进行合并 
		for(int j=0; j<mid[i].size(); j++) { 
			for(int x=i+1; x<mid.size(); x++) {
				if(mid[x][0]==-1) 
					continue;
				//如果核心点范围内没有其他核心点就不进行合并 
				for(int y=0;y<mid[x].size();y++) {
					if(mid[i][j]==mid[x][y]) {
						// 如果有一样的元素，应该放入一个核心点范围中
						for(int a=0; a<mid[x].size(); a++) {
							mid[i].push_back(mid[x][a]);
							mid[x][a] = -1;
						}
						break;
					}
				}
			}
		}
		cluster.push_back(mid[i]);
		//cluster目前保存的是核心点的分组 
	}

	// 删除cluster中的重复元素
	for(int i=0; i<cluster.size(); i++) {
		for(int j=0; j<cluster[i].size(); j++) {
			for(int k=j+1; k<cluster[i].size(); k++) {
				if(cluster[i][j] == cluster[i][k]) {
					cluster[i].erase(cluster[i].begin()+k);
					k--;
				}
			}
		}
	}

	//分配边界点 
	for(int i=0;i<cluster.size();i++)
		len[i]=cluster[i].size();
	
	for(int i=0; i<border_point.size(); i++) { 
		int x = border_point[i];
		for(int j=0; j<cluster.size(); j++) { 
			int flag=0;
			for(int k=0;k<len[j];k++) {
				int y = cluster[j][k];
				if(pow(point[x][0]-point[y][0],2)+pow(point[x][1]-point[y][1], 2)<=pow(Eps,2)) {
					cluster[j].push_back(x);
					flag=1;
					break;
				}
			}
			if(flag==1)
				break;
		}
	}

	//输出结果 
	cout<<"Kernel Points : "<<endl;
	for(int i=0; i<kernel_point.size(); i++) 
		cout<<kernel_point[i]+1<<"\t";
	cout<<endl<<endl;
	
	cout<<"Border Points : "<<endl;
	for(int i=0; i<border_point.size(); i++)
		cout<<border_point[i]+1<<"\t";
	cout<<endl<<endl;
	
	cout<<"Noise Points : "<<endl;
	for(int i=0; i<noise_point.size(); i++)
		cout<<noise_point[i]+1<<"\t";
	cout<<endl<<endl;
	
	cout<<"Cluster : "<<endl;
	for(int i=0; i<cluster.size(); i++) {
		cout<<"第"<<i+1<<"个"<<"\t";
		int temp=cluster[i].size();
		sort(cluster[i].begin(),cluster[i].end()) ;
		for(int j=0; j<cluster[i].size(); j++)
			cout<<cluster[i][j]+1<<"\t";
		cout<<endl;
	}
	
	return 0;
}