数据结构之压缩矩阵

定义

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

总结

压缩矩阵真的在某些特殊矩阵中节省了相当大的空间，特殊矩阵有对称矩阵，稀疏矩阵等堆成矩阵通过只储存一半的元素加对角线元素节省空间，而稀疏矩阵通过只储存非零元素来实现节省空间，真的是相当的赏心悦目。