work3.cpp

本代码实现了AHP决策分析

#include <stdio.h>
#include <stdlib.h>

struct unit_p
{
	int n;//序号
	float data;//权重值
	struct unit_p *next;

}* head;

float RI[15]={0,0,0.58,0.9,1.12,
			  1.24,1.32,1.41,1.45,1.49,
			  1.52,1.54,1.56,1.58,1.59};

struct unit_p * BuildLayer(int i)
{

	int j;
	struct unit_p *p = NULL,*q1,*q2;

	p=(struct unit_p *)malloc(sizeof(struct unit_p));
	p->n=1;
	p->data=0;
	p->next=NULL;

	q1=p;
	
	for (j=1;j<i;j++)
	{
		q2=(struct unit_p *)malloc(sizeof(struct unit_p));
		q2->n=j+1;
		q2->next=NULL;
		q2->data=0;

		q1->next=q2;
		q1=q2;

	}

	return(p);
}

int GetLayerNumber(struct unit_p * p)
{
	int i=0;
	while (p!=NULL) {i++;p=p->next;}
	return (i);

}

float * GetWeight(float * b,int i)
{
	float * result;
	result=new float[i];
	int m,n;
	float n_sum=0,m_sum=0;
	float *t;
	t=new float[i*i];

	for (n=0;n<i*i;n++) t[n]=b[n];

	for (n=0;n<i;n++)
	{
		for (m=0;m<i;m++)
			n_sum+=t[m*i+n];

		for (m=0;m<i;m++)
			t[m*i+n]/=n_sum;

		n_sum=0;
	}


	for (m=0;m<i;m++)
	{
		for (n=0;n<i;n++)
			m_sum+=t[m*i+n];

		result[m]=m_sum;
		
		m_sum=0;
	}

	for (n=0;n<i;n++)
		n_sum+=result[n];
	for (n=0;n<i;n++)
		result[n]/=n_sum;

	delete t;

	return(result);
}

float GetPreLayerWeight(struct unit_p * p,int i)
{
	while (p->n!=i) p=p->next;

	return(p->data);
}

void SumWeight(struct unit_p *p,float * b,float w)
{
	int i=0;
	while (p!=NULL)
	{
		p->data+=w*b[i++];
		p=p->next;

	}

}

void OutputWeight(struct unit_p * p,//层首元素指针
				  int layer)        //层数
{
/*	printf("\n");
	while (p!=NULL)
	{
		printf("%f\t",p->data);
		p=p->next;
	}*/


	FILE *fp;
	fp=fopen("out.txt","a");
	
	fprintf(fp,"第%d层各个元素的权重值如下：\n",layer);

	while (p!=NULL)
	{
		fprintf(fp,"%c%d:%.4f    ",'A'+layer-1,p->n,p->data);
		p=p->next;

	}
	
	fprintf(fp,"\n---------------------------------\n");	
	
	fclose(fp);
}

float * TransWeightArray(float * b,  //需要转换的权重值向量，由于个数不一定为此层元素个数
						 int k,		//权重向量中的元素个数
						 int i,		//层元素个数
						 int * r)	//相关元素的编号
{
	float * br;
	br=new float[i];

	int j;
	for (j=0;j<i;j++) 
	  br[j]=0;

	for (j=0;j<k;j++)
		br[r[j]-1]=b[j];
	
	return(br);
}


void OutputLayerPar(float * b,//判断矩阵数组
					int r,//相关元素个数，数组的行列数
					int * rb,//相关元素编号
					int layer,//上一层层号
					int m,//上一层的元素号
					float r_max,
					float cr)
{
	FILE * fp;
	fp=fopen("dat.txt","a");

	int i,j;

	fprintf(fp,"第%d层元素对于第%d层第%d元素的判断矩阵：\n",layer+1,layer,m);
	
	fprintf(fp,"%c%d\t",'A'+layer-1,m);
	for (i=0;i<r;i++)
		fprintf(fp,"%c%d\t",'A'+layer,rb[i]);
	
	for (i=0;i<r;i++)
	{
		fprintf(fp,"\n%c%d\t",'A'+layer,rb[i]);
		for (j=0;j<r;j++)
			fprintf(fp,"%.4f\t",b[i*r+j]);
	}
	
	fprintf(fp,"\n------------------------------------\n");
	
	fprintf(fp,"最大特征根R_MAX=%.4f,CI=%.4f,RI=%.2f,CR=%.4f",r_max,(r_max-r)/(r-1),RI[r-1],cr);
	
	fprintf(fp,"\n------------------------------------\n");

	
	
	fclose(fp);



}

float ComputMaxRoot(float * b,//判断矩阵
					float * w,//权重向量
					int r)//行列数
{
	float result=0;
	
	int i,j;

	float bw=0;

	for (i=0;i<r;i++)
	{
		for (j=0;j<r;j++)
		{
			bw+=b[i*r+j]*w[j];
		}

		result+=bw/w[i];
		bw=0;
	}

	result/=r;
	return(result);
}

float CheckCR(float r,//最大特征根
			int n)//判断矩阵行列数
{
	float CR;
	if (n>2) CR=(r-n)/(n-1)/RI[n-1];
	else CR=0;

	return(CR);
}

void main()
{
	int i,LayerNumber,j;
	float * b;//评价矩阵指针
	int layer=1;
	int m,n;
	float * b_result,* b_sum;
	float w;
	int RelateNumber;
	int * Relate;
	float r_max,CR;
	
	head=BuildLayer(1);
	head->data=1;

	OutputWeight(head,layer);

	struct unit_p * p=NULL,*preLayerP=NULL;
	
	preLayerP=head;
	
	printf("本程序为采用和积算法的AHP决策分析方法\n适用于结构图层数小于25\n每层元素个数小于15");
	printf("\n当输入的层元素个数为0时，程序结束");
	printf("\n\n请输入决策图表中第2层元素个数\n");

	
	scanf("%d",&i);
	
	while (i)
	{
		
//		b=new float[i*i];
		
		Relate=new int[i];
		for (m=0;m<i;m++)
			Relate[m]=0;

		p=BuildLayer(i);

		LayerNumber=GetLayerNumber(preLayerP);
			
		for (j=1;j<=LayerNumber;j++)
		{
			printf("请输入与第%d层第%d个元素相关的元素个数:",layer,j);
			scanf("%d",&RelateNumber);
			if (RelateNumber!=i)
			{
				
				printf("请从小到大输入这些元素编号\n请以逗号分开：");
				for (m=0;m<RelateNumber;m++)
					scanf("%d,",&Relate[m]);

			}
			else
			{
				for (m=0;m<RelateNumber;m++)
					Relate[m]=m+1;
			}

			b=new float[RelateNumber*RelateNumber];
			
			
			printf("请输入相对于第%d层第%d个元素的判断矩阵\n",layer,j);

			for (m=0;m<RelateNumber;m++)
				for (n=m+1;n<RelateNumber;n++)
				{
					printf("[%c%d/%c%d]=",'A'+layer,Relate[m],'A'+layer,Relate[n]);
					scanf("%f",&b[m*RelateNumber+n]);
				}

			for (m=0;m<RelateNumber;m++)
				for (n=0;n<RelateNumber;n++)
				{
					if (m==n) b[m*RelateNumber+n]=1;
					if (m>n) b[m*RelateNumber+n]=1/b[n*RelateNumber+m];
				}


			b_result=GetWeight(b,RelateNumber);//和积法计算判断矩阵权重

			r_max=ComputMaxRoot(b,b_result,RelateNumber);//计算最大特征根

			CR=CheckCR(r_max,RelateNumber);

			if(CR<=0.1)
			{
				printf("CR=%f小于0.1，一致性检验通过，数据已写入文件！\n",CR);

				OutputLayerPar(b,RelateNumber,Relate,layer,j,r_max,CR);//输出判断矩阵

				b_sum=TransWeightArray(b_result,RelateNumber,i,Relate);//转化权重向量

				w=GetPreLayerWeight(preLayerP,j);//获得上层第j元素的权重

				SumWeight(p,b_sum,w);//改变本层元素的权重值

			}

			else 
			{
				printf("CR=%f大于0.1，请重新输入！\n",CR);
				j--;
			}

			delete b;



		}

		layer++;

		OutputWeight(p,layer);
		

		preLayerP=p;

		printf("\n请输入决策图表中第%d层元素个数\n",layer+1);
		
		scanf("%d",&i);
	}

	printf("您输入的个数是0，本程序结束。");
	printf("\n具体各层元素的判断矩阵及一致性分析请查看dat.txt文件\n层次总排序结果请查看out.txt文件。\n");
	printf("输入y结束。");
	while ('y'!=getchar());
}