bigtree_clustering.java~16~

分别是模糊识别、模糊聚类、模糊控制的实例代码

package fuzzy_project;

class Bigtree_Clustering
{
  private double Matrix[][];
  private int row;
  private int col;
  private int x;
  private int length;
  private boolean sign;
  private Edges[] Value_Array;            //存储边
  private Edges[] Bigtree_Array;          //存放最大树边
  private int[][] Clustering_Matrix;      //存储所有可能的分类结果
  private int loop[];
  private String result;

  public Bigtree_Clustering(double array[][],int r,int c)
  {
    Matrix=array;
    row=r;
    col=c;
    x=0;
    length=1;
    sign=false;
    Value_Array=new Edges[row*(row-1)/2];     //一个完全无向图的边数有row*(row-1)/2条
    Bigtree_Array=new Edges[row-1];          //生成树的边数有row-1条
    Clustering_Matrix=new int[row][col];
    loop=new int[row*(row-1)/2];
    result="";

    for(int i=0;i<row;i++)
      for(int j=i+1;j<col;j++)
      {
        Value_Array[x]=new Edges(i,j,Matrix[i][j]);   //把相似矩阵的每条边存储在Edges类型的数组Value_Array中
        x++;
      }
    for(int x=0;x<row;x++)
    {
      Clustering_Matrix[x][0]=x;                  //给矩阵赋初始值
    }
    quickSort(Value_Array,0,row*(row-1)/2-1);      //对数组sort_array中的权值进行排序
    Bigtree_exe();
  }

  public void quickSort(Edges array[],int low,int high)   //快速排序算法
  {
    int i,j;
    Edges temp;
    i=low;
    j=high;
    temp=array[low];

    while(i<j)
    {
    while(array[j].weight>=temp.weight&&i<j)
      {j--;}
    array[i]=array[j];
    while(array[i].weight<=temp.weight&&i<j)
      {i++;}
    array[j]=array[i];
    }
    array[i]=temp;
    if(i-1>low)
      {quickSort(array,low,i-1);}
    if(high>i+1)
      {quickSort(array,i+1,high);}
  }

  public void Bigtree_exe()        //生成最大树
  {
    int x=0;int v1,v2;
    for(int i=row*(row-1)/2-1;i>=0;i--)          //判断是否构成回路
    {
      v1=seek(loop,Value_Array[i].start);
      v2=seek(loop,Value_Array[i].end);
      if(v1!=v2)
      {
        Bigtree_Array[x] = Value_Array[i];
        loop[v1]=v2;
        x++;
      }
      if(x==row-1)
        break;
    }
  }

  public String Clustering_exe(double param)     //在最大树基础上进行聚类
  {
    for(int i=0;i<row-1;i++)
    {
      if(Bigtree_Array[i].weight>=param)           //选取权值大于等于聚类参数的边
      {
        Clustering(Bigtree_Array[i].start,Bigtree_Array[i].end);
      }
    }

    for(int i=0;i<row;i++)        //返回聚类结果
   {
     if(Clustering_Matrix[i][0]==9999)
       continue;
     for(int j=0;j<col;j++)
     {
        if(j>0&&Clustering_Matrix[i][j]==0)
          break;
        result=result+String.valueOf(Clustering_Matrix[i][j]+1)+"、";
     }
     result=result+"#";
   }
   return result;
  }

  private void Clustering(int x,int y)     //根据当前最大树边的起点与终点值，合并具有相同元素的分类集合
  {
    for(int a=0;a<row;a++)
    {
      for (int b = 0; b < col; b++)
      {
        if (Clustering_Matrix[a][b] == x)
        {
          for (int c = 1; c < col; c++)
          {
            if (Clustering_Matrix[a][c]!= 0)
              length++;
          }
          for(int d=0;d<col;d++)
          {
            if(Clustering_Matrix[y][d]!=0)
              Clustering_Matrix[a][length++]=Clustering_Matrix[y][d];
          }
          Clustering_Matrix[y][0]=9999;
          sign = true;
          break;
        }
        if (Clustering_Matrix[a][b] == y)
        {
          for (int c = 1; c < col; c++)
          {
            if (Clustering_Matrix[a][c]!= 0)
              length++;
          }
          Clustering_Matrix[a][length]=x;
          for(int d=col-1;d>=0;d--)
          {
            if(Clustering_Matrix[x][d]!=0)
              Clustering_Matrix[a][length++]=Clustering_Matrix[x][d];
          }
          Clustering_Matrix[x][0]=9999;
          sign = true;
          break;
        }
      }
      length=1;
      if(sign)
      {
        sign=false;
        break;
      }
    }
  }

  private int seek(int loop[],int v)
  {
    int i=v;
    while(loop[i]>0)
    {i=loop[i];}
    return i;
  }
}