精华内容
下载资源
问答
  • importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importorg.apache.commons.math3.util.MathUtils;import...CustomerPoint;/****@authorxjx**/public classDBScanTest...

    importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importorg.apache.commons.math3.util.MathUtils;import...CustomerPoint;/***

    *@authorxjx

    **/

    public classDBScanTest3{//欧式距离

    private final doubledistance;//最低要求的寻找邻居数量

    private final intminPoints;private final Map visited = new HashMap();//点的标记,point:聚合内的点,noise:噪音点

    private enumPointStatus {

    NOISE,POINT

    }public DBScanTest3(final double distance, final intminPoints)throwsException {if (distance < 0.0d) {throw new Exception("距离小于0");

    }if (minPoints < 0) {throw new Exception("点数小于0");

    }this.distance =distance;this.minPoints =minPoints;

    }public doublegetDistance() {returndistance;

    }public intgetMinPoints() {returnminPoints;

    }public MapgetVisited() {returnvisited;

    }/*** 返回customerPoint的多个聚合

    *@parampoints

    *@return

    */

    public List> cluster(Listpoints){final List> clusters = new ArrayList>();for(CustomerPoint point : points) {

    //如果已经被标记if (visited.get(point) != null) {continue;

    }

    List neighbors =getNeighbors(point, points);if (neighbors.size() >=minPoints) {

    visited.put(point, PointStatus.POINT);

    List cluster = new ArrayList();

    //遍历所有邻居继续拓展找点

    clusters.add(expandCluster(cluster, point, neighbors, points, visited));

    }else{

    visited.put(point, PointStatus.NOISE);

    }

    }returnclusters;

    }private List expandCluster( Listcluster,

    CustomerPoint point,

    Listneighbors,

    Listpoints,

    Mapvisited) {

    cluster.add(point);

    visited.put(point, PointStatus.POINT);int index = 0;//遍历 所有的邻居

    while (index

    CustomerPoint current =neighbors.get(index);

    PointStatus pStatus=visited.get(current);if (pStatus == null) {

    List currentNeighbors =getNeighbors(current, points);

    neighbors.addAll(currentNeighbors);

    }

    //如果该点未被标记,将点进行标记并加入到集合中if (pStatus !=PointStatus.POINT) {

    visited.put(current, PointStatus.POINT);

    cluster.add(current);

    }

    index++;

    }returncluster;

    }//找到所有的邻居

    private List getNeighbors(CustomerPoint point,Listpoints) {

    List neighbors = new ArrayList();for(CustomerPoint neighbor : points) {if (visited.get(neighbor) != null) {continue;

    }if (point != neighbor && neighbor.distanceFrom(point) <=distance) {

    neighbors.add(neighbor);

    }

    }returnneighbors;

    }

    //做数据进行测试public static void main(String[] args) throwsException {

    CustomerPoint customerPoint= new CustomerPoint(new double[] {3,8});

    CustomerPoint customerPoint1= new CustomerPoint(new double[] {4,7});

    CustomerPoint customerPoint2= new CustomerPoint(new double[] {4,8});

    CustomerPoint customerPoint3= new CustomerPoint(new double[] {5,6});

    CustomerPoint customerPoint4= new CustomerPoint(new double[] {3,9});

    CustomerPoint customerPoint5= new CustomerPoint(new double[] {5,1});

    CustomerPoint customerPoint6= new CustomerPoint(new double[] {5,2});

    CustomerPoint customerPoint7= new CustomerPoint(new double[] {6,3});

    CustomerPoint customerPoint8= new CustomerPoint(new double[] {7,3});

    CustomerPoint customerPoint9= new CustomerPoint(new double[] {7,4});

    CustomerPoint customerPoint10= new CustomerPoint(new double[] {0,2});

    CustomerPoint customerPoint11= new CustomerPoint(new double[] {8,16});

    CustomerPoint customerPoint12= new CustomerPoint(new double[] {1,1});

    CustomerPoint customerPoint13= new CustomerPoint(new double[] {1,3});

    List cs = new ArrayList<>();

    cs.add(customerPoint13);

    cs.add(customerPoint12);

    cs.add(customerPoint11);

    cs.add(customerPoint10);

    cs.add(customerPoint9);

    cs.add(customerPoint8);

    cs.add(customerPoint7);

    cs.add(customerPoint6);

    cs.add(customerPoint5);

    cs.add(customerPoint4);

    cs.add(customerPoint3);

    cs.add(customerPoint2);

    cs.add(customerPoint1);

    cs.add(customerPoint);

    //这里第一个参数为距离,第二个参数为最小邻居数量

    DBScanTest3 db= new DBScanTest3(1.5, 1);

    //返回结果并打印

    List> aa =db.cluster(cs);for(int i =0;i

    System.out.print(aa.get(i).get(j).toString());

    }

    System.out.println();

    }

    }

    }

    展开全文
  • 1 importjava.sql.Array;2 importjava.util.ArrayList;3 importjava.util.Random;4 importjava.util.Scanner;56 classpoint {7 public float x = 0;8 public float y = 0;9 public int flage = -1;1011 ...

    1 importjava.sql.Array;2 importjava.util.ArrayList;3 importjava.util.Random;4 importjava.util.Scanner;5

    6 classpoint {7 public float x = 0;8 public float y = 0;9 public int flage = -1;10

    11 public floatgetX() {12 returnx;13 }14

    15 public void setX(floatx) {16 this.x =x;17 }18

    19 public floatgetY() {20 returny;21 }22

    23 public void setY(floaty) {24 this.y =y;25 }26 }27

    28 public classKcluster {29

    30 point[] ypo;//点集

    31 point[] pacore = null;//old聚类中心

    32 point[] pacoren = null;//new聚类中心33

    34 //初试聚类中心,点集

    35 public voidproductpoint() {36 Scanner cina = newScanner(System.in);37 System.out.print("请输入聚类中点的个数(随机产生):");38 int num =cina.nextInt();39

    40 ypo = newpoint[num];41 //随机产生点

    42 for (int i = 0; i < num; i++) {43

    44 float x = (int) (new Random().nextInt(10));45 float y = (int) (new Random().nextInt(10));46

    47 ypo[i] = new point();//对象创建

    48 ypo[i].setX(x);49 ypo[i].setY(y);50

    51 }52

    53 //初始化聚类中心位置

    54 System.out.print("请输入初始化聚类中心个数(随机产生):");55 int core =cina.nextInt();56 this.pacore = new point[core];//存放聚类中心

    57 this.pacoren = newpoint[core];58

    59 Random rand = newRandom();60 int temp[] = new int[core];61 temp[0] =rand.nextInt(num);62 pacore[0] = newpoint();63 pacore[0].x = ypo[temp[0]].x;64 pacore[0].y = ypo[temp[0]].y;65 pacore[0].flage=0;66 //避免产生重复的中心

    67 for (int i = 1; i < core; i++) {68 int flage = 0;69 int thistemp =rand.nextInt(num);70 for (int j = 0; j < i; j++) {71 if (temp[j] ==thistemp) {72 flage = 1;//有重复

    73 break;74

    75 }76 }77 if (flage == 1) {78 i--;79 } else{80 pacore[i] = newpoint();81 pacore[i].x=ypo[thistemp].x;82 pacore[i].y =ypo[thistemp].y;83 pacore[i].flage = 0;//0表示聚类中心

    84 }85

    86 }87 System.out.println("初始聚类中心:");88 for (int i = 0; i < pacore.length; i++) {89 System.out.println(pacore[i].x + " " +pacore[i].y);90 }91

    92 }93

    94 // ///找出每个点属于哪个聚类中心

    95 public void searchbelong()//找出每个点属于哪个聚类中心

    96 {97

    98 for (int i = 0; i < ypo.length; i++) {99 double dist = 999;100 int lable = -1;101 for (int j = 0; j < pacore.length; j++) {102

    103 double distance =distpoint(ypo[i], pacore[j]);104 if (distance

    108

    109 }110 }111 ypo[i].flage = lable + 1;112

    113 }114

    115 }116

    117 //更新聚类中心

    118 public voidcalaverage() {119

    120 for (int i = 0; i < pacore.length; i++) {121 System.out.println("以为中心的点:");123 int numc = 0;124 point newcore = newpoint();125 for (int j = 0; j < ypo.length; j++) {126

    127 if (ypo[j].flage == (i + 1)) {128 System.out.println(ypo[j].x + "," +ypo[j].y);129 numc += 1;130 newcore.x +=ypo[j].x;131 newcore.y +=ypo[j].y;132

    133 }134 }135 //新的聚类中心

    136 pacoren[i] = newpoint();137 pacoren[i].x = newcore.x /numc;138 pacoren[i].y = newcore.y /numc;139 pacoren[i].flage = 0;140 System.out.println("新的聚类中心:" + pacoren[i].x + "," +pacoren[i].y);141

    142 }143 }144

    145 public doubledistpoint(point px, point py) {146

    147 return Math.sqrt(Math.pow((px.x - py.x), 2)148 + Math.pow((px.y - py.y), 2));149

    150 }151

    152 public voidchange_oldtonew(point[] old, point[] news) {153 for (int i = 0; i < old.length; i++) {154 old[i].x =news[i].x;155 old[i].y =news[i].y;156 old[i].flage = 0;//表示为聚类中心的标志。

    157 }158 }159

    160 public voidmovecore() {161 //this.productpoint();//初始化,样本集,聚类中心,

    162 this.searchbelong();163 this.calaverage();//164 double movedistance = 0;165 int biao = -1;//标志,聚类中心点的移动是否符合最小距离

    166 for (int i = 0; i < pacore.length; i++) {167 movedistance =distpoint(pacore[i], pacoren[i]);168 System.out.println("distcore:" + movedistance);//聚类中心的移动距离

    169 if (movedistance < 0.01) {170 biao = 0;171

    172 } else{173

    174 biao=1;//需要继续迭代,

    175 break;176

    177 }178 }179 if (biao == 0) {180 System.out.print("迭代完毕!!!!!");181 } else{182 change_oldtonew(pacore, pacoren);183 movecore();184 }185

    186 }187

    188 public static voidmain(String[] args) {189 //TODO Auto-generated method stub

    190

    191 Kcluster kmean = newKcluster();192 kmean.productpoint();193 kmean.movecore();194 }195

    196 }

    展开全文
  • 基于演化依赖的Java软件聚类实现技术研究
  • import java.util.ArrayList;import org.algorithm.Kmeans;public class KmeansTest {publicstatic void main(String[] args){//初始化一个Kmean对象,将k置为10Kmeans k=new Kmeans(10);ArrayList dataSet=n...

    package org.test;

    import java.util.ArrayList;

    import org.algorithm.Kmeans;

    public class KmeansTest {

    public static void main(String[] args)

    {

    //初始化一个Kmean对象,将k置为10

    Kmeans k=new Kmeans(10);

    ArrayList dataSet=new ArrayList();

    dataSet.add(new float[]{1,2});

    dataSet.add(new float[]{3,3});

    dataSet.add(new float[]{3,4});

    dataSet.add(new float[]{5,6});

    dataSet.add(new float[]{8,9});

    dataSet.add(new float[]{4,5});

    dataSet.add(new float[]{6,4});

    dataSet.add(new float[]{3,9});

    dataSet.add(new float[]{5,9});

    dataSet.add(new float[]{4,2});

    dataSet.add(new float[]{1,9});

    dataSet.add(new float[]{7,8});

    //设置原始数据集

    k.setDataSet(dataSet);

    //执行算法

    k.execute();

    //得到聚类结果

    ArrayList> cluster=k.getCluster();

    //查看结果

    for(int i=0;i

    {

    k.printDataArray(cluster.get(i), "cluster["+i+"]");

    }

    }

    }

    package org.algorithm;

    import java.util.ArrayList;

    import java.util.Random;

    public class Kmeans {

    private int k;// 分成多少簇

    private int m;// 迭代次数

    private int dataSetLength;// 数据集元素个数,即数据集的长度

    private ArrayList dataSet;// 数据集链表

    private ArrayList center;// 中心链表

    private ArrayList> cluster; // 簇

    private ArrayList jc;// 误差平方和,k越接近dataSetLength,误差越小

    private Random random;

    public void setDataSet(ArrayList dataSet) {

    this.dataSet = dataSet;

    }

    public ArrayList> getCluster() {

    return cluster;

    }

    public Kmeans(int k) {

    if (k <= 0) {

    k = 1;

    }

    this.k = k;

    }

    private void init() {

    m = 0;

    random = new Random();

    if (dataSet == null || dataSet.size() == 0) {

    initDataSet();

    }

    dataSetLength = dataSet.size();

    if (k > dataSetLength) {

    k = dataSetLength;

    }

    center = initCenters();

    cluster = initCluster();

    jc = new ArrayList();

    }

    private void initDataSet() {

    dataSet = new ArrayList();

    // 其中{6,3}是一样的,所以长度为15的数据集分成14簇和15簇的误差都为0

    float[][] dataSetArray = new float[][] { { 8, 2 }, { 3, 4 }, {

    2, 5 },

    { 4, 2 }, { 7, 3 }, { 6, 2 }, { 4, 7 }, { 6, 3 }, { 5, 3 },

    { 6, 3 }, { 6, 9 }, { 1, 6 }, { 3, 9 }, { 4, 1 }, { 8, 6 }

    };

    for (int i = 0; i < dataSetArray.length; i++) {

    dataSet.add(dataSetArray[i]);

    }

    }

    private ArrayList initCenters() {

    ArrayList center = new ArrayList();

    int[] randoms = new int[k];

    boolean flag;

    int temp = random.nextInt(dataSetLength);

    randoms[0] = temp;

    for (int i = 1; i < k; i++) {

    flag = true;

    while (flag) {

    temp = random.nextInt(dataSetLength);

    int j = 0;

    // 不清楚for循环导致j无法加1

    // for(j=0;j

    // {

    // if(temp==randoms[j]);

    // {

    // break;

    // }

    // }

    while (j < i) {

    if (temp == randoms[j]) {

    break;

    }

    j++;

    }

    if (j == i) {

    flag = false;

    }

    }

    randoms[i] = temp;

    }

    // 测试随机数生成情况

    // for(int i=0;i

    // {

    // System.out.println("test1:randoms["+i+"]="+randoms[i]);

    // }

    // System.out.println();

    for (int i = 0; i < k; i++) {

    center.add(dataSet.get(randoms[i]));// 生成初始化中心链表

    }

    return center;

    }

    private ArrayList> initCluster() {

    ArrayList> cluster = new ArrayList>();

    for (int i = 0; i < k; i++) {

    cluster.add(new ArrayList());

    }

    return cluster;

    }

    private float distance(float[] element, float[] center) {

    float distance = 0.0f;

    float x = element[0] - center[0];

    float y = element[1] - center[1];

    float z = x * x + y * y;

    distance = (float) Math.sqrt(z);

    return distance;

    }

    private int minDistance(float[] distance) {

    float minDistance = distance[0];

    int minLocation = 0;

    for (int i = 1; i < distance.length; i++) {

    if (distance[i] < minDistance) {

    minDistance = distance[i];

    minLocation = i;

    } else if (distance[i] == minDistance) // 如果相等,随机返回一个位置

    {

    if (random.nextInt(10) < 5) {

    minLocation = i;

    }

    }

    }

    return minLocation;

    }

    private void clusterSet() {

    float[] distance = new float[k];

    for (int i = 0; i < dataSetLength; i++) {

    for (int j = 0; j < k; j++) {

    distance[j] = distance(dataSet.get(i), center.get(j));

    //

    System.out.println("test2:"+"dataSet["+i+"],center["+j+"],distance="+distance[j]);

    }

    int minLocation = minDistance(distance);

    //

    System.out.println("test3:"+"dataSet["+i+"],minLocation="+minLocation);

    // System.out.println();

    cluster.get(minLocation).add(dataSet.get(i));//

    核心,将当前元素放到最小距离中心相关的簇中

    }

    }

    private float errorSquare(float[] element, float[] center) {

    float x = element[0] - center[0];

    float y = element[1] - center[1];

    float errSquare = x * x + y * y;

    return errSquare;

    }

    private void countRule() {

    float jcF = 0;

    for (int i = 0; i < cluster.size(); i++) {

    for (int j = 0; j < cluster.get(i).size(); j++) {

    jcF += errorSquare(cluster.get(i).get(j), center.get(i));

    }

    }

    jc.add(jcF);

    }

    private void setNewCenter() {

    for (int i = 0; i < k; i++) {

    int n = cluster.get(i).size();

    if (n != 0) {

    float[] newCenter = { 0, 0 };

    for (int j = 0; j < n; j++) {

    newCenter[0] += cluster.get(i).get(j)[0];

    newCenter[1] += cluster.get(i).get(j)[1];

    }

    // 设置一个平均值

    newCenter[0] = newCenter[0] / n;

    newCenter[1] = newCenter[1] / n;

    center.set(i, newCenter);

    }

    }

    }

    public void printDataArray(ArrayList dataArray,

    String dataArrayName) {

    for (int i = 0; i < dataArray.size(); i++) {

    System.out.println("print:" + dataArrayName + "[" + i +

    "]={"

    + dataArray.get(i)[0] + "," + dataArray.get(i)[1] + "}");

    }

    System.out.println("===================================");

    }

    private void kmeans() {

    init();

    // printDataArray(dataSet,"initDataSet");

    // printDataArray(center,"initCenter");

    // 循环分组,直到误差不变为止

    while (true) {

    clusterSet();

    // for(int i=0;i

    // {

    // printDataArray(cluster.get(i),"cluster["+i+"]");

    // }

    countRule();

    // System.out.println("count:"+"jc["+m+"]="+jc.get(m));

    // System.out.println();

    // 误差不变了,分组完成

    if (m != 0) {

    if (jc.get(m) - jc.get(m - 1) == 0) {

    break;

    }

    }

    setNewCenter();

    // printDataArray(center,"newCenter");

    m++;

    cluster.clear();

    cluster = initCluster();

    }

    // System.out.println("note:the times of

    repeat:m="+m);//输出迭代次数

    }

    public void execute() {

    long startTime = System.currentTimeMillis();

    System.out.println("kmeans begins");

    kmeans();

    long endTime = System.currentTimeMillis();

    System.out.println("kmeans running time=" + (endTime -

    startTime)

    + "ms");

    System.out.println("kmeans ends");

    System.out.println();

    }

    }

    package org.algorithm;

    import java.util.ArrayList;

    import java.util.Random;

    public class Kmeans {

    private int k;// 分成多少簇

    private int m;// 迭代次数

    private int dataSetLength;// 数据集元素个数,即数据集的长度

    private ArrayList dataSet;// 数据集链表

    private ArrayList center;// 中心链表

    private ArrayList> cluster; // 簇

    private ArrayList jc;// 误差平方和,k越接近dataSetLength,误差越小

    private Random random;

    public void setDataSet(ArrayList dataSet) {

    this.dataSet = dataSet;

    }

    public ArrayList> getCluster() {

    return cluster;

    }

    public Kmeans(int k) {

    if (k <= 0) {

    k = 1;

    }

    this.k = k;

    }

    private void init() {

    m = 0;

    random = new Random();

    if (dataSet == null || dataSet.size() == 0) {

    initDataSet();

    }

    dataSetLength = dataSet.size();

    if (k > dataSetLength) {

    k = dataSetLength;

    }

    center = initCenters();

    cluster = initCluster();

    jc = new ArrayList();

    }

    private void initDataSet() {

    dataSet = new ArrayList();

    // 其中{6,3}是一样的,所以长度为15的数据集分成14簇和15簇的误差都为0

    float[][] dataSetArray = new float[][] { { 8, 2 }, { 3, 4 }, { 2, 5

    },

    { 4, 2 }, { 7, 3 }, { 6, 2 }, { 4, 7 }, { 6, 3 }, { 5, 3 },

    { 6, 3 }, { 6, 9 }, { 1, 6 }, { 3, 9 }, { 4, 1 }, { 8, 6 } };

    for (int i = 0; i < dataSetArray.length; i++) {

    dataSet.add(dataSetArray[i]);

    }

    }

    private ArrayList initCenters() {

    ArrayList center = new ArrayList();

    int[] randoms = new int[k];

    boolean flag;

    int temp = random.nextInt(dataSetLength);

    randoms[0] = temp;

    for (int i = 1; i < k; i++) {

    flag = true;

    while (flag) {

    temp = random.nextInt(dataSetLength);

    int j = 0;

    // 不清楚for循环导致j无法加1

    // for(j=0;j

    // {

    // if(temp==randoms[j]);

    // {

    // break;

    // }

    // }

    while (j < i) {

    if (temp == randoms[j]) {

    break;

    }

    j++;

    }

    if (j == i) {

    flag = false;

    }

    }

    randoms[i] = temp;

    }

    // 测试随机数生成情况

    // for(int i=0;i

    // {

    // System.out.println("test1:randoms["+i+"]="+randoms[i]);

    // }

    // System.out.println();

    for (int i = 0; i < k; i++) {

    center.add(dataSet.get(randoms[i]));// 生成初始化中心链表

    }

    return center;

    }

    private ArrayList> initCluster() {

    ArrayList> cluster = new ArrayList>();

    for (int i = 0; i < k; i++) {

    cluster.add(new ArrayList());

    }

    return cluster;

    }

    private float distance(float[] element, float[] center) {

    float distance = 0.0f;

    float x = element[0] - center[0];

    float y = element[1] - center[1];

    float z = x * x + y * y;

    distance = (float) Math.sqrt(z);

    return distance;

    }

    private int minDistance(float[] distance) {

    float minDistance = distance[0];

    int minLocation = 0;

    for (int i = 1; i < distance.length; i++) {

    if (distance[i] < minDistance) {

    minDistance = distance[i];

    minLocation = i;

    } else if (distance[i] == minDistance) // 如果相等,随机返回一个位置

    {

    if (random.nextInt(10) < 5) {

    minLocation = i;

    }

    }

    }

    return minLocation;

    }

    private void clusterSet() {

    float[] distance = new float[k];

    for (int i = 0; i < dataSetLength; i++) {

    for (int j = 0; j < k; j++) {

    distance[j] = distance(dataSet.get(i), center.get(j));

    //

    System.out.println("test2:"+"dataSet["+i+"],center["+j+"],distance="+distance[j]);

    }

    int minLocation = minDistance(distance);

    //

    System.out.println("test3:"+"dataSet["+i+"],minLocation="+minLocation);

    // System.out.println();

    cluster.get(minLocation).add(dataSet.get(i));//

    核心,将当前元素放到最小距离中心相关的簇中

    }

    }

    private float errorSquare(float[] element, float[] center) {

    float x = element[0] - center[0];

    float y = element[1] - center[1];

    float errSquare = x * x + y * y;

    return errSquare;

    }

    private void countRule() {

    float jcF = 0;

    for (int i = 0; i < cluster.size(); i++) {

    for (int j = 0; j < cluster.get(i).size(); j++) {

    jcF += errorSquare(cluster.get(i).get(j), center.get(i));

    }

    }

    jc.add(jcF);

    }

    private void setNewCenter() {

    for (int i = 0; i < k; i++) {

    int n = cluster.get(i).size();

    if (n != 0) {

    float[] newCenter = { 0, 0 };

    for (int j = 0; j < n; j++) {

    newCenter[0] += cluster.get(i).get(j)[0];

    newCenter[1] += cluster.get(i).get(j)[1];

    }

    // 设置一个平均值

    newCenter[0] = newCenter[0] / n;

    newCenter[1] = newCenter[1] / n;

    center.set(i, newCenter);

    }

    }

    }

    public void printDataArray(ArrayList dataArray,

    String dataArrayName) {

    for (int i = 0; i < dataArray.size(); i++) {

    System.out.println("print:" + dataArrayName + "[" + i + "]={"

    + dataArray.get(i)[0] + "," + dataArray.get(i)[1] + "}");

    }

    System.out.println("===================================");

    }

    private void kmeans() {

    init();

    // printDataArray(dataSet,"initDataSet");

    // printDataArray(center,"initCenter");

    // 循环分组,直到误差不变为止

    while (true) {

    clusterSet();

    // for(int i=0;i

    // {

    // printDataArray(cluster.get(i),"cluster["+i+"]");

    // }

    countRule();

    // System.out.println("count:"+"jc["+m+"]="+jc.get(m));

    // System.out.println();

    // 误差不变了,分组完成

    if (m != 0) {

    if (jc.get(m) - jc.get(m - 1) == 0) {

    break;

    }

    }

    setNewCenter();

    // printDataArray(center,"newCenter");

    m++;

    cluster.clear();

    cluster = initCluster();

    }

    // System.out.println("note:the times of repeat:m="+m);//输出迭代次数

    }

    public void execute() {

    long startTime = System.currentTimeMillis();

    System.out.println("kmeans begins");

    kmeans();

    long endTime = System.currentTimeMillis();

    System.out.println("kmeans running time=" + (endTime -

    startTime)

    + "ms");

    System.out.println("kmeans ends");

    System.out.println();

    }

    }

    测试:

    1.聚类分析

    聚类分析是数据挖掘中的一种分析方法,它把一个没有类别标记的样本集按照一种准则划分成若干个相似的子集类,使相似的样本尽可能归为一类,不相似的划分到不同的类别中。聚类通过比较数据的相似性和差异性发现数据的内在特征和分布规律,从而获得对数据更深刻的认识。聚类分析以相似性为基础,在一个聚类中的模式之间比不在同一聚类中的模式之间具有更多的相似性。

    聚类分析的算法可以分为划分法、层次法、基于密度的方法、基于网格的方法、基于模型的方法。

    基于划分的聚类主要有k-平均及其变种,速度快易于实现还适用于文本图像等多种数据的聚类分析。

    k-means算法

    k-means 算法接受输入量 k ;然后将n个数据对象划分为

    k个聚类以便使得所获得的聚类满足:同一聚类中的对象相似度较高;而不同聚类中的对象相似度较小。聚类相似度是利用各聚类中对象的均值所获得一个“中心对象”(引力中心)来进行计算的。

    k-means 算法的工作过程说明如下:

    首先从n个数据对象任意选择 k

    个对象作为初始聚类中心;而对于所剩下其它对象,则根据它们与这些聚类中心的相似度(距离),分别将它们分配给与其最相似的(聚类中心所代表的)聚类;

    然后再计算每个所获新聚类的聚类中心(该聚类中所有对象的均值);不断重复这一过程直到标准测度函数开始收敛为止。

    一般都采用均方差作为标准测度函数.

    k个聚类具有以下特点:各聚类本身尽可能的紧凑,而各聚类之间尽可能的分开。

    KMeans算法的基本思想是初始随机给定K个簇中心,按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心,从而确定新的簇心。一直迭代,直到簇心的移动距离小于某个给定的值。

    a4c26d1e5885305701be709a3d33442f.png

    a4c26d1e5885305701be709a3d33442f.png

    展开全文
  • java聚类算法

    2014-11-05 19:38:03
    java编程语言实现最大最小距离聚类算法,例子使用的是一系列二维坐标。
  • packagekmeans;importjava.util.*;publicclassKmeans{publicArrayListallGenerals=null;publicinttotalNumber=0;//得到所有的武将数目publicintK=0;//假设K=10publicKmeans(){allGenerals=newDomParser...

    package kmeans;

    import java.util.*;

    public class Kmeans {

    public ArrayList allGenerals = null;

    public int totalNumber = 0;// 得到所有的武将数目

    public int K = 0;// 假设K=10

    public Kmeans() {

    allGenerals = new DomParser().prepare();

    totalNumber = allGenerals.size();

    K = 3;

    }

    // 第一次随机选取聚类中心

    public Set firstRandom() {

    Set center = new HashSet();// 聚类中心的点的id,采用set保证不会有重复id

    Random ran = new Random();

    int roll = ran.nextInt(totalNumber);

    while (center.size() 

    roll = ran.nextInt(totalNumber);

    center.add(roll);

    }

    return center;

    }

    // 根据聚类中心初始化聚类信息

    public ArrayList init(Set center) {

    ArrayList cluster = new ArrayList();// 聚类 的数组

    Iterator it = center.iterator();

    while (it.hasNext()) {

    Cluster c = new Cluster();// 代表一个聚类

    c.setCenter(it.next());

    cluster.add(c);

    }

    return cluster;

    }

    /**

    * 计算各个武将到各个聚类中心的距离,重新聚类

    *

    * @param cluster

    *            聚类数组,用来聚类的,根据最近原则把武将聚类

    * @param center

    *            中心点id,用于计算各个武将到中心点的距离 return cluster 聚类后的所有聚类组成的数组

    */

    public ArrayList juLei(Set center,

    ArrayList cluster) {

    ArrayList distence = new ArrayList();// 存放距离信息,表示每个点到各个中心点的距离组成的数组

    General source = null;

    General dest = null;

    int id = 0;// 目的节点id

    int id2 = 0;// 源节点id

    Object[] p = center.toArray();// p 为聚类中心点id数组

    boolean flag = false;

    // 分别计算各个点到各个中心点的距离,并将距离最小的加入到各个聚类中,进行聚类

    for (int i = 0; i 

    // 每个点计算完,并聚类到距离最小的聚类中就清空距离数组

    distence.clear();

    // 计算到j个类中心点的距离,便利各个中心点

    for (int j = 0; j 

    // 如果该点不在中心点内 则计算距离

    if (!(center.contains(i))) {

    flag = true;

    // 计算距离

    source = allGenerals.get(i);// 某个点

    dest = allGenerals.get((Integer) p[j]);// 各个 中心点

    // 计算距离并存入数组

    distence.add(new Distance((Integer) p[j], i, Tool.juli(

    source, dest)));

    } else {

    flag = false;

    }

    }

    // 说明计算完某个武将到类中心的距离,开始比较

    if (flag == true) {

    // 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,

    // 目的id即类中心点id,这个就归到这个中心点所在聚类中

    double min = distence.get(0).getDist();// 默认第一个distance距离是最小的

    // 从1开始遍历distance数组

    int minid = 0;

    for (int k = 1; k 

    if (min > distence.get(k).getDist()) {

    min = distence.get(k).getDist();

    id = distence.get(k).getDest();// 目的,即类中心点

    id2 = distence.get(k).getSource();// 某个武将

    minid = k;

    } else {

    id = distence.get(minid).getDest();

    id2 = distence.get(minid).getSource();

    }

    }

    // 遍历cluster聚类数组,找到类中心点id与最小距离目的武将id相同的聚类

    for (int n = 0; n 

    // 如果和中心点的id相同 则setError

    if (cluster.get(n).getCenter() == id) {

    cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类

    break;

    }

    }

    }

    }

    return cluster;

    }

    // 产生新的聚类中心点数组

    public Set updateCenter() {

    Set center = new HashSet();

    for (int i = 0; i 

    center.add(i);

    }

    return center;

    }

    // 更新聚类中心, 求平均值

    public ArrayList updateCluster(ArrayList cluster) {

    ArrayList result = new ArrayList();

    // 重新产生的新的聚类中心组成的数组

    // k个聚类进行更新聚类中心

    for (int j = 0; j 

    ArrayList ps = cluster.get(j).getOfCluster();// 该聚类的所有 武将

    // 组成的数组

    ps.add(allGenerals.get(cluster.get(j).getCenter()));// 同时将该类中心对应的武将加入该武将数组

    int size = ps.size();// 该聚类的长度大小

    // 计算和,然后在计算平均值

    int sumrender = 0, sumtongshai = 0, sumwuli = 0, sumzhili = 0, sumjibin = 0, sumnubin = 0, sumqibin = 0, sumpolic = 0, sumqiangbin = 0, sumbinqi = 0, sumtongwu = 0, sumtongzhi = 0, sumtongwuzhi = 0, sumtongwuzhizheng = 0, sumsalary = 0;

    for (int k1 = 0; k1 

    sumrender += ps.get(k1).getRender();

    sumtongshai += ps.get(k1).getRender();

    sumwuli += ps.get(k1).getWuli();

    sumzhili += ps.get(k1).getZhili();

    sumjibin += ps.get(k1).getJibin();

    sumnubin += ps.get(k1).getNubin();

    sumqibin += ps.get(k1).getQibin();

    sumpolic += ps.get(k1).getPolic();

    sumqiangbin += ps.get(k1).getQiangbin();

    sumbinqi += ps.get(k1).getBinqi();

    sumtongwu += ps.get(k1).getTongwu();

    sumtongzhi += ps.get(k1).getTongzhi();

    sumtongwuzhi += ps.get(k1).getTongwuzhi();

    sumtongwuzhizheng += ps.get(k1).getTongwuzhizheng();

    sumsalary += ps.get(k1).getSalary();

    }

    // 产生新的聚类,然后加入到聚类数组中

    Cluster newCluster = new Cluster();

    newCluster.setCenter(j);

    // 计算平均值并构造新的武将对象

    newCluster.addGeneral(new General(sumrender / size, sumtongshai

    / size, sumwuli / size, sumzhili / size, sumjibin / size,

    sumnubin / size, sumqibin / size, sumpolic = 0,

    sumqiangbin = 0, sumbinqi / size, sumtongwu / size,

    sumtongzhi / size, sumtongwuzhi / size, sumtongwuzhizheng

    / size, sumsalary / size));

    result.add(newCluster);

    }

    return result;

    }

    /**

    * 计算各个武将到各个更新后的聚类中心的距离,重新聚类

    * @param update 更新后的聚类中心

    * @param cluster 要存储的聚类中心

    */

    public ArrayList updateJuLei(ArrayList update,

    ArrayList cluster) {

    ArrayList distence = new ArrayList();// 存放距离信息,表示每个点到各个中心点的距离组成的数组

    General source = null;

    General dest = null;

    int id = 0;// 目的节点id

    int id2 = 0;// 源节点id

    //Object[] p = center.toArray();// p 为聚类中心点id数组

    boolean flag = false;

    // 分别计算各个点到各个中心点的距离,并将距离最小的加入到各个聚类中,进行聚类

    for (int i = 0; i 

    // 每个点计算完,并聚类到距离最小的聚类中就清空距离数组

    distence.clear();

    // 计算到j个类中心点的距离,便利各个中心点

    //for (int j = 0; j 

    for (int j = 0; j 

    // 如果该点不在中心点内 则计算距离

    //if (!(center.contains(i))) {

    flag = true;

    // 计算距离

    source = allGenerals.get(i);// 某个点

    // dest = allGenerals.get((Integer) p[j]);// 各个 中心点

    dest = update.get(j).getOfCluster().get(0);// 各个 中心点

    // 计算距离并存入数组

    //distence.add(new Distance((Integer) p[j], i, Tool.juli(

    distence.add(new Distance(update.get(j).getCenter(), i, Tool.juli(

    source, dest)));

    /*} else {

    flag = false;

    }*/

    }

    // 说明计算完某个武将到类中心的距离,开始比较

    if (flag == true) {

    // 排序比较一个点到各个中心的距离的大小,找到距离最小的武将的 目的id,和源id,

    // 目的id即类中心点id,这个就归到这个中心点所在聚类中

    double min = distence.get(0).getDist();// 默认第一个distance距离是最小的

    // 从1开始遍历distance数组

    int mid = 0;

    for (int k = 1; k 

    if (min > distence.get(k).getDist()) {

    min = distence.get(k).getDist();

    id = distence.get(k).getDest();// 目的,即类中心点

    id2 = distence.get(k).getSource();// 某个武将

    mid = k;

    } else {

    id = distence.get(mid).getDest();

    id2 = distence.get(mid).getSource();

    }

    }

    // 遍历cluster聚类数组,找到类中心点id与最小距离目的武将id相同的聚类

    for (int n = 0; n 

    // 如果和中心点的id相同 则setError

    if (cluster.get(n).getCenter() == id) {

    cluster.get(n).addGeneral(allGenerals.get(id2));// 将与该聚类中心距离最小的武将加入该聚类

    }

    }

    }

    }

    return cluster;

    }

    // 不断循环聚类直到各个聚类没有重新分配

    public ArrayList getResult() {

    ArrayList result = new ArrayList();

    ArrayList temp = new ArrayList();

    boolean flag = false;

    // 得到随机中心点然后进行聚类

    Set center = firstRandom();

    result = juLei(center, init(center));

    print(result);

    do {

    // 重新聚类

    ArrayList up = updateCluster(result);//新的聚类中心

    ArrayList cluster = init(updateCenter()); // 得到更新后的中心点对应的聚类数组

    temp = updateJuLei(up, cluster);

    //print(temp);

    flag = isEquals(temp, result);

    result = temp;

    } while (!flag);

    return result;

    }

    public boolean isEquals(ArrayList temp, ArrayList result){

    boolean flag = false;

    if(temp.size() != result.size()){

    return flag;

    }

    for(Cluster tem : temp){

    for(Cluster res : result){

    if(tem.getCenter() == res.getCenter()){

    flag = true;

    }

    }

    // 如果找了一轮没找到 则说明两个聚类

    if(flag == false){

    return false;

    }else{// 如果找了一轮找到了,那么接着找

    flag = false;

    }

    }

    //如果代码能进行到这边,说明是true

    flag = true;

    return flag;

    }

    //输出所有的聚类

    public void print(ArrayList cs) {

    System.out.println("***************************************");

    for (int i = 0; i 

    Cluster c = cs.get(i);

    System.out.println("-----------------------------------------------------");

    System.out.println("center: " + allGenerals.get(c.getCenter()));

    ArrayList p = c.getOfCluster();

    for (int j = 0; j 

    System.out.println("general:"+p.get(j)+"\n");

    }

    }

    }

    }

    展开全文
  • 摘要由于聚类技术的不断发展近几年运用范围越来越大在生物学上营销分析学上在对Internet上的Web中文档管理上都有很大的运用但是这些跨领域跨专业的运用需要一个公用平台来实现这就是本篇文章提倡的基于Java实现...
  • java实现FCM聚类算法

    热门讨论 2008-11-26 14:36:57
    java实现FCM聚类算法java实现FCM聚类算法java实现FCM聚类算法java实现FCM聚类算法
  • K-means聚类算法是一种迭代求解的聚类分析算法,其步骤是随机选取K个对象作为初始的聚类中心,然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象...
  • Kmeans文本聚类java实现

    热门讨论 2015-02-17 10:20:03
    java实现的文本聚类使用了kmeans算法
  • 1.简介K均值聚类算法是先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都...
  • 网上很多python的聚类算法有很多,找的Java的,里面是个jar,直接调用就好了
  • /*** K均值聚类算法*/public classKmeans {private int numOfCluster;//分成多少簇private int timeOfIteration;//迭代次数private int dataSetLength;//数据集元素个数,即数据集的长度private ...
  • 聚类分析算法,Kmeans的java简单实现
  • 效果图 Tuple.java实体类/** 数据对象* 二维坐标*/public class Tuple {float x;float y;public Tuple(){}public Tuple(float a,float b){this.x=a;this.y=b;}public void setXY(float a,float b){this.x=a;this.y=b...
  • java文本聚类程序代码文件,实现文本聚类功能,分词
  • 在介绍最小生成树算法(MST)之前,简单说一下平均链接算法(average-link)的实现过程,平均链接聚类算法和单链接类似,多了计算聚类之间距离矩阵的步骤实现步骤如下:1,将元素各成一组,把这些组放入容器H2,循环元素...
  • 1.项目背景 在做交通路线分析的时候,客户需要找出车辆的行车规律,我们将车辆每天的行车路线当做一个数据样本,总共有365天或是更多,从这些数据中通过聚类来获得行车路线规律统计分析。我首先想到是K-means算法,...
  • 然后将n个数据对象划分为 k个聚类以便使得所获得的聚类满足:同一聚类中的对象相似度较高;而不同聚类中的对象相似度较小。聚类相似度是利用各聚类中对象的均值所获得一个“中心对象”(引力中心)来进行计算的。k个...
  • 聚类算法中基于链接的算法大致有三种:单链接算法(single link),平均链接算法(average link),最小生成数算法(minimum spanning tree)。现在实现单链接算法,...下面例子实现了根据经纬度来实现城市的聚类。packa...
  • 层次聚类(Hierarchical Clustering)一.概念层次聚类不需要指定聚类的数目,首先它是将数据中的每个实例看作一个类,然后将最相似的两个类合并,该过程迭代计算只到剩下一个类为止,类由两个子类构成,每个子类又由更...
  • DBSCAN聚类算法java实现

    2018-04-28 16:34:52
    java版的DBSCAN聚类算法实现,是典型的算法思路实现,遍历未访问的所有点,如果是核心点,就新建一个簇,然后遍历其邻域内的所有点集A,不断扩展,如果簇内的点时核心点,就将其邻域所有点纳入点集A,并从点集移除已...
  • java实现kmeans算法,可以处理任意维度的向量。并将聚类结果写入文本。 java实现kmeans算法,可以处理任意维度的向量。并将聚类结果写入文本。
  • java简单实现聚类算法 但是有一个小问题,,,,我其实每次迭代之后(就是达不到我的收敛标准之前,聚类中心的误差达不到指定小的时候),虽然重新算了聚类中心,但是其实我的那些点并没有变,可是这个程序不知道咋...
  • KMeans算法的基本思想是初始随机给定K个簇中心,按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心,从而确定新...下图给出对坐标点的聚类结果:下面给出核心算法的代码:/*** Author: Or...
  • BIRCH(Balanced Iterative Reducing...关于BIRCH的更多特点先不介绍,我先讲一下算法的完整实现细节,对算法的实现过程搞清楚后再去看别人对该算法的评价才会感受深刻。你不需要具备B树的相关知识,我接下来会讲得很...
  • ​​上一篇中我们实现了最小生成树算法,现在我们利用最小生成树来实现图论聚类。如果有一最小生成树如图:最小生成树剪枝后聚类结果​我们要对以上六个点进行聚类,我们阈值为4,所以要剪掉权值大于等于4的边...
  • kmeans聚类java实现附测试数据及结果

    热门讨论 2011-12-01 19:11:06
    kmeans聚类java实现附测试数据及结果

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 652
精华内容 260
关键字:

java聚类实现

java 订阅