reddragonjuzhen.c

矩阵计算 算术游戏里用了多个 goto 语句

#include<stdio.h>

#define MAX_LINE 10
#define MAX_ROW 10

//定义最大行列数
//以下矩阵均指实型二维数组

int g_flag;
float g_temp_a[MAX_ROW], g_temp;

/*
函数功能：输入一个矩阵，输入错误时报错
函数参数；待输入实型矩阵array，array的行列数i，j
返回值：0，表示输入错误；1，表示正确输入
*/
int Input(float array[][MAX_ROW], int i, int j)
{
	int x, y;

	if(i<1||j<1||i>MAX_LINE||j>MAX_ROW)
	{
		printf("输入错误！\n");
		return 0;
	}
	else
	{
	    for(x=0;x<i;x++)
		{
		    for(y=0;y<j;y++)
			{
				if(scanf("%f", &array[x][y])!=1)
				{
					printf("输入错误！\n");
					while(getchar()!='\n')
						;
					return 0;
				}
			}
		}
	    return 1;
	}
}

/*
函数功能：输出一个实型矩阵，各元素保留3位小数
函数参数：矩阵array，array的行列数i，j
返回值：无
*/
void Output(float array[][MAX_ROW],int i,int j)
{
	int x, y;

	for(x=0;x<i;x++)
	{
		for(y=0;y<j;y++)
		{
			printf("%-8.3f", array[x][y]);
		}
		printf("\n");
	}
}  

/*
函数功能：进行矩阵A与B的线性运算，当运算条件不满足时报错
函数参数：矩阵A，A的系数、行列数p,m，n；矩阵B，的系数、行列数q,i，j；实型矩阵C，用于存储结果（系数为实型）
返回值：0，表示运算条件不满足；1，表示运算成功
*/
int Xian_xing_c(float A[][MAX_ROW], float p, int m, int n, float B[][MAX_ROW], float q, int i, int j, float C[][MAX_ROW])
{
	int x, y;

	if(m!=i||n!=j)
	{
		printf("不能计算！\n");
		return 0;
	}
	else
	{
		for(x=0;x<m;x++)
		{
			for(y=0;y<n;y++)
			{
				C[x][y]=p*A[x][y]+q*B[x][y];
			}
		}
		return 1;
	}
}

/* 
函数功能：实现线性运算功能全过程
函数参数：无
返回值：无
*/
void Xian_xing(void)
{
	float A[MAX_LINE][MAX_ROW], B[MAX_LINE][MAX_ROW], C[MAX_LINE][MAX_ROW], p, q;
	int m, n, i, j, error=1;

	printf("\n这个程序将帮助您计算pA+qB的值！\n");

	while(1)
	{
		printf("\n请输入A的系数P:");
		if(scanf("%f", &p)==1)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	while(1)
	{
		printf("请输入矩阵A的行列数m，n：");
		if(scanf("%d%d", &m,&n)==2)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, n);
	if(error==0)
	{
		goto end;
	}
	while(1)
	{
		printf("\n请输入B的系数q:");
		if(scanf("%f", &q)==1)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	if(q==0)
	{
		int x, y;
		i=m,j =n;

		for(x=0;x<i;x++)
		{
			for(y=0;y<j;y++)
			{
				B[x][y]=0;
			}
		}
	}
	else
	{
		while(1)
		{
			printf("请输入矩阵B的行列数i，j:");
	    		if(scanf("%d%d", &i, &j)==2)
				break;
			else
			{
				printf("输入错误！\n");
				while(getchar()!='\n')
					;
			}
		}
	    	printf("请按矩阵格式输入矩阵B（略括号）:\n");
	    	error=Input(B, i, j);
		if(error==0)
		{
		    goto end;
		}
	}
	error=Xian_xing_c(A, p, m, n, B, q, i, j, C);
	if(error==0)
	{
		goto end;
	}
	printf("\npA+qB为：\n");
	Output(C, m, n);
end:;
}

/*
函数功能：计算矩阵A与B之积AB
函数参数：矩阵A，A的行列数m，n；矩阵B，的行列数i，j；实型矩阵C，用于存储AB
返回值：0，表示运算条件不满足；1，表示运算成功
*/
int Chen_ji_c(float A[][MAX_ROW], int m, int n, float B[][MAX_ROW], int i, int j, float C[][MAX_ROW])
{
	int x, y, z;  //x为A的行标，y为B的列标，z为的A列标和B的行标
	float sum;

	if(m<1||n<1||i<1||j<1||n!=i)
	{
		printf("输入错误！\n");
		return 0;
	}
	else
	{
		for(x=0;x<m;x++)
		{
			for(y=0;y<j;y++)
			{
				sum=0;
				for(z=0;z<i;z++)
				{
					sum+=A[x][z]*B[z][y];
				}
				C[x][y]=sum;
			}
		}
		return 1;
	}
}

/* 
函数功能：实现矩阵乘积功能全过程
函数参数：无
返回值：无
*/
void Cheng_ji(void)
{
	float A[MAX_LINE][MAX_ROW], B[MAX_LINE][MAX_ROW], C[MAX_LINE][MAX_ROW];
	int m, n, i, j, error=1;

	printf("\n这个程序将帮助您计算两个矩阵A和B的乘积AB!\n");

	while(1)
	{
		printf("\n请输入矩阵A的行列数m，n：");
		if(scanf("%d%d", &m, &n)==2)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, n);
	if(error==0)
	{
		goto end;
	}
	while(1)
	{
		printf("\n请输入矩阵B的行列数i，j:");
		if(scanf("%d%d", &i, &j)==2)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵B（略括号）:\n");
	error=Input(B, i, j);
	if(error==0)
	{
		goto end;
	}
	error=Chen_ji_c(A, m, n, B, i, j, C);
	if(error==0)
	{
		goto end;
	}
	printf("\n矩阵A和B的乘积AB为：\n");
	Output(C, m, j);
end:;
}

/*
函数功能：计算矩阵A的转置矩阵B
函数参数：矩阵A，A的行列数m，n；矩阵B，用于存储结果
返回值：无
*/
void Zhuan_zhi_c(float A[][MAX_ROW], int i, int j, float B[][MAX_ROW])
{
	int x, y;

	for(x=0;x<i;x++)
	{
		for(y=0;y<j;y++)
		{
			B[y][x]=A[x][y];
		}
	}
}

/* 
函数功能：实现矩阵乘积功能全过程
函数参数：无
返回值：无
*/
void Zhuan_zhi(void)
{
	float A[MAX_LINE][MAX_ROW], B[MAX_LINE][MAX_ROW];
	int i, j, error=1;

	printf("\n这个程序将帮助您计算两个矩阵A的转置矩阵B!\n");

	while(1)
	{
		printf("\n请输入矩阵A的行列数m，n：");
		if(scanf("%d%d", &i, &j)==2)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, i, j);
	if(error==0)
	{
		goto end;
	}
	else
	{
		Zhuan_zhi_c(A, i, j, B);
		printf("\n矩阵A的转置矩阵B为：\n");
		Output(B, j,i);
	}
end:	;
}

int Qiu_ni_c(float A[][MAX_ROW], int m, float B[][MAX_ROW])
{
	int i, j, k, l;
	float temp_a[MAX_ROW], temp;

	for(i=0;i<m;i++)
	{
		for(j=0;j<m;j++)
		{
			if(i==j)
			{
				B[i][j]=1;
			}
			else
			{
				B[i][j]=0;
			}
		}
	}
	
	for(k=0;k<m;k++)
	{
		for(i=k;i<m;i++)
		{
			if(A[i][k]!=0)
				break;
		}
		if(i==m)
		{
			return 0;
		}
		else
		{
			for(j=0;j<m;j++)
			{
				temp_a[j]=A[i][j];
				A[i][j]=A[k][j];
				A[k][j]=temp_a[j];
				
				temp_a[j]=B[i][j];
				B[i][j]=B[k][j];
				B[k][j]=temp_a[j];
			}
			temp=A[k][k];
			for(j=0;j<m;j++)
			{
				B[k][j]/=temp;
				A[k][j]/=temp;
			}
			for(i=k+1;i<m;i++)
			{
				if(A[i][k]!=0)
				{
					temp=A[i][k];
					for(l=0;l<m;l++)
					{
						B[i][l]-=(temp*B[k][l]);
						A[i][l]-=(temp*A[k][l]);
					}
				}
			}
		}
	}
	for(k=0;k<m-1;k++)
	{
		for(i=k+1;i<m;i++)
		{
			if(A[k][i]!=0)
			{
				temp=A[k][i];
				for(j=0;j<m;j++)
				{
					B[k][j]-=(temp*B[i][j]);
					A[k][j]-=(temp*A[i][j]);
				}
			}
		}
	}
	return 1;
}
			
			


/*
函数功能：实现矩阵求逆的全过程
函数参数：无
返回值：无
*/
void Qiu_ni(void)
{
	float A[MAX_LINE][MAX_ROW], B[MAX_LINE][MAX_ROW];
	int m, error=1, flag;

	printf("\n这个程序将帮助您计算矩阵A的逆矩阵!\n");
	
	while(1)
	{
		printf("请输入A的阶数：");
		if(scanf("%d",&m)==1)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, m);
	if(error==0)
	{
		goto end;
	}
	else
	{
		flag=Qiu_ni_c(A, m, B);
		if(flag==0)
		{
			printf("A的逆不存在！\n");
		}
		else
		{
			printf("A的逆矩阵B为：\n");
			Output(B, m, m);
		}
	}
end:	;
}

float Hang_lie_shi_c(float (*p)[MAX_ROW], int m)
{
	float times;
	int i, j, k;

	int flag=1;

	if(m==1)
	{
		return p[0][0];
	}
	else
	{
		for(i=0;i<m;i++)
		{
			if(p[i][0]!=0)
				break;
		}
		if(i==m)
		{
			return 0;
		}
		else
		{
			if(i!=0)
			{
				flag=-flag;

				for(j=0;j<m;j++)
				{
					g_temp_a[j]=p[i][j];
					p[i][j]=p[0][j];
					p[0][j]=g_temp_a[j];
				}
			}
			times=p[0][0];
			for(j=0;j<m;j++)
			{
				p[0][j]/=times;
			}
			for(j=1;j<m;j++)
			{
				if(p[j][0]!=0)
				{
					g_temp=p[j][0];
					for(k=0;k<m;k++)
					{
						p[j][k]-=g_temp*p[0][k];
					}
				}
			}
		}
		return flag*times*Hang_lie_shi_c((float(*)[10])&p[1][1], m-1);
	}
}
						

		
		
	

void Hang_lie_shi(void)
{
	float A[MAX_LINE][MAX_ROW], result;
	int m, error=1;

	printf("\n这个程序将帮助您计算矩阵A的行列式!\n");

	while(1)
	{
		printf("请输入A的阶数：");
		if(scanf("%d",&m)==1)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, m);
	if(error==0)
	{
		goto end;
	}
	else
	{
		result=Hang_lie_shi_c(A, m);
		printf("A的行列式为： %.3f\n",result);
	}
end:	;
}

void Ban_sui_c(float A[][MAX_ROW],int m,float B[][MAX_ROW])
{
	float temp[MAX_LINE][MAX_ROW];
	int i, j, k, l, a, b;

	for(i=0;i<m;i++)
	{
		for(j=0;j<m;j++)
		{
			for(k=0,a=0;k<m;k++,a++)
			{
				if(k!=i)
				{
					for(l=0,b=0;l<m;l++,b++)
					{
						if(l!=j)
							temp[a][b]=A[k][l];
						else
							b--;
					}
				}
				else
					a--;
			}
			if((i+j)%2)
				B[j][i]=-1*Hang_lie_shi_c(temp, m-1);
			else
				B[j][i]=Hang_lie_shi_c(temp, m-1);
		}
	}
}
			
							
			
		

void Ban_sui(void)
{
	float A[MAX_LINE][MAX_ROW], B[MAX_LINE][MAX_ROW];
	int m, error=1;

	printf("\n这个程序将帮助您计算矩阵A的伴随矩阵B!\n");

	while(1)
	{
		printf("请输入A的阶数：");
		if(scanf("%d",&m)==1)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, m);
	if(error==0)
	{
		goto end;
	}
	else
	{
		Ban_sui_c(A, m, B);
		printf("A的伴随矩阵B为:\n");
		Output(B, m, m);
	}
end:	;
}

int Qiu_zhi_c(float array[][MAX_ROW], int m, int n)
{
	int i, j, k, l, a=-1;
	float temp, temp_a[MAX_ROW];

	for(i=0;i<m;i++)
	{
		for(j=a+1;j<m;j++)
		{
			if(array[j][i]!=0)
				break;
		}
		if(j<m)
		{
			a++;
			for(k=0;k<m;k++)
			{
				temp_a[k]=array[j][k];
				array[j][k]=array[a][k];
				array[a][k]=temp_a[k];
			}
			temp=array[a][i];
			for(k=0;k<m;k++)
			{
				array[a][k]/=temp;
			}
			for(k=a+1;k<m;k++)
			{
				if(array[k][i]!=0)
				{
					temp=array[k][i];
					for(l=i;l<m;l++)
					{
						array[k][l]-=temp*array[a][l];
					}
				}
			}
		}
	}
	return a+1;
}
void Qiu_zhi(void)
{
	float A[MAX_LINE][MAX_ROW];
	int m, n, error=1, result;
	
	printf("\n这个程序将帮助您计算矩阵A的秩!\n");

	while(1)
	{
		printf("\n请输入矩阵A的行列数m，n：");
		if(scanf("%d%d", &m, &n)==2)
			break;
		else
		{
			printf("输入错误！\n");
			while(getchar()!='\n')
				;
		}
	}
	printf("请按矩阵格式输入矩阵A（略括号）:\n");
	error=Input(A, m, n);
	if(error==0)
	{
		goto end;
	}
	else
	{
		result=Qiu_zhi_c(A, m, n);
		printf("矩阵A的秩为：%d\n",result);
	}
end:	;
}

void main(void)
{
	int m,flag=1;

	printf("\n\n-------------欢迎使用 Red Dragon 矩阵精灵！--------------\n\n");

	while(flag)
	{
		printf("\n1 线形运算\n2 求两矩阵之积\n3 求转置矩阵\n4 求逆矩阵\n5 求行列式\n6 求伴随矩阵\n7 求矩阵的秩\n8 退出\n");
		while(1)
		{
			printf("请选择：");
			if(scanf("%d",&m)!=NULL)
				break;
			else
			{
				printf("输入错误！\n");
				while(getchar()!='\n')
					;
			}
		}

		switch(m)
		{
		case 1:
			Xian_xing();
			break;
		case 2:
			Cheng_ji();
			break;
		case 3:
			Zhuan_zhi();
			break;
		case 4:
			Qiu_ni();
			break;
		case 5:
			Hang_lie_shi();
			break;
		case 6:
			Ban_sui();
			break;
		case 7:
			Qiu_zhi();
			break;
		case 8:
			flag=0;
			break;
		default:
			printf("输入错误！\n");
		}
	}
	printf("\n\n-------------- 已退出 Red Dragon 矩阵精灵 ---------------\n");
}