数据挖掘聚类算法--DBSCAN

数据集如下所示：

1,1,1
2,1.5,1
3,0.5,1
3,5,-1
7,0.75,-1
7,4,2
8,5,2
8,5.5,2

数据集有三个属性，分别是二维坐标中的x和y，第三个属性是所属的类，-1代表为孤立点，坐标系如下图所示：

源代码如下：

package neugle.dbscan;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class DBScan {
    private List<Point> pointList = new ArrayList<DBScan.Point>();// 读入的样本数据

    private List<List<Point>> clusterList = new ArrayList<List<Point>>();// 最终分类结果

    private List<Point> noiseList = new ArrayList<DBScan.Point>();// 噪声数据集合

    private List<Point> npointList = new ArrayList<DBScan.Point>();// 候选数据集合

    private List<Integer> unvisitedList = new ArrayList<Integer>();// unvisited集合

    private double eps;// 邻域半径
    private int minPts;// 密度

    class Point {
        public double x;
        public double y;
        public String point_type;
        public boolean isVisited = false;
    }

    public DBScan(double eps, int minPts) {
        this.eps = eps;
        this.minPts = minPts;
    }

    // 读取数据
    public List<Point> ReadFile(String filePath) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader(filePath);
            br = new BufferedReader(fr);
            String line = null;
            while ((line = br.readLine()) != null) {
                Point point = new Point();
                String[] agrs = line.split(",");
                point.x = Double.parseDouble(agrs[0]);
                point.y = Double.parseDouble(agrs[1]);
                point.point_type = agrs[2];
                this.pointList.add(point);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return pointList;
    }

    // DBScan主方法
    public void DBScanFun(String filePath) {
        this.ReadFile(filePath);
        // this.Norm();
        while (this.IsOver()) {
            Point p = this.pointList.get(this.RandomNum());// 随机找到unvisited节点
            p.isVisited = true;// 标记p为visited
            List<Point> neighborList = this.GetNeighbors(p);// 找到满足最小密度的邻居节点
            if (neighborList.size() < this.minPts) {// 添加噪声数据
                this.noiseList.add(p);// 将p放入噪声集合
            } else {
                List<Point> clist = new ArrayList<DBScan.Point>();// 新建一个簇C
                clist.add(p);// 将p放到簇C中
                this.npointList = neighborList;// 令N为p的邻域对象的集合
                for (int i = 0; i < this.npointList.size(); i++) {
                    if (this.npointList.get(i).isVisited == false) {// 查找p'中unvisited的节点
                        this.npointList.get(i).isVisited = true;// 标记p'为visited
                        List<Point> neighborLists = this
                                .GetNeighbors(this.npointList.get(i));// 计算p'满足邻域的节点集合
                        if (neighborLists.size() >= this.minPts) {
                            for (int j = 0; j < neighborLists.size(); j++) {
                                this.npointList.add(neighborLists.get(j));// 将p'的邻域节点加入到N
                            }
                        }
                        clist.add(this.npointList.get(i));// 将p'添加到簇C
                    }
                }
                this.clusterList.add(clist);
            }
        }
    }

    // 在未访问的集合中随机选取
    private int RandomNum() {
        int num = this.unvisitedList.size();
        Random rand = new Random();
        int randNum = rand.nextInt(num);
        return this.unvisitedList.get(randNum);
    }

    // 获得邻域集合
    private List<Point> GetNeighbors(Point p) {
        List<Point> list = new ArrayList<DBScan.Point>();
        for (int i = 0; i < this.pointList.size(); i++) {
            double value = this.DistanceCalculate(this.pointList.get(i), p);
            if (value != 0 && value <= this.eps) {
                list.add(this.pointList.get(i));
            }
        }
        return list;
    }

    // 欧几里得距离公式
    private double DistanceCalculate(Point iris1, Point iris2) {
        double sum = Math.sqrt(Math.pow((iris1.x - iris2.x), 2)
                + Math.pow((iris1.y - iris2.y), 2));
        return sum;
    }

    // 判断数据是否都被访问完
    private boolean IsOver() {
        this.unvisitedList = new ArrayList<Integer>();
        for (int i = 0; i < this.pointList.size(); i++) {
            if (this.pointList.get(i).isVisited == false) {
                unvisitedList.add(i);
            }
        }
        if (this.unvisitedList.size() > 0) {
            return true;
        }
        return false;
    }

    public void Print() {
        System.out.println("聚为" + this.clusterList.size() + "类");
        for (int i = 0; i < this.clusterList.size(); i++) {
            List<Point> c = this.clusterList.get(i);
            System.out.println("------------");
            for (int j = 0; j < c.size(); j++) {
                System.out.println(c.get(j).x + " " + c.get(j).y + " "
                        + c.get(j).point_type);
            }
            System.out.println(c.size());
            System.out.println("------------");
        }

        System.out.println("噪声点有" + this.noiseList.size() + "个");
        System.out.println("------------");
        for (int i = 0; i < this.noiseList.size(); i++) {
            System.out.println(this.noiseList.get(i).x + " "
                    + this.noiseList.get(i).y + " "
                    + this.noiseList.get(i).point_type);
        }
        System.out.println("------------");
    }

    public static void main(String[] args) {
        DBScan c = new DBScan(2.5, 2);
        c.DBScanFun("D:\data\DBScan\test.data");
        c.Print();
    }
}

实验结果如下所示：

聚为2类
------------
8.0 5.5 2
7.0 4.0 2
8.0 5.0 2
3
------------
------------
3.0 0.5 1
1.0 1.0 1
2.0 1.5 1
3
------------
噪声点有2个
------------
3.0 5.0 -1
7.0 0.75 -1
------------