数据结构--3.3 矩阵转置

1.稀疏矩阵的压缩存储，至少需要存储以下信息：
矩阵中各非 0 元素的值，以及所在矩阵中的行标和列标；
矩阵的总行数和总列数；

上图是一个稀疏矩阵，若对其进行压缩存储，矩阵中各非 0 元素的存储状态如图 2 所示：

图 2 的数组中，存储的是三元组（即由 3 部分数据组成的集合），组中数据分别表示（行标，列标，元素值）。
2、矩阵（包括稀疏矩阵）的转置，即互换矩阵中所有元素的行标和列标


图 2a) 表示的是图 1 中转置之前矩阵的三元组表，2b) 表示的是图 1 中矩阵转置后对应的三元组表。
矩阵转置的实现过程需完成以下 3 步：
1.将矩阵的行数和列数互换；
2.将三元组表（存储矩阵）中的 i 列和 j 列互换，实现矩阵的转置；
3.以 j 列为序，重新排列三元组表中存储各三元组的先后顺序；
矩阵转置的实现思路是：不断遍历存储矩阵的三元组表，每次都取出表中 j 列最小的那一个三元组，互换行标和列标的值，并按次序存储到一个新三元组表中，。

例如，将图 2a) 三元组表存储的矩阵进行转置的过程为：
1.新建一个三元组表（用于存储转置矩阵），并将原矩阵的行数和列数互换赋值给新三元组；
2.遍历三元组表，找到表中 j 列最小值 1 所在的三元组 (3,1,6)，然后将其行标和列标互换后添加到一个新的三元组表中，如图 3 所示：

3.继续遍历三元组表，找到表中 j 列次小值为 2 的三元组，分别为 (1,2,1)、(2,2,3) 和 (3,2,5)，根据找到它们的先后次序将各自的行标和列标互换后添加到新三元组表中，如图 4 所示：

对比图 4 和图 2b) 可以看到，矩阵被成功地转置。

全部代码如下：

结构体创建

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

typedef int elem;

typedef struct Triple{
	int i;
	int j;
	elem 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(CompressedMatrix));
	resultPtr->rows = paraRows;
	resultPtr->columns = paraColumns;
	resultPtr->numElements = paraElements;
	resultPtr->elements = (TriplePtr)malloc(paraElements*sizeof(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;
}

转置

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(CompressedMatrix));
	resultPtr->rows = paraPtr->columns ;
	resultPtr->columns = paraPtr->rows ;
	resultPtr->numElements = paraPtr->numElements ;
	
	resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements *sizeof(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 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 );
	}
}

测试代码

void compressedMatrixTest(){
	CompressedMatrixPtr tempPtr1, tempPtr2;
	int i, j, tempElements;

	//Construct the first sample matrix.
	tempElements = 4;
	int** tempMatrix1 = (int**)malloc(tempElements * sizeof(int*));
	for(i = 0; i < tempElements; i ++){
		tempMatrix1[i] = (int*)malloc(3 * sizeof(int));
	}//Of for i

	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];
		}//Of for j
	}//Of for i
	
	tempPtr1 = initCompressedMatrix(2, 3, 4, tempMatrix1);

	printf("After initialization.\r\n");
	printCompressedMatrix(tempPtr1);

	tempPtr2 = transposeCompressedMatrix(tempPtr1);
	printf("After transpose.\r\n");
	printCompressedMatrix(tempPtr2);
}

运行结果

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