利用线性表压缩稀疏矩阵

稀疏矩阵，就是矩阵中的大多数元素为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][n] = 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。