输入data为矩阵，clusternumber为聚类的个数，该算法使用的是计量地理的思想。使用的测试数据如下：
0.0,0.375,0.483,1.749,1.516,0.375
0.0,0.0,0.776,1.596,1.336,1.743
0.0,0.0,0.0,1.926,1.662,2.154
0.0,0.0,0.0,0.0,0.501,0.693
0.0,0.0,0.0,0.0,0.0,0.589
0.0,0.0,0.0,0.0,0.0,0.0
#order1:获取的最小值行列号
#isexist:判断的聚类结果里面是否包含新的类，如果包括，将新类加入进去
#newdata：如果新类由两个元素，并且这两个元素属于两个类，吧这两个类里面的数据放到newdata里面，最后合并为一类
#Flag_DeleteRowAndCol:在最后删除已分类的行列用到
#Flag_DeleteName：在最后删除行列名
#Flag_DeleteNumber：一共删除多少行（列）
#counDIM：新加的行列名称
#calcdis:用于计算所有类与当前值的距离
#leaveMatrixDim:用于循环的数据矩阵是否需要删除最后一列，因为最后一列始终为所有类别与剩余元素的最小值，并且只有一列
cluster = function(data,clusterNumbers)
{
#data=as.data.frame(b)
#clusterNumbers=4
#browser()
name=rownames(data)
ori=data
counDIM=1+nrow(data)
#
# dist=data.frame(1,2:6,t(data[1,2:6]))
# colnames(dist)=c('rownumber','colnumber','value')
# for(i in 2:(nrow(data)-1))
# {
# j=i+1
# a=data.frame(i,j:6,t(data[i,j:6]))
# colnames(a)=c('rownumber','colnumber','value')
# dist=rbind(dist,a)
# print(i)
# }
# rownames(dist)=NULL
leaveMatrixDim=nrow(ori)
clusterresult=matrix(0,leaveMatrixDim,leaveMatrixDim)
rownames(clusterresult)=1:leaveMatrixDim
colnames(clusterresult)=1:leaveMatrixDim
newcluster=matrix(0,10*leaveMatrixDim,leaveMatrixDim)
rownames(newcluster)=1:(10*leaveMatrixDim)
colnames(newcluster)=1:(leaveMatrixDim)
finalDIMofData=nrow(data)+1
# clusterresult[1,1]=6
# clusterresult[2,1]=1
# clusterresult[2,2]=2
# clusterresult[2,3]=6
# calc_dist=dist[which(dist$value!=-1),]
m_iswhile=TRUE
while(m_iswhile)
{
minValue= min(data[data!=0])
getrowandcol=which(data==minValue, arr.ind = TRUE)
order1=c(getrowandcol)
Flag_DeleteRowAndCol=order1
Flag_DeleteName=as.numeric(rownames(data)[order1])
order1=unique(Flag_DeleteName)
Flag_DeleteNumber=length(order1)
# for(indx in 1:Flag_DeleteNumber)
# {
# if(order1[indx]<=(as.numeric(rownames(ori)[nrow(ori)])))
# leaveMatrixDim=leaveMatrixDim-1
# }
leaveMatrixDim=nrow(data)
#如果与已经分类的归为一类，需要找到那一类的所有行列
#if(any(order1>(nrow(data)-Flag_DeleteNumber))==TRUE)
if(any(order1>(as.numeric(rownames(ori)[nrow(ori)])))==TRUE)
{
#browser()
calcrc=which(newcluster == minValue, arr.ind = TRUE)
for(i in 1:nrow(calcrc))
{
calcrow=which(newcluster == minValue, arr.ind = TRUE)[i,1]
calccol=which(newcluster == minValue, arr.ind = TRUE)[i,2]
order1=cbind(order1, newcluster[c(calcrow+1,calcrow+2),calccol])
}
# calccol=which(newcluster == minValue, arr.ind = TRUE)
# for(i in 1:nrow(getrowandcol))
# {
# order1=cbind(order1, newcluster[c(calcrow+1,calcrow+2),calccol])
# }
order1=c(order1)
order1=order1[order1<=(as.numeric(rownames(ori)[nrow(ori)]))]
order1=unique(order1)
}
#查看当前的两条轨迹是否已经在结果类别中出现过
for(ex in 1:length(order1))
{
if(ex==1)
{
isexist=which(clusterresult==order1[ex], arr.ind = TRUE)
}else
{
isexist=rbind(isexist, which(clusterresult==order1[ex], arr.ind = TRUE))
}
}
#如果出现过，只留下行号，即类别号，后面要归为这一类里面
if(nrow(isexist)>0)
isexist=unique(isexist[,1])
#判断是否需要合并现有的两个类别
if(length(isexist)>1)
{
for(l in 1:length(isexist))
{
if(l==1)
{
newdata=c((clusterresult[isexist[1],]))
}else
{
newdata=rbind(newdata,c(clusterresult[isexist[l],]))
}
}
newdata=c(newdata)
newdata=as.data.frame(newdata)
for(k in 1:length(order1))
{
newdata=rbind(newdata,order1[k])
}
newdata=unique(newdata)
newdata=newdata[which(newdata>0),1]
clusterresult=clusterresult[-isexist,]
#把结果中的两类合并后，要把这两类清零，然后把结果都网上提，保证前面部分有数据，后面为0，（数据连续，0连续，不能中间有间隔）
for(i in 1:length(isexist))
{
clusterresult=rbind(clusterresult,rep(0,nrow(ori)))
}
if(length(which(clusterresult!=0, arr.ind = TRUE))>0)
{
irow=(max(which(clusterresult!=0, arr.ind = TRUE)[,1]))+1
}else
{
irow=1
}
icol=1
for(k in 1:length(newdata))
{
clusterresult[irow,icol]=(newdata[k])
icol=icol+1
}
rownames(clusterresult)[irow]=counDIM
}
if(length(isexist)==1)
{
irow=isexist[1]
icol=(max(which(clusterresult[irow,]!=0, arr.ind = TRUE)))+1
for(k in 1:length(order1))
{
clusterresult[irow,icol]=order1[k]
icol=icol+1
}
rownames(clusterresult)[irow]=counDIM
}#新填一类
if(length(isexist)<1)
{
#查找最后的类别号
if(length(which(clusterresult!=0, arr.ind = TRUE))>0)
{
irow=(max(which(clusterresult!=0, arr.ind = TRUE)[,1]))+1
}else
{
irow=1
}
index=1
for(k in 1:length(order1))
{
clusterresult[irow,index]=order1[k]
index=index+1
}
rownames(clusterresult)[irow]=counDIM
}
# newcluster= data.frame(rep(0,(nrow(data)-length(order1))),rep(0,(nrow(data)-length(order1))),rep(0,(nrow(data)-length(order1))))
#用于一开始查询已有类别的行号，也可以作为最后新增列使用
#newcluster=matrix(0,3,(nrow(data)-length(name)))
if(length(intersect(name,Flag_DeleteName))>0)
{
name=name[-which(name%in%intersect(name,as.character(Flag_DeleteName)))]
}
#把要删除的行列删除
data=data[-Flag_DeleteRowAndCol,-Flag_DeleteRowAndCol]
# if(nrow(data)>leaveMatrixDim)
# {
# data=data[1:leaveMatrixDim,1:leaveMatrixDim]
# }
#如果新添加的列被聚到类别中，那newcluster（记录每次新列的数据）就要把相应的清零
for(i in 1:length(Flag_DeleteName))
{
if(Flag_DeleteName[i]>nrow(ori))
{
calcrow=nrow(ori)+3*(Flag_DeleteName[i]-nrow(ori)-1)+1
# getculsterrow=which(rownames(newcluster)==calcrow,arr.ind = TRUE)[1]
newcluster[c(calcrow,calcrow+1,calcrow+2),]=0
}
}
#对聚类的结果进行去重
for(i in 1:(max(which(clusterresult!=0, arr.ind = TRUE)[,1])))
{
a=clusterresult[i,(clusterresult[i,]>0)]
a=unique(a)
clusterresult[i,]=0
for(j in 1:length(a))
{
clusterresult[i,j]=a[j]
}
}
#行列名称也要改，因为后面聚类的时候是通过行列名称判断的
if((max(which(clusterresult!=0, arr.ind = TRUE)[,1]))!=clusterNumbers || nrow(data)>(nrow(ori)/20))
{
#查找要归入类内的所有行列号
# for(i in 1:(max(which(clusterresult!=0, arr.ind = TRUE)[,1])))
# {
# if(i==1)
# {
# calcdis=clusterresult[i,which(clusterresult[i,]!=0, arr.ind = TRUE)]
# }else
# {
# calcdis=rbind(calcdis,clusterresult[i,which(clusterresult[i,]!=0, arr.ind = TRUE)])
# }
#
# }
# calcdis=unique(c(calcdis))
leavename=rownames(data)
for(i in 1:((length(leavename))))
{
#browser()
#if(leaveMatrixDim==4) browser()
#判断要重新计算距离的两类是否是集合，如果是，需要对应找到这个集合里面的所有元素进行比较
if(as.numeric(leavename[i])>nrow(ori))
{
getculsterrow=which(rownames(clusterresult)==as.numeric(leavename[i]),arr.ind = TRUE)[1]
disd=clusterresult[getculsterrow,which(clusterresult[getculsterrow,]!=0, arr.ind = TRUE)]#disd是已有的类别
getculsterrow=which(rownames(clusterresult)==counDIM,arr.ind = TRUE)[1]
calcdis=clusterresult[getculsterrow,which(clusterresult[getculsterrow,]!=0, arr.ind = TRUE)]
new1= ifelse(ori[calcdis[1],as.numeric(disd[1])]>ori[as.numeric(disd[1]),calcdis[1]],ori[calcdis[1],as.numeric(disd[1])],ori[as.numeric(disd[1]),calcdis[1]])
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(disd[1])
newcluster[finalDIMofData+2,i]=calcdis[1]
for(j in 1:length(calcdis))
{
for(k in 1:length(disd))
{
new2= ifelse(ori[calcdis[j],as.numeric(disd[k])]>ori[as.numeric(disd[k]),calcdis[j]],ori[calcdis[j],as.numeric(disd[k])],ori[as.numeric(disd[k]),calcdis[j]])
if(new1==0)
{
new1= new2
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(disd[k])
newcluster[finalDIMofData+2,i]=calcdis[j]
}
if(new1>new2 && new2!=0)
{
new1= new2
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(disd[k])
newcluster[finalDIMofData+2,i]=calcdis[j]
}
}
}
}else
{
getculsterrow=which(rownames(clusterresult)==counDIM,arr.ind = TRUE)[1]
calcdis=clusterresult[getculsterrow,which(clusterresult[getculsterrow,]!=0, arr.ind = TRUE)]
new1= ifelse(ori[calcdis[1],as.numeric(leavename[i])]>ori[as.numeric(leavename[i]),calcdis[1]],ori[calcdis[1],as.numeric(leavename[i])],ori[as.numeric(leavename[i]),calcdis[1]])
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(leavename[i])
newcluster[finalDIMofData+2,i]=calcdis[1]
for(j in 2:length(calcdis))
{
new2= ifelse(ori[calcdis[j],as.numeric(leavename[i])]>ori[as.numeric(leavename[i]),calcdis[j]],ori[calcdis[j],as.numeric(leavename[i])],ori[as.numeric(leavename[i]),calcdis[j]])
if(new1==0)
{
new1= new2
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(leavename[i])
newcluster[finalDIMofData+2,i]=calcdis[j]
}
if(new1>new2 && new2!=0)
{
new1= new2
newcluster[finalDIMofData,i]=new1
newcluster[finalDIMofData+1,i]=as.numeric(leavename[i])
newcluster[finalDIMofData+2,i]=calcdis[j]
}
}
}
}
add=newcluster[finalDIMofData,]
add=add[add>0]
data=cbind(data, t(t(add)))#加一列，是计算的新距离
data=rbind(data,c(rep(0,(nrow(data)+1))))#加一行，全为0
rownames(data)[nrow(data)]=counDIM
colnames(data)[nrow(data)]=counDIM
counDIM=counDIM+1
rownames(data)[1:length(name)]=name
colnames(data)[1:length(name)]=name
finalDIMofData=finalDIMofData+3
}else
{
m_iswhile=FALSE
}
cat('待聚类元素个数：',leaveMatrixDim,'\n')
cat('newcluster中共有数据行：',(max(which(newcluster!=0, arr.ind = TRUE)[,1])),'\n')
cat('已完成聚类个数：',(max(which(clusterresult!=0, arr.ind = TRUE)[,1])),'\n')
#print((leaveMatrixDim))
#print((leaveMatrixDim))
}
browser()
return(clusterresult)
}
cluster(C,1)
b=AREA_COST_Order
for(i in 1:nrow(AREA_COST_Order))
{
for(j in i:0)
{
b[i,j]=0
}
}
b[b==1]=0
rownames(b)=1:nrow(b)
colnames(b)=1:nrow(b)
diag(b)=0
result_cluster=cluster(b,4)
data=as.data.frame(b)
clusterNumbers=4
b=read.csv("K:\\本科\\学习\\C++\\程序\\聚类分析\\ClusterAnalysis\\Table 7-5.txt", sep = ",",header=F)
cluster(b,1)
(max(which(result_cluster!=0, arr.ind = TRUE)[,1]))
![R语言中的功效分析[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)