对称矩阵、对角矩阵、稀疏矩阵等特殊矩阵的压缩存储方式

川长思鸟来 2021-12-09 07:09 363阅读 0赞

## 稀疏矩阵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;
    }