利用线性表压缩稀疏矩阵

稀疏矩阵，就是矩阵中的大多数元素为0，只有少量的非0元素。对于这种矩阵，直接存储就有点浪费空间了，更好的办法就是定义一个结构体，结构体中的3个成员对应于非0元素的位置以及非0元素的值。然后在加上一些附加的信息，比如矩阵的大小、非0元素的个数等等。听起来挺简单的，但是写起来还是挺复杂的：

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>//使用随机数调用
#include <time.h>//通过时间生成随机数种子

typedef int Elemtype;

//表示稀疏矩阵的3元组：行号、列号，元素值
typedef struct Triple
{
int m;
int n;
Elemtype val;
}Triple;

//使用线性表存储这些3元组
typedef struct compressedSparseMatrix
{
Triple *data;
int len;//非0元素的个数
//稀疏矩阵的行、列
//它们并不是必须的，但是可以通过它们较快的通过压缩的线性表来恢复一个稀疏矩阵
int row;
int col;
}compressedSparseMatrix;

//创建稀疏矩阵
void createSparseMatrix(Elemtype ***sparseMatrix,int row, int col,int number)
{

//创建矩阵
*sparseMatrix = (Elemtype**)malloc(sizeof(Elemtype*) * row);
for(int i = 0; i < row;++i)
(*sparseMatrix)[i] = (Elemtype*)malloc(sizeof(Elemtype) * col);

//如果有非0值，才初始化，否则sparseMatrix带出去的是一个分配好内存的2维数组
if(number != 0)
{
//矩阵初始化为0
for(int i = 0; i < row; ++i)
for(int j = 0; j< col;++j)
(*sparseMatrix)[i][j] = 0;

//利用时间初始化随机数种子
srand( (unsigned )(time(NULL)));
//产生number次随机数
//利用随机数给m、n赋值，来确定非0成员的位置

int m = 0;
int n = 0;
for(int i = 0; i < number;++i)
{
m = rand()%row;
n = rand()%col;
//将元素值控制在1~10以内
(*sparseMatrix)[m]
= rand()%10+1;
}

//打印稀疏矩阵
for(int i = 0; i < row; ++i)
{
for(int j = 0; j< col;++j)
{
printf("%d\t",(*sparseMatrix)[i][j]);
}
printf("\n");
}
}

}

//销毁稀疏矩阵
void destroySparseMatrix(Elemtype ***sparseMatrix,int row, int col)
{
for(int i = 0; i < row;++i)
free((*sparseMatrix)[i]);
free((*sparseMatrix));
}

//用一个稀疏矩阵初始化压缩矩阵
bool initCompressedSparseMatrix(compressedSparseMatrix* CSM,Elemtype ***sparseMatrix,int row, int col,int number)
{
//初始化compressedSparseMatrix结构
CSM->data = (Triple*)malloc(sizeof(Triple) * number);
if(NULL == CSM->data)
return false;
CSM->len = number;
CSM->row = row;
CSM->col = col;

//将稀疏矩阵变为compressedSparseMatrix结构
int k = 0;
for(int i= 0; i < CSM->row;++i)
for(int j = 0; j < CSM->col;++j)
{
if((*sparseMatrix)[i][j] != 0)
{
CSM->data[k].val = (*sparseMatrix)[i][j];
CSM->data[k].m = i;
CSM->data[k].n = j;
++k;
}

}
return true;
}

//销毁压缩的稀疏矩阵
void destroyCompressedSparseMatrix(compressedSparseMatrix* CSM)
{
free(CSM->data);
CSM->data = NULL;
}
//打印压缩的稀疏矩阵
void printCompressedSparseMatrix(compressedSparseMatrix* CSM)
{
for(int i = 0;i < CSM->len;++i)
{

printf("第%d行%d列的元素为： %d",CSM->data[i].m,CSM->data[i].n,CSM->data[i].val);
printf("\n");
}
}

//通过线性表恢复稀疏矩阵
void transCPM2SM(compressedSparseMatrix *CMP,Elemtype ***sparseMatrix)
{
int k = 0;
for(int i = 0; i< CMP->row;++i)
{
for(int j = 0; j < CMP->col;++j)
{
if(i == CMP->data[k].m && j == CMP->data[k].n)
{
(*sparseMatrix)[i][j] = CMP->data[k++].val;

}
else
(*sparseMatrix)[i][j] = 0;
}
}
//打印转化好的稀疏矩阵
for(int i = 0; i < CMP->row; ++i)
{
for(int j = 0; j< CMP->col;++j)
{
printf("%d\t",(*sparseMatrix)[i][j]);
}
printf("\n");
}

}

 

在主函数中：

int main()
{
Elemtype **mySparseMatrix;
createSparseMatrix(&mySparseMatrix,4,6,5);
compressedSparseMatrix myCSM;
initCompressedSparseMatrix(&myCSM,&mySparseMatrix,4,6,5);
printCompressedSparseMatrix(&myCSM);
Elemtype **mySparseMatrix1;
createSparseMatrix(&mySparseMatrix1,4,6,0);
transCPM2SM(&myCSM,&mySparseMatrix1);
destroyCompressedSparseMatrix(&myCSM);
destroySparseMatrix(&mySparseMatrix1,4,6);
destroySparseMatrix(&mySparseMatrix,4,6);
return 0;
}

这样定义以后，稀疏矩阵的一些数学操作也会变得非常方便：矩阵的转置只是将结构体中位置信息的行、列交换一下顺序；矩阵的加法、减法也是对应位置的元素的相加减，值得注意的是，运算完毕后，需要判断结果是否为0。