test3dlg.cpp

可以求的网络的最短路径,直径,介数

	 fprintf(fp_outmeasure,"%d   %d    %d\n",i,j,m_EdgeWeight[i][j]);
	 }*/
   /* //统计度、出度、入度、出权、入权、边权、点权分布

    for(i=0;i<m_Nodeptr;i++)        //找出度最大的点
	{
	   if(m_Degree[i]>m_MaxDegree)
		   m_MaxDegree=m_Degree[i];
       if(m_InDegree[i]>m_MaxInDegree)
		   m_MaxInDegree=m_InDegree[i];
       if(m_OutDegree[i]>m_MaxOutDegree)
		   m_MaxOutDegree=m_OutDegree[i];
       if(m_InWeight[i]>m_MaxInWeight)
		   m_MaxInWeight=m_InWeight[i];
       if(m_OutWeight[i]>m_MaxOutWeight)
		   m_MaxOutWeight=m_OutWeight[i];
       if(m_EdgeWeight[i][i]>m_MaxEdgeWeight)
		   m_MaxEdgeWeight=m_EdgeWeight[i][i];	
	   if(m_NodeWeight[i]>m_MaxNodeWeight)
	       m_MaxNodeWeight=m_NodeWeight[i];
	}
	for(i=0;i<m_Nodeptr;i++)
		for(j=0;j<m_Nodeptr;j++)
		{
		  if(m_EdgeWeight[i][j]>m_MaxEdgeWeight)
		   m_MaxEdgeWeight=m_EdgeWeight[i][j];	
		}
	m_DegreeVsNum=(int *)calloc(1,(m_MaxDegree+1)*sizeof(int));
    m_OutDegreeVsNum=(int *)calloc(1,(m_MaxOutDegree+1)*sizeof(int));
    m_InDegreeVsNum=(int *)calloc(1,(m_MaxInDegree+1)*sizeof(int));
    m_OutWeightVsNum=(int *)calloc(1,(m_MaxOutWeight+1)*sizeof(int));
    m_InWeightVsNum=(int *)calloc(1,(m_MaxInWeight+1)*sizeof(int));
    m_EdgeWeightVsNum=(int *)calloc(1,(m_MaxEdgeWeight+1)*sizeof(int));
    m_NodeWeightVsNum=(int *)calloc(1,(m_MaxNodeWeight+1)*sizeof(int));
    for(i=0;i<m_Nodeptr;i++)
	{
	   m_DegreeVsNum[m_Degree[i]]++;
       m_OutDegreeVsNum[m_OutDegree[i]]++;
       m_InDegreeVsNum[m_InDegree[i]]++;
       m_OutWeightVsNum[m_OutWeight[i]]++;
       m_InWeightVsNum[m_InWeight[i]]++;
       m_NodeWeightVsNum[m_NodeWeight[i]]++;
	}
    for(i=0;i<m_Nodeptr;i++)
		for(j=0;j<m_Nodeptr;j++)
       m_EdgeWeightVsNum[m_EdgeWeight[i][j]]++;
	//计算出对数
	FILE *fp_DF,*fp_OutDF,*fp_InDF,*fp_OutWeight,*fp_InWeight,*fp_EdgeWeight,*fp_NodeWeight;
	float m_a,m_b,m_c,m_d,m_e,m_theta;
	int m_TotalPtr=0;
	m_a=m_b=m_c=m_d=m_e=0;
	fp_DF=fopen("DrawDegreeOri.txt","w+");    //保存度log_log数据
    fp_OutDF=fopen("DrawOutDegreeOri.txt","w+");    //保存出度log_log数据
    fp_InDF=fopen("DrawInDegreeOri.txt","w+");    //保存入度log_log数据
    fp_OutWeight=fopen("DrawOutWeightOri.txt","w+");    //保存出权log_log数据
    fp_InWeight=fopen("DrawInWeightOri.txt","w+");    //保存入权log_log数据
    fp_EdgeWeight=fopen("DrawEdgeWeightOri.txt","w+");    //保存入权log_log数据
    fp_NodeWeight=fopen("DrawNodeWeightOri.txt","w+");    //保存入权log_log数据

	
	for(i=0;i<=m_MaxDegree;i++)                    //保存度log_log数据
	{
	   if(m_DegreeVsNum[i]==0) continue;
       fprintf(fp_DF,"%f      %f      %d       %d\n",log(i),log(m_DegreeVsNum[i]),i,m_DegreeVsNum[i]);
	   m_a=m_a+log(i)*m_DegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_DegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_DF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxOutDegree;i++)                        //保存出度log_log数据
	{
	   if(m_OutDegreeVsNum[i]==0) continue;
       fprintf(fp_OutDF,"%f      %f      %d       %d\n",log(i),log(m_OutDegreeVsNum[i]),i,m_OutDegreeVsNum[i]);
	   m_a=m_a+log(i)*m_OutDegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_OutDegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_OutDF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxInDegree;i++)                        //保存入度log_log数据
	{
	   if(m_InDegreeVsNum[i]==0) continue;
       fprintf(fp_InDF,"%f      %f      %d       %d\n",log(i),log(m_InDegreeVsNum[i]),i,m_InDegreeVsNum[i]);
	   m_a=m_a+log(i)*m_InDegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_InDegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_InDF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxOutWeight;i++)                        //保存出权log_log数据
	{
	   if(m_OutWeightVsNum[i]==0) continue;
       fprintf(fp_OutWeight,"%f      %f      %d       %d\n",log(i),log(m_OutWeightVsNum[i]),i,m_OutWeightVsNum[i]);
	   m_a=m_a+log(i)*m_OutWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_OutWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_OutWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxInWeight;i++)                        //保存入权log_log数据
	{
	   if(m_InWeightVsNum[i]==0) continue;
       fprintf(fp_InWeight,"%f      %f      %d       %d\n",log(i),log(m_InWeightVsNum[i]),i,m_InWeightVsNum[i]);
	   m_a=m_a+log(i)*m_InWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_InWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_InWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxEdgeWeight;i++)                        //保存边权log_log数据
	{
	   if(m_EdgeWeightVsNum[i]==0) continue;
       fprintf(fp_EdgeWeight,"%f      %f      %d       %d\n",log(i),log(m_EdgeWeightVsNum[i]),i,m_EdgeWeightVsNum[i]);
	   m_a=m_a+log(i)*m_EdgeWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_EdgeWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_EdgeWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxNodeWeight;i++)                        //保存点权log_log数据
	{
	   if(m_NodeWeightVsNum[i]==0) continue;
       fprintf(fp_NodeWeight,"%f      %f      %d       %d\n",log(i),log(m_NodeWeightVsNum[i]),i,m_NodeWeightVsNum[i]);
	   m_a=m_a+log(i)*m_NodeWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_NodeWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_NodeWeight,"m_theta=%f\n",m_theta);
	fclose(fp_DF);
    fclose(fp_OutDF);
    fclose(fp_InDF);
    fclose(fp_OutWeight);
    fclose(fp_InWeight);
    fclose(fp_EdgeWeight);
    fclose(fp_NodeWeight);*/

    m_ClusterCo=ClusterCoMatrix(); 
	fp_outmeasure=fopen("Results.txt","w+");
	fprintf(fp_outmeasure,"%f\n",m_ClusterCo);
    m_MeanLean=CalculateLen();
    fp_out=fopen("MeanLean.txt","w+");
	fprintf(fp_out,"%f\n",m_MeanLean);
	
	 MessageBox("Reading and writting finished!","Finish");
	 fclose(fp);
     fclose(fp1);
     fclose(Node);
     fclose(fp_outmeasure);
	 /*delete(m_OutDegree);
	 delete(m_InDegree);
     delete(m_Degree);
     delete(m_Edge);*/
	 return;
}
float CTEST3Dlg::ClusterCoMatrix()                      //计算网络的聚类系数用邻接矩阵
{
  long int i,j,h,Wij,Wih,Si;                  //Wij,Wih存放ij和ih之间的边权,Si为节点i的点权
  float m_Cluster=0;                       //网络的聚类系数
  long int m_Neighbors=0;                  //邻居的个数计数器
  long int m_NumOfEdges=0;                //邻居之间的边的条数
  float m_temp=0;                          //临时变量，用来计算网络聚类系数
  float	m_temp2=0;                         //临时变量，用来计算邻居间的点权

  for(i=0;i<m_Nodeptr;i++)
  {
    m_Neighbors=0;                         //邻居个数计数器
    m_NumOfEdges=0;                        //邻居之间实际的边条数
	Si=m_OutWeight[i]+m_InWeight[i];        //把入点权和出点权相加就等于点权
	for(j=0;j<m_Nodeptr;j++)
	{
	   if(m_EdgeWeight[i][j]!=0||m_EdgeWeight[j][i]!=0)   //i与当前节点j有边连接
	   {
	     m_Neighbors++;                   //邻居个数加1
         Wij=m_EdgeWeight[i][j]+m_EdgeWeight[j][i];        //在求解有向加权网络的节点聚类系数时，只要节点i和j和h之间存在连接边（不区分连接方向），所以在这把两个方向的边权都加上
	     m_temp2=m_temp2+Wij;
		 for(h=0;h<m_Nodeptr;h++)
		 {
		   if((m_EdgeWeight[j][h]!=0||m_EdgeWeight[h][j]!=0 )&& (m_EdgeWeight[i][h]!=0||m_EdgeWeight[h][i]!=0))//节点j的当前邻居h也是节点i的邻居
		   {
		     m_NumOfEdges++;
			 Wih=m_EdgeWeight[i][h]+m_EdgeWeight[h][i];        //在求解有向加权网络的节点聚类系数时，只要节点i和j和h之间存在连接边（不区分连接方向），所以在这把两个方向的边权都加上
			 m_temp2=m_temp2+Wih;
		   }
		 }
	   }
	}
   //计算出节点i的聚类系数
	if(m_NumOfEdges!=0 && m_Neighbors>1)
      m_temp=m_temp2/(2*Si*(m_Degree[i]-1));
	else
	  m_temp=0;
	m_Cluster+=m_temp;               //累计每个节点的聚类系数
  } 
  m_Cluster=float(m_Cluster/float(m_Nodeptr));
  return m_Cluster;

}
float CTEST3Dlg::CalculateLen() //计算平均路径长度的主程序
{
  int i,j;
  int sourcePoint;
  int s,v,loop;
  int nflag;
  DefResult *presult;
  float m_MeanLean=0;
  float m_temp=0;
  float m_NumOfUnreachableNode=0;
  for(loop=1;loop<=m_Nodeptr;loop++)
  {
    sourcePoint=loop;
	//用链表存储指针最短路径，共有（m_Nodeptr-1）条路径，因为下标从1开始
	presult=(DefResult *)malloc(sizeof(DefResult)*m_Nodeptr);
    //初始化从源点到各点的最短路径，并 求出与源点直接连接权值最小的点
	for(i=1,v=INT_MAX;i<=m_Nodeptr;i++)
	{
	   //标志从源点到对应点的最短路径未求出
	   presult[i].flag=0;
	   //路径初始化为空；
	   presult[i].thead=NULL;
	   if(m_EdgeWeight[sourcePoint][i]==0)         //从 源点到该点没有直接的连接
	   {
	      presult[i].start=-1;                     //路径没有起始点（除源点），设值为-1
		  presult[i].totalValue=INT_MAX;           //路径 初始化为最大
		  continue;
		 }
        presult[i].totalValue=m_EdgeWeight[sourcePoint][i];    //从源点到该点有直接连接，路径长度初始化为源点到该点的权值
		presult[i].start=i;         //路径从该点开始（除源点）
		if(v>m_EdgeWeight[sourcePoint][i])   //求出与源点直接连接权值最小的点，权值存于v中，点编号存于s中
		{
		  v=m_EdgeWeight[sourcePoint][i];
		  s=i;                        //i为与源点直接相连权值最小的点  
		  }
	  }
      m_EdgeWeight[sourcePoint][s]=0;   //标志该点不必考虑了，值为0
	  presult[s].flag=1;             //标志从源点到该点的最短路径已经找到
	  presult[sourcePoint].flag=1;   //源点到源点也标志完成
	  for(nflag=2;nflag<=m_Nodeptr;nflag++)  //从源点到n个顶点的最短路径是否已经求完，源点与源点直接相连权值最小的点已经完成，nflag初始为2
	  { 
	     v=presult[s].totalValue;     //s是目前源点到其他点最短路径的结束点
	     for(i=1;i<=m_Nodeptr;i++)   //扫描从s出发到其他各点的权值，以决定是否更新邻接表和路径表   
		 {
		    if((m_EdgeWeight[s][i]!=0)&&((v+m_EdgeWeight[s][i])<presult[i].totalValue))
			{
			   presult[i].totalValue=v+m_EdgeWeight[s][i];
			   presult[i].start=presult[i].start;
			  }
		   }
		  for(j=1,v=INT_MAX;j<=m_Nodeptr;j++)   //筛选目前结果中的最短路径
		  {
		      if(!presult[j].flag&&presult[j].totalValue&&presult[j].totalValue<v)
			  {
			     v=presult[j].totalValue;
				 s=j;
				}
			}
           presult[s].flag=1;               //标志从源点到s点的最短路径已经找到
           m_EdgeWeight[sourcePoint][s]=0;
		}
		for(j=1;j<=m_Nodeptr;j++)
		{
		   if(j==sourcePoint) continue;      //跳过源点本身
		   if(presult[i].start==-1)         //说明节点j不可达		   
		      m_NumOfUnreachableNode++;     //统计不可达节点个数
		   else	
		   { if(presult[j].totalValue>10000)  continue;
		      
              m_MeanLean=m_MeanLean+presult[j].totalValue;
		   }
		  }
	}
	m_temp=float((m_Nodeptr-m_NumOfUnreachableNode)*(m_Nodeptr-m_NumOfUnreachableNode-1)/2.0);
    m_MeanLean=float(m_MeanLean/m_temp);
    return m_MeanLean;
}
/*float CTEST3Dlg::MeanRouteLen()
{
  
	float m_MeanLean;
    m_MeanLean=CalculateLen();   
	return m_MeanLean;
}*/

void CTEST3Dlg::Onlength() 
{
	// TODO: Add your control notification handler code here
	m_length.readdata();
	//m_length.c_length();
	m_length.c();
}