关于#矩阵#的问题，如何解决？

问题：已知两个稀疏矩阵A和B，其行数和列数均对应相等，编写一个程序，计算A和B之和，假设稀疏矩阵采用三元组表示。
测试用例：输入：1,1,2;2,1,3↵1,2,5;2,1,-3↵
输出：1,1,2;1,2,5↵
我的代码：

##define MAX 100
#define ERROR 0
#define ok 1
#include

typedef struct {
    int row,col;
    int item;
}Triple;
typedef struct{
    Triple data[MAX];
    int mu,nu,num;//行数，列数，非零元数 
}TripleMatrix;

int getitem(int row,int col){
    if(row>mu||col>nu) return 0;
    for(int i=0;i//遍历
        if(data[i].row==row&&data[i].col==col){
            return data[i].item;
        } 
    }
    return 0;
}

void setitem(int row,int col,int item){
    if(row>mu||col>nu) return ERROR;
    if(num==MAX) return ERROR;
    if(item==0) return OK:
        //利用wile找正确位置
        int index=0;
        while(indexif(row>data[index].row){
                index++;
            }
            else if(row==data[index].row&&(col>data[index].col)){
                index++;
            }
            else{
                break;
            }
         } 
         if((row==data[index].row&&)&&(col==data[index].col)){
             //当前行列元素已存在 ，将新数据 替换之
             data[index].item=item; 
         }
         else{
             //插入，后续元素都向后移动一个单元
             for(int i=num;i>index;i--){
                 data[i].row=data[i-1].row;
                 data[i].col=data[i-1].col;
                 data[i].item=data[i-1].item;
             } 
             data[index].row=row;
             data[index].col=col;
             data[index].item=item;
             num++;
         }
         return OK;
}

int matrixAdd(TripleMatrix a,TripleMatrix b,TripleMatrix &result){
    if(a.mu!=b.mu||b.mu!=result.mu||a.nu!=b.nu||b.nu!=result.nu)
    return -1;
    else{
        for(int i=1;i<=a.mu;i++){
            for(int j=1;j<=a.nu;j++){
                int item=a.getitem(i,j)+b.getitem(i,j);
                if(item!=0)
                {
                    result.setitem(i,j,item);
                }
            }
        }
        return OK;
    }
} 
void TripleMatrix(){
    for(int i=0;iprintf("%d,%d,%d;",data[i].row,data[i].col,data[i].item);
    }
}
int main(){
    TripleMatrix a,b,result;
    int num=2;
    scanf("%d,%d,%d;%d,%d,%d\n",a.data[1].row,a.data[1].col,a.data[1].item,a.data[2].row,a.data[2].col,a.data[2].item);
    scanf("%d,%d,%d;%d,%d,%d\n",b.data[1].row,b.data[1].col,b.data[1].item,b.data[2].row,b.data[2].col,b.data[2].item);
    matrix(a,b,&result);
    TripleMatrix(result);
    return 0;
} 

程序改错，谢谢

该回答引用ChatGPT：

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

typedef struct
{
    int row; // 行号
    int col; // 列号
    int value; // 元素值
} Triple;

typedef struct
{
    Triple *data; // 三元组表
    int rows; // 行数
    int cols; // 列数
    int nums; // 非零元素个数
} SparseMatrix;

// 创建稀疏矩阵
SparseMatrix* createSparseMatrix(int rows, int cols, int nums)
{
    SparseMatrix *matrix = (SparseMatrix*)malloc(sizeof(SparseMatrix));
    matrix->rows = rows;
    matrix->cols = cols;
    matrix->nums = nums;
    matrix->data = (Triple*)malloc(sizeof(Triple) * nums);
    return matrix;
}

// 释放稀疏矩阵
void freeSparseMatrix(SparseMatrix *matrix)
{
    free(matrix->data);
    free(matrix);
}

// 读取稀疏矩阵
SparseMatrix* readSparseMatrix()
{
    int rows, cols, nums;
    scanf("%d,%d,%d", &rows, &cols, &nums);
    SparseMatrix *matrix = createSparseMatrix(rows, cols, nums);
    for (int i = 0; i < nums; i++)
    {
        scanf("%d,%d,%d", &matrix->data[i].row, &matrix->data[i].col, &matrix->data[i].value);
    }
    return matrix;
}

// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix *matrix)
{
    for (int i = 0; i < matrix->nums; i++)
    {
        printf("%d,%d,%d;", matrix->data[i].row, matrix->data[i].col, matrix->data[i].value);
    }
    printf("\n");
}

// 计算两个稀疏矩阵的和
SparseMatrix* addSparseMatrix(SparseMatrix *matrixA, SparseMatrix *matrixB)
{
    if (matrixA->rows != matrixB->rows || matrixA->cols != matrixB->cols)
    {
        printf("Error: the size of matrixA and matrixB must be equal!\
}
SparseMatrix *matrixC = createSparseMatrix(matrixA->rows, matrixA->cols, 0);
int i = 0, j = 0, k = 0;
while (i < matrixA->nums && j < matrixB->nums)
{
    if (matrixA->data[i].row < matrixB->data[j].row ||
        (matrixA->data[i].row == matrixB->data[j].row && matrixA->data[i].col < matrixB->data[j].col))
    {
        matrixC->data[k].row = matrixA->data[i].row;
        matrixC->data[k].col = matrixA->data[i].col;
        matrixC->data[k].value = matrixA->data[i].value;
        i++;
    }
    else if (matrixA->data[i].row > matrixB->data[j].row ||
             (matrixA->data[i].row == matrixB->data[j].row && matrixA->data[i].col > matrixB->data[j].col))
    {
        matrixC->data[k].row = matrixB->data[j].row;
        matrixC->data[k].col = matrixB->data[j].col;
        matrixC->data[k].value = matrixB->data[j].value;
        j++;
    }
    else
    {
        matrixC->data[k].row = matrixA->data[i].row;
        matrixC->data[k].col = matrixA->data[i].col;
        matrixC->data[k].value = matrixA->data[i].value + matrixB->data[j].value;
        i++;
        j++;
    }
    k++;
}
while (i < matrixA->nums)
{
    matrixC->data[k].row = matrixA->data[i].row;
    matrixC->data[k].col = matrixA->data[i].col;
    matrixC->data[k].value = matrixA->data[i].value;
    i++;
    k++;
}
while (j < matrixB->nums)
{
    matrixC->data[k].row = matrixB->data[j].row;
    matrixC->data[k].col = matrixB->data[j].col;
    matrixC->data[k].value = matrixB->data[j].value;
    j++;
    k++;
}
matrixC->
nums = k;
matrixC->nums = nums;
return matrixC;
}

int main() { // 读取稀疏矩阵A和B SparseMatrix *matrixA = readSparseMatrix(); SparseMatrix *matrixB = readSparseMatrix(); // 计算稀疏矩阵A和B的和 SparseMatrix *matrixC = addSparseMatrix(matrixA, matrixB); // 输出稀疏矩阵C printSparseMatrix(matrixC); // 释放稀疏矩阵 freeSparseMatrix(matrixA); freeSparseMatrix(matrixB); freeSparseMatrix(matrixC); return 0; }

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7611880
• 除此之外, 这篇博客: 对称矩阵、对角矩阵、稀疏矩阵等特殊矩阵的压缩存储方式中的 稀疏矩阵A、B均采用三元组顺序表表示，验证实现矩阵A快速转置算法，并设计、验证矩阵A、B相加得到矩阵C的算法。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
  

  1. 从键盘输入矩阵的行数和列数，随机生成稀疏矩阵。
  2. 设计算法将随机生成的稀疏矩阵转换成三元组顺序表形式存储。
  3. 设计算法将快速装置得到的与相加得到的三元组顺序表分别转换成矩阵形式。
  4. 输出随机生成的稀疏矩阵A、B及其三元组顺序表表示、快速转置得到的与相加得到的三元组顺序表及其矩阵形式。

  #include "stdio.h"
  #include "stdlib.h"
  #include "time.h"
  #define maxsize 12500 
  
  typedef struct{
      int i;//元素的行下标 
      int j;//元素的列下标 
      int v;//元素的值 
  
  }Triple;
  //定义三元组
  typedef struct{
      Triple  data[maxsize+1];  // data[0]未用
      int  mu,nu,tu;//元素的总行数，总列数，不为0元素个数 
  }TSMatrix;
  //动态二维数组生成随机矩阵 
  int **RandomMatrix(int M,int N){
  	int **a;
  	int i, j; 
  	a=(int **)malloc(M*sizeof(int*));
  	for(i=0;i<M;i++)
  		a[i]=(int *)malloc(N*sizeof(int));
                                                       
      srand((unsigned)time(0));                                                          
      for (i = 0; i < M; ++i)            
      {                                  
          for (j = 0; j <= N; ++j)
          { 
  			a[i][j] = rand() % 10;                      
          }                              
      }                                                                     
  	return a;                                  
  }
  //打印矩阵 
  void printMatrix(int **a,int M,int N){
  	int i,j;
  	for (i = 0; i <M; ++i)            
      {                                  
          for (j = 0; j <N; ++j)        
          {                              
              printf("%d\t", a[i][j]); 
          }                              
          printf("\n");                  
      }
  }
  //打印三元组 
  void printTSMatrix(TSMatrix M){
  	
  	int t;
  	for(t=1;t<=M.tu;t++){      
  		printf("%d %d %d \n",M.data[t].i,M.data[t].j,M.data[t].v);
  	}
  }
  //把矩阵转化成三元组形式 
  TSMatrix changeToTSMatrix(int **a,int MA,int NA){
  	TSMatrix M;
  	int H,L;
  	int i,j,t;
  	t=1;//三元组的位置 
  	M.tu=0;
  	M.mu=MA;
  	M.nu=NA;
  	for(i=0;i<M.mu;i++){
  		for(j=0;j<M.nu;j++){
  			if(a[i][j]!=0){
  				M.data[t].i=(i+1);
  				M.data[t].j=(j+1); 
  				M.data[t].v=a[i][j];
  				t++;
  				M.tu++;
  			}
  		}
  	}
  	printTSMatrix(M);
  	return M;
  }
  //快速转置
  void kszzTSMatrix(TSMatrix M,TSMatrix *T){
  	//初始化T（行数、列数、元素个数）
  	int q,p,col;
  	int num[100];
  	int cpot[100];
  	T->mu=M.nu;
  	T->nu=M.mu;
  	T->tu=M.tu; 
  	if(T->tu>0){
  		for(col=1;col<=M.nu;col++) num[col]=0;//初始化求num[] 为0 
  			for(p=1;p<=M.tu;p++)	num[M.data[p].j]++;//求每一列的num[]，即求出每一列的有值元素的个数 
  		//求cpot[]
  		cpot[1]=1;
  		for(col=2;col<=M.nu;col++)//求出每一列的第一个元素在顺序表中的位置 
  			cpot[col]=cpot[col-1]+num[col-1];
  			//这一列首元素的存放位置等于上一列的首元素的存放位置+上一列的元素个数 
  		
  		for(p=1;p<=M.tu;p++){//元素的转置 
  			col= M.data[p].j;
  			q=cpot[col];
  			T->data[q].i=M.data[p].j;
  			T->data[q].j=M.data[p].i;
  			T->data[q].v=M.data[p].v;
  			cpot[col]++;//把当前一列元素的位置后移一个单位 
  		}
  		printf("");
  	}
  }
   
  int cmp(Triple c1,Triple c2){
  	if(c1.i==c2.i){
  		if(c1.j==c2.j){
  			return 0;
  		} 
  		else if(c1.j<c2.j){
  				return -1;
  			}	
  			 else{
  			 	return 1;
  			 }
  			
  	}
  	else if(c1.i<c2.i){
  			return -1;
  		} 
  		
  		else{
  			return 1;
  		} 
  					
  }
  //三元组相加 
  int addTSMatrix(TSMatrix A,TSMatrix B,TSMatrix *C){
  	int i,j;
  	int p=1,q=1;
  	C->tu=1;
  	while((p<=A.tu)&&(q<=B.tu)){
  		if(cmp(A.data[p],B.data[q])==-1){
  			C->data[C->tu].i=A.data[p].i;
  			C->data[C->tu].j=A.data[p].j;
  			C->data[C->tu++].v=A.data[p].v;
  			p++;
  		}
  		if(cmp(A.data[p],B.data[q])==1){
  				C->data[C->tu].i=B.data[q].i;//
  				C->data[C->tu].j=B.data[q].j;//
  				C->data[C->tu++].v=B.data[q].v;
  				q++;
  		}
  		if(cmp(A.data[p],B.data[q])==0){
  				C->data[C->tu].i=A.data[p].i;
  				C->data[C->tu].j=A.data[p].j;
  				C->data[C->tu++].v=A.data[p].v+B.data[q].v;
  				p++;
  				q++;
  			}
  	}
  	C->mu=A.mu;
  	C->nu=A.nu;
  	while((p<=A.tu)){
  		C->data[C->tu].i=A.data[p].i;
  		C->data[C->tu].j=A.data[p].j;
  		C->data[C->tu++].v=A.data[p].v;
  		p++;
  		C->mu=A.mu;
  		C->nu=A.nu;
  	} 
  	while((q<=B.tu)){
  		C->data[C->tu].i=B.data[q].i;
  		C->data[C->tu].j=B.data[q].j;
  		C->data[C->tu++].v=B.data[q].v;
  		q++;
  		C->mu=B.mu;
  		C->nu=B.nu;
  	}
  	C->tu--;
  	printf("hhhhhh%d",C->tu);
  	return 0;
  }
  
  //把三元组转换成矩阵形式输出 
  void changetoMartix(TSMatrix A){
  	int p=1,row,col;
  	int d;
  	for(row=1;row<=A.mu;row++){
  		printf("\n");
  		for(col=1;col<=A.nu;col++){
  			if((A.data[p].i=row)&&(A.data[p].j==col)){
  				d=A.data[p].v;
  				p++;
  			}
  			else{
  				d=0;
  			}
  			printf(" %d ",d);
  		} 
  	}
  	printf("\n");
  }
  
  
  int main(){
  	int **A,**B;
  	TSMatrix TA,TB,TC;
  	TSMatrix TTA;//保存转置了的三元组
  	int t;
  	int MA=0,NA=0,MB=0,NB=0;                
      printf("请输入A矩阵的行数，列数：\n");
  	scanf("%d %d",&MA,&NA); 
  	A=RandomMatrix(MA,NA);
  	printf("A矩阵为：\n");
  	printMatrix(A,MA,NA);
  	printf("请输入B矩阵的行数，列数：\n");
  	scanf("%d %d",&MB,&NB); 
  	B=RandomMatrix(MB,NB);
  	printf("B矩阵为：\n");
  	printMatrix(B,MB,NB);
  
  	printf("三元组顺序表形式A为：\n");
  	TA=changeToTSMatrix(A,MA,NA);
  	printf("三元组顺序表形式B为：\n");
  	TB=changeToTSMatrix(B,MB,NB);
  	kszzTSMatrix(TA,&TTA);
  	printf("转置后的TA:\n");
  	printTSMatrix(TTA);
  	
  	addTSMatrix(TA,TB,&TC);
  	printf("A+B相加得到的三元组C：\n");
  	printTSMatrix(TC);
  
  	printf("TA的转置矩阵形式：\n");
  	changetoMartix(TTA);
  	printf("TC的矩阵形式：\n");
  	changetoMartix(TC);
  	return 0;
  }
  
  

   

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^