如何处理菜单函数与模块的关系
#include<stdio.h>#include<stdlib.h>
#include<malloc.h>
#include<conio.h>
#define N 5 //矩阵阶数
#define MAXSIZE 12500
typedef int ElemType;
typedef struct
{
int row,col; //非零元的行下标和列下标
ElemType e; //非零元的值
}Triple;
typedef struct
{
Triple data[MAXSIZE+1]; //非零元三元组表，data[0]未用
int mu,nu,tu; //矩阵行数、列数和非零元个数
}TSMatrix;
//函数声明
void duichenSMatrix();
void Saveto1Darray(int a[], int e, int i, int j);//将e按照在矩阵中相应的位置存储到一维数组中
void printduichenMatrix(int a[],int n);//显示对称矩阵
int Value(int a[], int i, int j);//返回存储在一维数组中对称矩阵的元素
void xishuSMatrix();
int CreateSMatrix(int a[][N],TSMatrix *M); //利用二维数组创建稀疏矩阵
void PrintSMatrix(TSMatrix T); //以三元组形式输出稀疏矩阵
void Print2Darray(TSMatrix T); //以二维数组输出稀疏矩阵
int TransposeMatrix(TSMatrix M, TSMatrix *T); //转置
int FastTransposeSMatrix(TSMatrix M, TSMatrix *T); //快速转置
void SubSMatrix();//矩阵加法运算
void MultSMatrix();//矩阵乘法运算
int getvalue(TSMatrix c,int i,int j);//返回三元组中的值
void end(); //系统退出函数
void menu()//菜单函数
{
int a;
printf(" <矩阵压缩存储系统>\n");
printf("\n********************************系统菜单***********************************\n");
printf("\n1-------------------- 对称矩阵的压缩存储 --------------------\n");
printf("\n2-------------------- 稀疏矩阵的压缩存储 --------------------\n");
printf("\n3-------------------- 矩阵的加法运算 --------------------\n");
printf("\n4-------------------- 矩阵的乘法运算 --------------------\n");
printf("\n5-------------------- 应用程序退出 --------------------\n");
printf("\n请输入您要使用的功能: ");
scanf("%d", &a);
system("cls");
switch(a)
{
case 1:duichenSMatrix();break;
case 2:xishuSMatrix();break;
case 3:SubSMatrix();break;
case 4:MultSMatrix();break;
case 5:end();break;
default:printf("输入无效，请重新输入!");
getch();
system("cls");
menu();
}
}
//对称矩阵的压缩存储
void duichenSMatrix()
{
int *a = NULL; //定义一个指向一维数组的指针
int i,j,e,n;
int choice;
printf("请输入您要创建对称矩阵的阶数：");
scanf("%d",&n);
a = (int *)malloc(sizeof(int) * (n*(n+1)/2));
printf("\n请输入%d阶对称矩阵(只需要输入下三角部分即可)\n",n);
for(i=0;i<n;i++)
{
printf("输入第%d行的%d个数据元素: ", i+1, i+1);
for(j=0; j<=i; j++)
{
scanf("%d", &e);
Saveto1Darray(a, e, i, j);//将输入的数据存储到一维数组中
}
}
printf("对称矩阵为:\n");
printduichenMatrix(a,n);
printf("\n返回菜单请按1，退出程序请按2");
printf("\n请输入：");
scanf("%d", &choice);
if(choice == 1)
{
system("cls");
menu();
}
if(choice == 2)
end();
}
void Saveto1Darray(int a[], int e, int i, int j)//将e按照在矩阵中相应的位置存储到一维数组中
{
if (i>=j)
a[(i*(i+1))/2+j] = e;
else
a[(j*(j+1))/2+i] = e;
}
void printduichenMatrix(int a[],int n)//显示对称矩阵
{
int i,j;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
printf("%4d",Value(a,i,j));
printf("\n");
}
}
int Value(int a[], int i, int j)//返回存储在一维数组中对称矩阵的元素
{
if (i>=j)
return a[(i*(i+1))/2+j];
else
return a[(j*(j+1))/2+i];
}
//稀疏矩阵的压缩存储
void xishuSMatrix()
{
int choice;
TSMatrix M,T1,T2;
int a[N][N] = {
{4,9,0,0,0},
{0,0,6,0,0},
{0,0,0,2,0},
{0,5,0,0,0},
{0,0,0,7,0}};
CreateSMatrix(a,&M);//创建稀疏矩阵M
printf("初始化一个稀疏矩阵(二维数组形式)\n");
Print2Darray(M);//以二维数组形式输出稀疏矩阵M
printf("原稀疏矩阵(三元组形式)\n");
PrintSMatrix(M);//以三元组形式输出稀疏矩阵M
printf("\n普通转置请按1，快速转置请按2");
printf("\n请输入：");
scanf("%d",&choice);
if(choice==1)
{
TransposeMatrix(M,&T1);
printf("普通转置后的稀疏矩阵(三元组形式)为：\n");
PrintSMatrix(T1);//以三元组形式输出转置后的稀疏矩阵T1
printf("普通转置后的稀疏矩阵(二维数组形式)为：\n");
Print2Darray(T1);//以二维数组形式输出转置后的稀疏矩阵T1
}
if(choice==2)
{
FastTransposeSMatrix(M,&T2);
printf("快速转置后的稀疏矩阵(三元组形式)为：\n");
PrintSMatrix(T2);//以三元组形式输出快速转置后的稀疏矩阵T2
printf("快速转置后的稀疏矩阵(二维数组形式)为：\n");
Print2Darray(T2);//以二维数组形式输出快速转置后的稀疏矩阵T2
}
printf("\n返回菜单请按1，退出程序请按2");
printf("\n请输入：");
scanf("%d", &choice);
if (choice == 1)
{
system("cls");
menu();
}
if (choice == 2)
{
end();
}
}
int CreateSMatrix(int a[][N],TSMatrix *M) //利用二维数组创建稀疏矩阵
{
int pos,i,j;
M->mu = M->nu = 5;
M->tu=0;
pos=1;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
if(a[i][j]!=0)
{
M->data[pos].row=i+1;
M->data[pos].col=j+1;
M->data[pos].e=a[i][j];
pos++;
M->tu++;
}
return 0;
}
void PrintSMatrix(TSMatrix T)//以三元组形式输出稀疏矩阵
{
int i;
printf("row col value\n");
for(i = 1; i <= T.tu; i++)
{
printf("%2d", T.data[i].row);
printf("%7d", T.data[i].col);
printf("%7d", T.data[i].e);
printf("\n");
}
}
int TransposeMatrix(TSMatrix M, TSMatrix *T) //转置
{
int i,p,q;
T->mu = M.mu;
T->nu = M.nu;
T->tu = M.tu;
if(T->tu)
{
q=1;
for(i=1;i<=M.nu;++i)
for(p=1;p<=M.tu;++p)
if(M.data[p].col==i)
{
T->data[q].row = M.data[p].col;
T->data[q].col = M.data[p].row;
T->data[q].e = M.data[p].e;
++q;
}
}
return 0;
}
int FastTransposeSMatrix(TSMatrix M, TSMatrix *T) //快速转置
{
int i,p,q,t;
int num[N],cpot[N*N];//num存储M中每一列含非零元的个数，cpot存储每一列第一个非零元在data中的序号
T->mu = M.mu;
T->nu = M.nu;
T->tu = M.tu;
if(T->tu)
{
for(i=1;i<=M.nu;++i)
num[i]=0;
for(t=1;t<=M.tu;++t)
++num[M.data[t].col];
cpot[1]=1;
for(i=2;i<=M.nu;++i)
cpot[i]=cpot[i-1]+num[i-1];
for(p=1;p<=M.tu;++p)
{
i=M.data[p].col;
q=cpot[i];
T->data[q].row=M.data[p].col;
T->data[q].col=M.data[p].row;
T->data[q].e=M.data[p].e;
++cpot[i];
}
}
return 0;
}
void Print2Darray(TSMatrix T)//以二维数组形式输出稀疏矩阵
{
int i,j,pos,a[N][N];
for(i=0;i<N;i++)
for(j=0;j<N;j++)
{
a[i][j]=0;
for(pos=1;pos<=T.tu;pos++)
{
if(i==T.data[pos].row-1 && j==T.data[pos].col-1)
a[i][j]=T.data[pos].e;
}
}
for(i=0;i<N;i++)
for(j=0;j<N;j++)
{
printf("%3d",a[i][j]);
if(j==N-1)
printf("\n");
}
}
void SubSMatrix()//矩阵加法运算
{
int choice;
int g,m,t,k;//g、m、t分别记录三个矩阵的元素的存储位置
TSMatrix a,b,c;
int A1[N][N] = {
{4,9,0,0,0},
{0,0,6,0,0},
{0,0,0,2,0},
{0,5,0,0,0},
{2,0,0,7,0}};
int A2[N][N] = {
{4,0,1,0,0},
{0,6,0,0,0},
{0,0,0,2,0},
{0,5,0,1,0},
{0,0,3,0,0}};
CreateSMatrix(A1,&a);//利用A1数组创建稀疏矩阵a
CreateSMatrix(A2,&b);//利用A2数组创建稀疏矩阵b
printf("先初始化两个稀疏矩阵a、b\n");
printf("矩阵a为：\n");
Print2Darray(a);
printf("矩阵b为：\n");
Print2Darray(b);
c.mu=a.mu;
c.nu=a.nu;
c.tu=0;
g=m=t=1;//从data[1]开始
for(k=1;k<=a.mu;k++)//将行下标和列下标相等的元素直接相加
{
if(a.data[m].row==k && b.data[t].row==k)//行下标相等时
{
if(a.data[m].col==b.data[t].col)//列下表相等时
{
c.data[g].row=k;
c.data[g].col=a.data[m].col;
c.data[g].e=a.data[m].e+b.data[t].e;
c.tu++;
g++;
m++;
t++;
}
}
//将行下标和列下标不等的元素直接插入到c的相应位置
while(a.data[m].row==k)//插入矩阵a中剩余的元素
{
c.data[g].row=k;
c.data[g].col=a.data[m].col;
c.data[g].e=a.data[m].e;
c.tu++;
m++;
g++;
}
while(b.data[t].row==k)//插入矩阵b中剩余的元素
{
c.data[g].row=k;
c.data[g].col=b.data[t].col;
c.data[g].e=b.data[t].e;
c.tu++;
t++;
g++;
}
}
printf("a+b(二维数组形式):\n");
Print2Darray(c);
printf("a+b(三元组形式):\n");
PrintSMatrix(c);
printf("\n返回菜单请按1，退出程序请按2");
printf("\n请输入：");
scanf("%d", &choice);
if(choice == 1)
{
system("cls");
menu();
}
if(choice == 2)
end();
}
void MultSMatrix()//矩阵乘法运算
{
int choice;
TSMatrix a,b,c;
int i,j,k,p=1,s;
int A1[N][N] = {
{4,9,0,0,0},
{0,0,6,0,0},
{0,0,0,2,0},
{0,5,0,0,0},
{2,0,0,7,0}};
int A2[N][N] = {
{4,0,1,0,0},
{0,6,0,0,0},
{0,0,0,2,0},
{0,5,0,1,0},
{0,0,3,0,0}};
CreateSMatrix(A1,&a);//利用A1数组创建稀疏矩阵a
CreateSMatrix(A2,&b);//利用A2数组创建稀疏矩阵b
printf("先初始化两个稀疏矩阵\n");
printf("矩阵a为：\n");
Print2Darray(a);
printf("矩阵b为：\n");
Print2Darray(b);
for(i=1; i<=a.mu; i++)
for(j=1; j<=b.nu; j++)
{
s=0;
for(k=1; k<=a.nu; k++)
s+=getvalue(a,i,k)*getvalue(b,k,j);
if(s!=0)
{
c.data[p].row=i;
c.data[p].col=j;
c.data[p].e=s;
p++;
}
}
c.mu=a.mu;
c.nu=b.nu;
c.tu=p-1;
printf("a*b(二维数组形式):\n");
Print2Darray(c);
printf("a*b(三元组形式):\n");
PrintSMatrix(c);
printf("\n返回菜单请按1，退出程序请按2");
printf("\n请输入：");
scanf("%d", &choice);
if(choice == 1)
{
system("cls");
menu();
}
if(choice == 2)
end();
}
int getvalue(TSMatrix c,int i,int j)//返回三元组中的值
{
int k=1;
while(k<=c.tu&&(c.data[k].row!=i||c.data[k].col!=j))
k++;
if(k<=c.tu)
return c.data[k].e;
else
return 0;
}
void end() //系统退出函数
{
char choice, ch;
ch = getchar();
printf("\n\n\n\n\n\n\n\t\t\t确定退出系统?\n\n\n\t\t\t确定按'y',其他则返回主菜单: ");
scanf("%c", &choice);
if(choice == 'Y' || choice == 'y')
{
system("cls");
printf("\n\n\n\n\n\n\n 感谢您的使用!!!");
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf(" ");
}
else
{
system("cls");
menu();
}
}
int main()
{
system("color 0F"); //调整控制台颜色
printf("\n\n\n\n\n\n\n\n\n\n\n\n");
printf(" ");
printf("欢迎使用矩阵压缩存储系统！");
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf(" ");
system("pause");
system("cls");
menu();
return 0;
}
