层次聚类算法java实现

层次聚类方法对给定的数据集进行层次的分解，直到某种条件满足为止。具体又可分为凝聚的，分裂的两种方案。

1凝聚的层次聚类是一种自底向上的策略，首先将每个对象作为一个簇，然后合并这些原子簇为越来越大的簇，直到所有的对象都在一个簇中，或者某个终结条件被满足，绝大多数层次聚类方法属于这一类，它们只是在簇间相似度的定义上有所不同。

2分裂的层次聚类与凝聚的层次聚类相反，采用自顶向下的策略，它首先将所有对象置于同一个簇中，然后逐渐细分为越来越小的簇，直到每个对象自成一簇，或者达到了某个终止条件。

层次凝聚的代表是AGNES算法

javad代码：

Node.java

public class Node {

String nodeName; // 样本点名

   Cluster cluster; //样本点所属类簇

   private double dimension[]; //样本点的维度

   public Node(){

   }

   public Node(double[]dimension,String nodeName){

       this.nodeName=nodeName;

       this.dimension=dimension;

   }

   public double[] getDimension(){

      return dimension;

   }

   public voidsetDimension(double[] dimension) {

      this.dimension = dimension;

   }

   public Cluster getCluster(){

      return cluster;

   }

   public void setCluster(Clustercluster) {

      this.cluster = cluster;

   }

   public String getNodeName(){

      return nodeName;

   }

   public void setNodeName(StringnodeName) {

      this.nodeName = nodeName;

   }

}

类簇Cluster.java

public class Cluster {

private List nodes = new ArrayList(); // 类簇中的样本点

   private StringclusterName;

   public List getNodes() {

      return nodes;

   }

   public void setNodes(Listnodes) {

      this.nodes = nodes;

   }

   public String getClusterName(){

      return clusterName;

   }

   public voidsetClusterName(String clusterName) {

      this.clusterName = clusterName;

   }

}

算法主程序

publicclass hierCluster {

 publicList startAnalysis(List nodes,int ClusterNum){

    List finalClusters=new ArrayList();

    ListoriginalClusters=InitialCluster(nodes);

    finalClusters=originalClusters;

    while(finalClusters.size()>ClusterNum){

        doublemin=Double.MAX_VALUE;

        intmergeIndexA=0;

        intmergeIndexB=0;

        for(inti=0;i

           for(int j=0;j

              if(i!=j){

                  ClusterclusterA=finalClusters.get(i);

                  ClusterclusterB=finalClusters.get(j);

                  ListnodesA=clusterA.getNodes();

                  ListnodesB=clusterB.getNodes();

                  for(intm=0;m

                     for(int n=0;n

                        doubletempDis=dist(nodesA.get(m),nodesB.get(n));

                        if(tempDis

                           min=tempDis;

                           mergeIndexA=i;

                           mergeIndexB=j;

                        }

                     }

                 }

              }

           } //end for j

        }// end fori

       //合并cluster[mergeIndexA]和cluster[mergeIndexB]

       finalClusters=mergeCluster(finalClusters,mergeIndexA,mergeIndexB);

    }//end while

    return finalClusters;

  }

private List mergeCluster(List finalCluster,int mergeIndexA, int mergeIndexB) {

if(mergeIndexA!=mergeIndexB)

{

ClusterclusterA=finalCluster.get(mergeIndexA);

ClusterclusterB=finalCluster.get(mergeIndexB);

List nodesA=clusterA.getNodes();

ListnodesB=clusterB.getNodes();

for (Node dp : nodesB) {

          Node tempDp = new Node();

         tempDp.setNodeName(dp.getNodeName());

         tempDp.setDimension(dp.getDimension());

          tempDp.setCluster(clusterA);

          nodesA.add(tempDp);

       }

clusterA.setNodes(nodesA);

finalCluster.remove(mergeIndexB);

//System.out.println(" removemergeIndexA"+mergeIndexA+";"+mergeIndexB);

}

returnfinalCluster;

}

public double dist(Node a,Nodeb)

{

double[]dimensionA=a.getDimension();

double[]dimensionB=b.getDimension();

doubledistance=0;

if(dimensionA.length==dimensionB.length)//注意易出错为：//if(dimensionA==dimensionB)

{

for(int j=0;j

{

doubletemp=Math.pow(dimensionA[j]-dimensionB[j], 2);

distance=distance+temp;

}

distance=Math.pow(distance,0.5);

}

return distance;

}

public ListInitialCluster(Listnodes)

{

ListoriginalCluster=newArrayList();

for(int i=0;i

{

Node tempNode=nodes.get(i);

ListtempNodes=new ArrayList();

tempNodes.add(tempNode);

Cluster tempCluster=newCluster();

tempCluster.setClusterName("cluster"+String.valueOf(i));

tempCluster.setNodes(tempNodes);

tempNode.setCluster(tempCluster);

originalCluster.add(tempCluster);

}

returnoriginalCluster;

}

publicstatic void main(String[] args) {

ArrayListnodes = new ArrayList();

for(int i=0;i<20;i++){//随机产生点

floattempx=(float) Math.random();

float tempy=(float)Math.random(); 

double[]a={tempx,tempy};

Node tempNode=newNode(a,String.valueOf(i));

nodes.add(tempNode);

}

 intclusterNum=5; //类簇数

    hierCluster hc=new hierCluster();

    List clusters=hc.startAnalysis(nodes,clusterNum);

    for(Cluster cl:clusters){

       System.out.println("------"+cl.getClusterName()+"------");

        ListtempDps=cl.getNodes();

        for(Nodetempdp:tempDps){

          System.out.println(tempdp.getNodeName());

       }

    }

}

}