数组-稀疏矩阵的基本操作（C语言）

编译器：VS Code
语言：C语言

数组

稀疏矩阵

稀疏矩阵的基本操作主要有：创建稀疏矩阵、还原稀疏矩阵、复制稀疏矩阵、销毁稀疏矩阵、稀疏矩阵的转置、相加。。。

代码

#include
#include
#define maxsize 100
//Ternary structure
typedef struct {
    int i,j; //row,colums
    int v;   //non-zero element values
}ternary;    //ternary
//sparse matrix structure
typedef struct{
    ternary data[maxsize];
    int row,col,t;  
    int elem[maxsize][maxsize];
}matrix; 

//创建三元组
int create_sparse_matrix(matrix &a,char string[])
{
    int row,col,value;
    int k=0;
    printf("请输入 %s 矩阵的行数，列数，非零元个数:",string);
    scanf("%d %d %d",&a.row,&a.col,&a.t);
    printf("%d %d %d\n",a.row,a.col,a.t);
    //按行输入
    for(int i=1;i<=a.t;i++){  //非零元个数
        do{
            printf("请按行序输入第 %d 个非零元素的行( 1 ～ %d ),列 ( 1 ～ %d ),元素值\n",i,a.row,a.col);
            scanf("%d %d %d",&row,&col,&value);  
            if(row<1 || row>a.row ||col<1||col>a.col){  //行列的合法性
                printf("输入错误，请重新输入\n");
                k=1;
            }
            else{
                k=0;
            }
        }
        while(k);
        //将非零元存入三元组
        a.data[i].i=row;  //行下标
        a.data[i].j=col;  //列下标
        a.data[i].v=value;//下标的元素值
        a.elem[row][col]=value;
    }
    return true;
}
//打印
int print(matrix c)
{
    printf(" %d 行, %d 列， %d 个非零元素。\n",c.row,c.col,c.t);
    printf("=========================\n");
	printf("%4s %4s %8s\n", "i", "j", "v");
	printf("=========================\n");
    for(int i=1;i<=c.t;i++){
        printf("%4d %4d %8d\n",c.data[i].i,c.data[i].j,c.data[i].v);
    }
    printf("=========================\n");
    return true;
}
//销毁三元组,所有元素置空
int destroy(matrix &a)
{
    a.row=0;
    a.col=0;
    a.t=0;
    return false;
}
//复制三元组
int cp(matrix a,matrix &b)
{   
    printf("=======矩阵复制==========\n");
    b=a;
    return true;
}
//还原稀疏矩阵
int reduction(matrix a)
{
    printf("=======稀疏矩阵==========\n");
    for(int i=1;i<=a.row;i++){
        for(int j=1;j<=a.col;j++){
            if(a.elem[i][j]!=0 && a.elem[i][j]!=0){
                printf("%3d",a.elem[i][j]);
            }
            else{
                printf("%3d",0);
            }
        }
        printf("\n");
    }
    return true;
}
//稀疏矩阵的转置
int transpose(matrix a,matrix &at)
{
    printf("=======矩阵转置==========\n");
    int q=1;  
    at.row=a.col,at.col=a.row,at.t=a.t;  //行变为列，列变为行
    for(int row=1;row<a.row;row++){      //行
        for(int p=1;p<=a.t;p++){    //非零元个数
            if(a.data[p].j==row){   //按顺序,所以用row不用a.data[p].i
                at.data[q].i=a.data[q].j;
                at.data[q].j=a.data[q].i;
                at.data[q].v=a.data[q].v;          
                q++;
            }
        }
    }
    return true;
}
//加法:sm=a+b
/*
行列不相同，按行排序
行列相同，行列不变，数值相加。
*/
int sum(matrix a,matrix c,matrix &sm)
{
    int i=1,j=1,k=1;
    sm.row=a.row;
    sm.col=a.col;
    sm.t=a.t+c.t;
    while(i<=a.t && j<=c.t){   //i是a的非零元个数，j是c的非零元个数
        if(a.data[i].i<c.data[j].i){   //a行号
            sm.data[k].i=a.data[i].i;  //行
            sm.data[k].j=a.data[i].j;  //列
            sm.data[k].v=a.data[i].v;  //数值
            i++;
        }
        else if(a.data[i].i>c.data[j].i){   //a行号>c行号
            sm.data[k].i=c.data[j].i;  //行
            sm.data[k].j=c.data[j].j;  //列
            sm.data[k].v=c.data[j].v;  //数值
            j++;
        }
        else if(a.data[i].i==c.data[j].i){  //行号相同
            if(a.data[i].j==c.data[j].j){   //比较列号
                sm.data[k].i=a.data[i].i;  //行
                sm.data[k].j=a.data[i].j;  //列
                sm.data[k].v=a.data[i].v+c.data[j].v;  //数值相同相加
                i++;
                j++;
            }
            if(a.data[i].j<c.data[j].j){   //比较列号
                sm.data[k].i=a.data[i].i;  //行
                sm.data[k].j=a.data[i].j;  //列
                sm.data[k].v=a.data[i].v;  //数值
                i++;
            }
            if(a.data[i].j>c.data[j].j){   //比较列号
                sm.data[k].i=c.data[j].i;  //行
                sm.data[k].j=c.data[j].j;  //列
                sm.data[k].v=c.data[j].v;  //数值
                j++;
            }
        } 
        k++;
    } 
    while(i<=a.t){        //稀疏矩阵a>c
        sm.data[k].i=a.data[i].i;  //行
        sm.data[k].j=a.data[i].j;  //列
        sm.data[k].v=a.data[i].v;  //数值
        i++;    
        k++;
    }
    while(j<=c.t){   //稀疏矩阵a
        sm.data[k].i=c.data[j].i;  //行
        sm.data[k].j=c.data[j].j;  //列
        sm.data[k].v=c.data[j].v;  //数值
        j++;
        k++;
    }
    return true; 
}
//乘法

int main()
{
    matrix a,b,at,c,sm;
    char A[]="a",C[]="c";
    create_sparse_matrix(a,A); //创建三元组
    print(a);  
    create_sparse_matrix(c,C);
    print(c);
    int expression;
    printf("1.还原稀疏矩阵\n2.复制稀疏矩阵\n3.销毁稀疏矩阵\n4.稀疏矩阵的转置\n5.稀疏矩阵a+c相加\n");
    scanf("%d",&expression);
    switch (expression)
    {
    case 1:{
        reduction(a);      //还原稀疏矩阵
        break;
    }
    case 2:{
        cp(a,b);                 //复制三元组
        print(b);
        break;
    }
    case 3:{
        destroy(a);
        print(a);    
        break;
    }
    case 4:{
        transpose(a,at);         //稀疏矩阵的转置
        print(at);
        break; 
    }
    case 5:{
        sum(a,c,sm);         //稀疏矩阵的相加
        print(sm);
        break; 
    }
    default:
        break;
    }
    
}

结果