C#，基于密度的噪声应用空间聚类算法（DBSCAN Algorithm）源代码

深度混淆2024-03-04 14:32

1 聚类算法

聚类分析或简单聚类基本上是一种无监督的学习方法，它将数据点划分为若干特定的批次或组，使得相同组中的数据点具有相似的属性，而不同组中的数据点在某种意义上具有不同的属性。它包括许多基于差分进化的不同方法。

E、 g.K-均值（点之间的距离）、亲和传播（图距离）、均值偏移（点之间的距离）、DBSCAN（最近点之间的距离）、高斯混合（到中心的马氏距离）、谱聚类（图距离）等。

基本上，所有聚类方法都使用相同的方法，即首先计算相似度，然后使用相似度将数据点聚类为组或批。在这里，我们将重点讨论基于密度的应用程序空间聚类和噪声（DBSCAN）聚类方法。

簇是数据空间中的密集区域，由点密度较低的区域隔开。DBSCAN算法基于"簇"和"噪声"这一直观概念。关键思想是，对于簇的每个点，给定半径的邻域必须至少包含最少数量的点。

2 DBSCAN

DBSCAN全称为**Density-based Spatial Clustering of Applications with Noise。**翻译中文即：基于密度的噪声应用空间聚类（DBSCAN）

基于密度的噪声应用空间聚类是一种基于密度的聚类技术。在基于密度的聚类中，数据按数据点高度集中的区域分组，数据点高度集中的区域被数据点高度集中的区域包围。基本上，该算法会找到数据点密集的地方，并调用这些集群。

DBSCAN是基于密度的聚类的基本算法。它可以从包含噪声和异常值的大量数据中发现不同形状和大小的聚类。DBSCAN集群最吸引人的特性是它对异常值的鲁棒性。该算法只需要两个参数，即minPoints和epsilon。对于一个区域，聚集在一起的最小点数（阈值）是minpoint，其中作为epsilon的是用于在任何点的邻域中定位点的距离度量。DBSCAN围绕每个数据点创建一个epsilon半径的圆，并将其分类为核心点、边界点和噪声。

3 源程序

using System;

using System.Data;

using System.Collections.Generic;

using System.Drawing;

namespace Legalsoft.Truffer.Algorithm

{

public class K_Means_DBSCAN_Algorithm

{

public List<Point> Cluster1 = new List<Point>();

public List<Point> Cluster2 = new List<Point>();

public List<Point> afterCluster1 = new List<Point>();

public List<Point> afterCluster2 = new List<Point>();

public void Caverage()

{

afterCluster1.Clear();

afterCluster2.Clear();

List<Point> Cluster = new List<Point>();

foreach (Point m1Point in Cluster1)

{

Cluster.Add(m1Point);

}

foreach (Point m2Point in Cluster2)

{

Cluster.Add(m2Point);

}

Point C1 = Cluster[0];

Point C2 = Cluster[1];

bool flag = true;

while (flag)

{

int N1 = 0;

int N2 = 0;

int C1x = 0;

int C2x = 0;

int C1y = 0;

int C2y = 0;

foreach (Point point in Cluster)

{

int s1 = Math.Abs(point.X - C1.X) + Math.Abs(point.Y - C1.Y);

int s2 = Math.Abs(point.X - C2.X) + Math.Abs(point.Y - C2.Y);

if (s1 < s2)

{

N1++;

C1x += point.X;

C1y += point.Y;

}

else

{

N2++;

C2x += point.X;

C2y += point.Y;

}

}

if (C1x / N1 == C1.X && C2.X == C2x / N2 && C1.Y == C1y / N1 && C2.Y == C2y / N2)

{

flag = false;

}

C1.X = C1x / N1;

C2.X = C2x / N2;

C1.Y = C1y / N1;

C2.Y = C2y / N2;

}

foreach (Point point in Cluster)

{

int s1 = Math.Abs(point.X - C1.X) + Math.Abs(point.Y - C1.Y);

int s2 = Math.Abs(point.X - C2.X) + Math.Abs(point.Y - C2.Y);

if (s1 < s2)

{

afterCluster1.Add(point);

}

else

{

afterCluster2.Add(point);

}

}

}

/// <summary>

/// K-Means-DBSCAN算法

/// </summary>

public void DBSCAN(int radius = 1, int MinPts = 12)

{

double pow = 2.0;

afterCluster1.Clear();

afterCluster2.Clear();

List<Point> Cluster = new List<Point>();

List<Point> temp1 = new List<Point>();

List<Point> temp2 = new List<Point>();

foreach (Point m1Point in Cluster1)

{

Cluster.Add(m1Point);

}

foreach (Point m2Point in Cluster2)

{

Cluster.Add(m2Point);

}

Point C1;

Point C2;

bool isC1Get = false;

bool isC2Get = false;

foreach (Point mm in Cluster)

{

if (isC1Get == false)

{

int count = 0;

temp1.Clear();

foreach (Point mm1 in Cluster)

{

double banjing = Math.Sqrt(Math.Pow(mm1.X - mm.X, pow) + Math.Pow(mm1.Y - mm.Y, pow));

if (banjing < radius)

{

count++;

temp1.Add(mm1);

}

}

if (count >= MinPts)

{

C1 = mm;

isC1Get = true;

foreach (Point mm2 in temp1)

{

foreach (Point mm3 in Cluster)

{

double banjing = Math.Sqrt(Math.Pow(mm3.X - mm2.X, pow) + Math.Pow(mm3.Y - mm2.Y, pow));

if (banjing < radius && (afterCluster1.Contains(mm3) == false))

{

afterCluster1.Add(mm3);

}

}

}

}

}

else if (isC2Get == false)

{

if (afterCluster1.Contains(mm) == false)

{

int count = 0;

temp2.Clear();

foreach (Point mm1 in Cluster)

{

double banjing = Math.Sqrt(Math.Pow(mm1.X - mm.X, pow) + Math.Pow(mm1.Y - mm.Y, pow));

if (banjing < radius)

{

count++;

temp2.Add(mm1);

}

}

if (count >= MinPts)

{

C2 = mm;

isC2Get = true;

foreach (Point mm2 in temp2)

{

foreach (Point mm3 in Cluster)

{

double banjing = Math.Sqrt(Math.Pow(mm3.X - mm2.X, pow) + Math.Pow(mm3.Y - mm2.Y, pow));

if (banjing < radius && (afterCluster1.Contains(mm3) == false) && afterCluster2.Contains(mm3) == false)

{

afterCluster2.Add(mm3);

}

}

}

}

}

else

{

continue;

}

}

else

{

break;

}

}

}

}

}

4 源代码

cs 复制代码 
using System;
using System.Data;
using System.Collections.Generic;
using System.Drawing;

namespace Legalsoft.Truffer.Algorithm
{
    public class K_Means_DBSCAN_Algorithm
    {
        public List<Point> Cluster1 = new List<Point>();
        public List<Point> Cluster2 = new List<Point>();

        public List<Point> afterCluster1 = new List<Point>();
        public List<Point> afterCluster2 = new List<Point>();

        public void Caverage()
        {
            afterCluster1.Clear();
            afterCluster2.Clear();

            List<Point> Cluster = new List<Point>();
            foreach (Point m1Point in Cluster1)
            {
                Cluster.Add(m1Point);
            }
            foreach (Point m2Point in Cluster2)
            {
                Cluster.Add(m2Point);
            }
            Point C1 = Cluster[0];
            Point C2 = Cluster[1];

            bool flag = true;
            while (flag)
            {
                int N1 = 0;
                int N2 = 0;
                int C1x = 0;
                int C2x = 0;
                int C1y = 0;
                int C2y = 0;
                foreach (Point point in Cluster)
                {
                    int s1 = Math.Abs(point.X - C1.X) + Math.Abs(point.Y - C1.Y);
                    int s2 = Math.Abs(point.X - C2.X) + Math.Abs(point.Y - C2.Y);
                    if (s1 < s2)
                    {
                        N1++;
                        C1x += point.X;
                        C1y += point.Y;
                    }
                    else
                    {
                        N2++;
                        C2x += point.X;
                        C2y += point.Y;
                    }
                }
                if (C1x / N1 == C1.X && C2.X == C2x / N2 && C1.Y == C1y / N1 && C2.Y == C2y / N2)
                {
                    flag = false;
                }
                C1.X = C1x / N1;
                C2.X = C2x / N2;
                C1.Y = C1y / N1;
                C2.Y = C2y / N2;
            }

            foreach (Point point in Cluster)
            {
                int s1 = Math.Abs(point.X - C1.X) + Math.Abs(point.Y - C1.Y);
                int s2 = Math.Abs(point.X - C2.X) + Math.Abs(point.Y - C2.Y);
                if (s1 < s2)
                {
                    afterCluster1.Add(point);
                }
                else
                {
                    afterCluster2.Add(point);
                }
            }
        }

        /// <summary>
        /// K-Means-DBSCAN算法
        /// </summary>
        public void DBSCAN(int radius = 1, int MinPts = 12)
        {
            double pow = 2.0;
            afterCluster1.Clear();
            afterCluster2.Clear();
            List<Point> Cluster = new List<Point>();
            List<Point> temp1 = new List<Point>();
            List<Point> temp2 = new List<Point>();

            foreach (Point m1Point in Cluster1)
            {
                Cluster.Add(m1Point);
            }
            foreach (Point m2Point in Cluster2)
            {
                Cluster.Add(m2Point);
            }
            Point C1;
            Point C2;

            bool isC1Get = false;
            bool isC2Get = false;
            foreach (Point mm in Cluster)
            {
                if (isC1Get == false)
                {
                    int count = 0;
                    temp1.Clear();
                    foreach (Point mm1 in Cluster)
                    {
                        double banjing = Math.Sqrt(Math.Pow(mm1.X - mm.X, pow) + Math.Pow(mm1.Y - mm.Y, pow));
                        if (banjing < radius)
                        {
                            count++;
                            temp1.Add(mm1);
                        }
                    }
                    if (count >= MinPts)
                    {
                        C1 = mm;
                        isC1Get = true;
                        foreach (Point mm2 in temp1)
                        {
                            foreach (Point mm3 in Cluster)
                            {
                                double banjing = Math.Sqrt(Math.Pow(mm3.X - mm2.X, pow) + Math.Pow(mm3.Y - mm2.Y, pow));
                                if (banjing < radius && (afterCluster1.Contains(mm3) == false))
                                {
                                    afterCluster1.Add(mm3);
                                }
                            }
                        }
                    }
                }
                else if (isC2Get == false)
                {
                    if (afterCluster1.Contains(mm) == false)
                    {
                        int count = 0;
                        temp2.Clear();
                        foreach (Point mm1 in Cluster)
                        {
                            double banjing = Math.Sqrt(Math.Pow(mm1.X - mm.X, pow) + Math.Pow(mm1.Y - mm.Y, pow));
                            if (banjing < radius)
                            {
                                count++;
                                temp2.Add(mm1);
                            }
                        }
                        if (count >= MinPts)
                        {
                            C2 = mm;
                            isC2Get = true;
                            foreach (Point mm2 in temp2)
                            {
                                foreach (Point mm3 in Cluster)
                                {
                                    double banjing = Math.Sqrt(Math.Pow(mm3.X - mm2.X, pow) + Math.Pow(mm3.Y - mm2.Y, pow));
                                    if (banjing < radius && (afterCluster1.Contains(mm3) == false) && afterCluster2.Contains(mm3) == false)
                                    {
                                        afterCluster2.Add(mm3);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }
}
相关推荐
_.Switch16 分钟前
Python机器学习模型的部署与维护：版本管理、监控与更新策略
开发语言·人工智能·python·算法·机器学习
自由的dream1 小时前
0-1背包问题
算法
2401_857297912 小时前
招联金融2025校招内推
java·前端·算法·金融·求职招聘
技术无疆2 小时前
【Python】Streamlit：为数据科学与机器学习打造的简易应用框架
开发语言·人工智能·python·深度学习·神经网络·机器学习·数据挖掘
羊小猪~~2 小时前
机器学习/数据分析--用通俗语言讲解时间序列自回归(AR)模型，并用其预测天气，拟合度98%+
人工智能·python·机器学习·数据挖掘·数据分析·回归·时序数据库
良月澪二3 小时前
CSP-S 2021 T1廊桥分配
算法·图论
wangyue44 小时前
c# 线性回归和多项式拟合
算法
&梧桐树夏4 小时前
【算法系列-链表】删除链表的倒数第N个结点
数据结构·算法·链表
QuantumStack4 小时前
【C++ 真题】B2037 奇偶数判断
数据结构·c++·算法
今天好像不上班4 小时前
软件验证与确认实验二-单元测试
测试工具·算法
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache