代码:
#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(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 compressedMatrixTest(){
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(){
compressedMatrixTest();
return 1;
}
运行结果:
压缩矩阵的转置的心得
在矩阵运算中,矩阵的转置是一个基本的操作,它将矩阵的行和列进行互换。然而,当涉及到压缩矩阵(如稀疏矩阵)的转置时,我们需要考虑一些额外的因素,以优化存储和计算效率。以下是我对压缩矩阵转置操作的一些心得:
理解稀疏矩阵的特性:
稀疏矩阵是那些大部分元素都是零,只有少数元素是非零的矩阵。这种特性使得在存储和计算时,我们可以只关注那些非零元素,从而提高效率。在进行转置操作时,这一特性仍然保留,但我们需要以新的方式重新组织这些非零元素。
选择合适的压缩存储方式:
对于稀疏矩阵,有多种压缩存储方式,如三元组表示法(COO)、压缩稀疏行(CSR)或压缩稀疏列(CSC)等。不同的存储方式适用于不同的应用场景。在进行转置操作时,选择合适的存储方式可以大大提高效率。例如,如果原始矩阵是以CSR格式存储的,那么转置后的矩阵更适合以CSC格式存储,因为CSR和CSC在行和列上的存储顺序是相反的。
优化转置算法:
对于稀疏矩阵的转置,我们不能简单地逐行或逐列地交换元素,因为这会导致大量的无效操作(即处理零元素)。相反,我们应该只关注那些非零元素,并找到一种高效的方式来重新组织它们。这通常涉及到遍历原始矩阵的非零元素,并根据它们在转置矩阵中的新位置进行存储。
考虑内存管理:
在进行稀疏矩阵的转置时,我们可能需要重新分配内存来存储转置后的矩阵。这涉及到对内存的有效管理,以避免内存泄漏或不必要的内存分配。一种常见的策略是在转置操作之前预先分配足够的内存,并在操作完成后释放不再需要的内存。