C语言数据结构

压缩矩阵实际上就是将一个二维矩阵的非零元素单独记录并存储与之对应的行和列。

例如：

压缩矩阵的转置：就是将压缩矩阵的行和列交换就可以了，实际的操作就是将转置前的每一列的非零元素记录下来，然后再计算对应的转置后的压缩矩阵每一行对应的首元素的首个相对地址，然后将转置前的第i列赋值给转置后的第i行。注意的是如果转置后的某一行已经赋值了一个元素那么该行的首个元素的相对地址就要加一。

例如：

#include 
#include 

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;

//计算paraData矩阵的非零元素个数函数
int calculateNumElenent(int paraRows,int paraColumns,int **paraData)
{
    int numElement = 0;
    for(int i = 0; i < paraRows; i++)
    {
        for(int j = 0; j < paraColumns; j++)
        {
            if(paraData[i][j] != 0)
            {
                numElement++;
            }
        }
    }
    return numElement;
}

//压缩矩阵函数
CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int** paraData)
{
	int numElements = 0;//编号非零元素

	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));

    //将压缩前的矩阵行和列存储在压缩矩阵
	resultPtr->rows = paraRows;
	resultPtr->columns = paraColumns;

	int paraElement = calculateNumElenent(paraRows,paraColumns,paraData);//记录非零元素的个数

	resultPtr->elements = (TriplePtr)malloc(paraElement * sizeof(struct Triple));//根据非零元素的个数来分配压缩矩阵的空间大小

    //压缩矩阵
	for(int i = 0; i < paraRows; i ++)
    {
        for(int j = 0; j < paraColumns; j++)
        {
            if(paraData[i][j] != 0)
            {
                resultPtr->elements[numElements].i = i;
                resultPtr->elements[numElements].j = j;
                resultPtr->elements[numElements].e = paraData[i][j];
                numElements++;
            }
        }
	}

    resultPtr->numElements = numElements;//存储压缩矩阵中非零元素的个数

	return resultPtr;
}

//打印压缩后的矩阵函数
void printCompressedMatrix(CompressedMatrixPtr paraPtr)
{
	for(int i = 0; i < paraPtr->numElements; i ++)
    {
		printf("(%d, %d): %drn", 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 rn", 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;
}


void compressedMatrixTest()
{
	CompressedMatrixPtr tempPtr1, tempPtr2;

	//建立一个4 * 3的矩阵
	int** tempMatrix1 = (int**)malloc(4 * sizeof(int*));
	for(int i = 0; i < 4; i ++){
		tempMatrix1[i] = (int*)malloc(3 * sizeof(int));
	}
    
    //打印tempMatrix1矩阵
	int tempMatrix2[4][3] = {{0, 0, 2}, {0, 2, 3}, {2, 0, 5}, {2, 1, 6}};
    for(int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            printf("%d ",tempMatrix2[i][j]);
        }
        printf("n");
    }
    printf("n");

    //将矩阵tempMatrix1的值赋值给矩阵tempMatrix2
	for(int i = 0; i < 4; i ++)
    {
		for(int j = 0; j < 3; j ++) {
			tempMatrix1[i][j] = tempMatrix2[i][j];
		}
	}

    //打印矩阵tempMatrix2
	for(int i = 0; i < 4; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            printf("%d ",tempMatrix1[i][j]);
        }
        printf("n");
    }

	tempPtr1 = initCompressedMatrix(4, 3, tempMatrix1);

	printf("After initialization.rn");
	printCompressedMatrix(tempPtr1);

	tempPtr2 = transposeCompressedMatrix(tempPtr1);
	printf("After transpose.rn");
	printCompressedMatrix(tempPtr2);
}

int main(){
	compressedMatrixTest();

	return 1;
}

运算结果

0 0 2 
0 2 3
2 0 5
2 1 6

0 0 2
0 2 3
2 0 5
2 1 6
After initialization.
(0, 2): 2
(1, 1): 2
(1, 2): 3
(2, 0): 2
(2, 2): 5
(3, 0): 2
(3, 1): 1
(3, 2): 6
tempOffsets[1] = 2
tempOffsets[2] = 4
After transpose.
(0, 2): 2
(0, 3): 2
(1, 1): 2
(1, 3): 1
(2, 0): 2
(2, 1): 3
(2, 2): 5
(2, 3): 6
PS D:Data StructionweekFourstudent>