数据结构-压缩矩阵的转置

---

结构体

typedef struct Triple
{
	int i;//记录非零元素的行
	int j;//记录非零元素的列
	int e;//记录非零元素的具体值
}Triple,*TriplePtr;

typedef struct CompressedMatrix
{
	int rows，columns，numElements;//记录未压缩的矩阵的实际行,列,非零元素个数
	Triple* elements;
}CompressedMatrix,*CompressedMatrixPtr;

压缩矩阵函数

CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData)
{
	int i;
	CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows=paraRows;
	resultPtr->columns=paraColumns;
	resultPtr->numElements=paraElements;
	resultPtr->elements=(TriplePtr)malloc(paraElements*sizeof(struct Triple));

	for(i=0;i<paraElements;i++)
	{
		resultPtr->elements[i].i=paraData[i][0];
		resultPtr->elements[i].j=paraData[i][1];
		resultPtr->elements[i].e=paraData[i][2];
	}

	return resultPtr;
}

打印压缩后的矩阵

void printCompressedMatrix(CompressedMatrixPtr paraPtr)
{
	int i;
	for(i=0;i<paraPtr->numElements;i++)
	{
		printf("(%d, %d):%d\r\n",paraPtr->elements[i].i,paraPtr->elements[i].j,paraPtr->elements[i].e);
	}
}

转置

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr)
{
	int i,tempcolumn,tempPosition;
	int *tempcolumnCounts=(int*)malloc(paraPtr->columns*sizeof(int));
	int *tempOffsets=(int*)malloc(paraPtr->columns*sizeof(int));
	 //将转置前每一列的非零元素的个数赋值为0
	for(i=0;i<paraPtr->columns;i++)
	{
		tempcolumnCounts[i]=0;
	}
	//申请转置后的压缩矩阵
	CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	//转置后的压缩矩阵的行和列与转置前的压缩矩阵的行和列进行交换
	resultPtr->rows=paraPtr->columns;
	resultPtr->columns=paraPtr->rows;
	//记录转置后压缩矩阵非0元素的个数
	resultPtr->numElements=paraPtr->numElements;
	//根据非零元素的个数申请一维数组
	resultPtr->elements=(TriplePtr)malloc(paraPtr->numElements*sizeof(struct Triple));
	//找出转置前第i列有几个非零元素
	for(i=0;i<paraPtr->numElements;i++)
	{
		tempcolumnCounts[paraPtr->elements[i].j]++;
	}
	tempOffsets[0]=0;//转置后第0行的首元素对应元素的首编号为0

	for(i=1;i<paraPtr->columns;i++)
	{
		tempOffsets[i]=tempOffsets[i-1]+tempcolumnCounts[i-1];//记录转置后第i行的首元素对应的元素的首编号
		printf("tempOffsets[%d]=%d\r\n",i,tempOffsets[i]);//打印第i行首个非零元素对应的位置
	}
	
	for(i=0;i<paraPtr->numElements;i++)
	{
		tempcolumn=paraPtr->elements[i].j;
		tempPosition=tempOffsets[tempcolumn];
		
		resultPtr->elements[tempPosition].i=paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j=paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e=paraPtr->elements[i].e;
		
		tempOffsets[tempcolumn]++;//转置后某行的首元素被占领后新的位置就要往下一位
	}
	return resultPtr;
}

完整代码

#include<stdio.h>
#include<malloc.h>

typedef struct Triple
{
	int i;
	int j;
	int e;	
}Triple,*TriplePtr;

typedef struct CompressedMatrix
{
	int rows;
	int columns;
	int numElements;
	Triple* elements;
}CompressedMatrix,*CompressedMatrixPtr;

CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData)
{
	int i;
	CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows=paraRows;
	resultPtr->columns=paraColumns;
	resultPtr->numElements=paraElements;
	resultPtr->elements=(TriplePtr)malloc(paraElements*sizeof(struct Triple));

	for(i=0;i<paraElements;i++)
	{
		resultPtr->elements[i].i=paraData[i][0];
		resultPtr->elements[i].j=paraData[i][1];
		resultPtr->elements[i].e=paraData[i][2];
	}

	return resultPtr;
}

void printCompressedMatrix(CompressedMatrixPtr paraPtr)
{
	int i;
	for(i=0;i<paraPtr->numElements;i++)
	{
		printf("(%d, %d):%d\r\n",paraPtr->elements[i].i,paraPtr->elements[i].j,paraPtr->elements[i].e);
	}
}

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr)
{
	int i,tempcolumn,tempPosition;
	int *tempcolumnCounts=(int*)malloc(paraPtr->columns*sizeof(int));
	int *tempOffsets=(int*)malloc(paraPtr->columns*sizeof(int));
	for(i=0;i<paraPtr->columns;i++)
	{
		tempcolumnCounts[i]=0;
	}
	
	CompressedMatrixPtr resultPtr=(CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows=paraPtr->columns;
	resultPtr->columns=paraPtr->rows;
	resultPtr->numElements=paraPtr->numElements;
	
	resultPtr->elements=(TriplePtr)malloc(paraPtr->numElements*sizeof(struct Triple));
	
	for(i=0;i<paraPtr->numElements;i++)
	{
		tempcolumnCounts[paraPtr->elements[i].j]++;
	}
	tempOffsets[0]=0;
	for(i=1;i<paraPtr->columns;i++)
	{
		tempOffsets[i]=tempOffsets[i-1]+tempcolumnCounts[i-1];
		printf("tempOffsets[%d]=%d\r\n",i,tempOffsets[i]);
	}
	
	for(i=0;i<paraPtr->numElements;i++)
	{
		tempcolumn=paraPtr->elements[i].j;
		tempPosition=tempOffsets[tempcolumn];
		
		resultPtr->elements[tempPosition].i=paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j=paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e=paraPtr->elements[i].e;
		
		tempOffsets[tempcolumn]++;
	}
	return resultPtr;
}

void test()
{
	CompressedMatrixPtr tempPtr1, tempPtr2;
	int i,j,tempElements;
	
	tempElements=4;
	int** tempMatrix1 =(int**)malloc(tempElements*sizeof(int*));
	for(i=0;i<tempElements;i++)
	{
		tempMatrix1[i]=(int*)malloc(3*sizeof(int));
	}
	
	int tempMatrix2[4][3]={{0,0,2},{0,2,3},{2,0,5},{2,1,6}};
	for(i=0;i<tempElements;i++)
	{
		for(j=0;j<3;j++)
		{
			tempMatrix1[i][j]=tempMatrix2[i][j];
		}
	}
	
	tempPtr1=initCompressedMatrix(2,3,4,tempMatrix1);
	printf("After initialization.\r\n");
	printCompressedMatrix(tempPtr1);
	
	tempPtr2=transposeCompressedMatrix(tempPtr1);
	printf("After transpose.\r\n");
	printCompressedMatrix(tempPtr2);

}
int main()
{
	test();
	return 0;
}

运行结果：

After initialization.
(0, 0):2
(0, 2):3
(2, 0):5
(2, 1):6
tempOffsets[1]=2
tempOffsets[2]=3
After transpose.
(0, 0):2
(0, 2):5
(1, 2):6
(2, 0):3